如何结合LambdaMetaFactory处理带泛型的静态方法？

一、错误核心原因 #

你遇到的调用失败，本质是LambdaMetafactory的方法类型参数违反了泛型擦除规则：

• 自定义函数式接口ProcessInterface<T>经过泛型擦除后，process方法的第一个参数类型是AbstractParent，而非具体子类（如ChildOne）。
• 你在创建LambdaMetafactory时，第四个参数samMethodType传入了具体子类的类型，导致生成的Lambda方法签名与接口擦除后的签名不兼容，调用时会抛出类型转换异常。

二、修复后的Lambda生成代码 #

调整generate方法中LambdaMetafactory的参数，将samMethodType改为泛型擦除后的统一类型，同时补充必要的方法校验：

public static List<ProcessInterface<? extends AbstractParent>> generate(Class<?> targetClass) throws Throwable {
    ArrayList<ProcessInterface<? extends AbstractParent>> processors = new ArrayList<>();
    for (Method method : targetClass.getDeclaredMethods()) {
        // 补充校验：确保方法是静态的、返回值为String
        if (method.isAnnotationPresent(ProcessAnnotation.class) &&
            method.isStatic() &&
            method.getParameterCount() == 2 &&
            AbstractParent.class.isAssignableFrom(method.getParameterTypes()[0]) &&
            method.getParameterTypes()[1] == String.class &&
            method.getReturnType() == String.class) {
            
            MethodHandles.Lookup lookup = MethodHandles.lookup();
            MethodHandle handle = lookup.unreflect(method);
            
            // 泛型擦除后的函数式接口方法签名：(AbstractParent, String) -> String
            MethodType samMethodType = MethodType.methodType(String.class, AbstractParent.class, String.class);
            // 目标方法的实际签名：(ChildOne/ChildTwo, String) -> String
            MethodType implMethodType = handle.type();
            
            CallSite callSite = LambdaMetafactory.metafactory(
                lookup,
                "process",
                MethodType.methodType(ProcessInterface.class),
                samMethodType,  // 必须使用擦除后的统一类型
                handle,
                implMethodType
            );
            
            ProcessInterface<? extends AbstractParent> func = 
                (ProcessInterface<? extends AbstractParent>) callSite.getTarget().invoke();
            processors.add(func);
        }
    }
    return processors;
}

修复后，原调用代码即可正常执行，触发对应子类的处理逻辑：

List<ProcessInterface<? extends AbstractParent>> interfaces = generate(GeneralProcessor.class);
ChildOne childOne = new ChildOne();
interfaces.get(0).process(childOne, "prefix-");

三、更优实现方案 #

1. 按子类类型分组存储处理器 #

如果需要精准匹配子类与处理器，建议将结果存储为Map，避免手动索引的麻烦：

public static Map<Class<? extends AbstractParent>, ProcessInterface<?>> generateTypedProcessors(Class<?> targetClass) throws Throwable {
    Map<Class<? extends AbstractParent>, ProcessInterface<?>> processorMap = new HashMap<>();
    MethodHandles.Lookup lookup = MethodHandles.lookup();
    
    for (Method method : targetClass.getDeclaredMethods()) {
        if (method.isAnnotationPresent(ProcessAnnotation.class) &&
            method.isStatic() &&
            method.getParameterCount() == 2 &&
            AbstractParent.class.isAssignableFrom(method.getParameterTypes()[0]) &&
            method.getParameterTypes()[1] == String.class &&
            method.getReturnType() == String.class) {
            
            Class<? extends AbstractParent> paramType = (Class<? extends AbstractParent>) method.getParameterTypes()[0];
            MethodHandle handle = lookup.unreflect(method);
            
            MethodType samMethodType = MethodType.methodType(String.class, AbstractParent.class, String.class);
            CallSite callSite = LambdaMetafactory.metafactory(lookup, "process", MethodType.methodType(ProcessInterface.class), samMethodType, handle, handle.type());
            
            processorMap.put(paramType, (ProcessInterface<?>) callSite.getTarget().invoke());
        }
    }
    return processorMap;
}

调用时直接按类型获取：

Map<Class<? extends AbstractParent>, ProcessInterface<?>> processorMap = generateTypedProcessors(GeneralProcessor.class);
((ProcessInterface<ChildOne>) processorMap.get(ChildOne.class)).process(childOne, "prefix-");

2. 直接使用MethodHandle替代Lambda生成 #

如果不需要生成ProcessInterface实例，也可以直接存储适配后的MethodHandle，性能更优：

public static Map<Class<? extends AbstractParent>, MethodHandle> generateMethodHandles(Class<?> targetClass) throws Throwable {
    Map<Class<? extends AbstractParent>, MethodHandle> handleMap = new HashMap<>();
    MethodHandles.Lookup lookup = MethodHandles.lookup();
    
    for (Method method : targetClass.getDeclaredMethods()) {
        if (method.isAnnotationPresent(ProcessAnnotation.class) &&
            method.isStatic() &&
            method.getParameterCount() == 2 &&
            AbstractParent.class.isAssignableFrom(method.getParameterTypes()[0]) &&
            method.getParameterTypes()[1] == String.class &&
            method.getReturnType() == String.class) {
            
            Class<? extends AbstractParent> paramType = (Class<? extends AbstractParent>) method.getParameterTypes()[0];
            MethodHandle handle = lookup.unreflect(method);
            // 适配为统一的方法签名，方便调用
            MethodHandle adaptedHandle = handle.asType(MethodType.methodType(String.class, AbstractParent.class, String.class));
            handleMap.put(paramType, adaptedHandle);
        }
    }
    return handleMap;
}

调用示例：

Map<Class<? extends AbstractParent>, MethodHandle> handleMap = generateMethodHandles(GeneralProcessor.class);
String result = (String) handleMap.get(ChildOne.class).invoke(childOne, "prefix-");

3. 缓存处理器实例 #

如果多次调用生成方法，建议缓存生成的ProcessInterface或MethodHandle实例，避免重复生成Lambda或反射操作，提升性能。

四、关键校验补充 #

• 必须检查方法是否为静态：你的原代码未显式校验method.isStatic()，如果混入非静态方法会导致unreflect失败。
• 严格校验返回值：补充method.getReturnType() == String.class，避免不符合规则的方法被误处理。

内容的提问来源于stack exchange，提问作者TypeMonkey