Java：如何解析 lambda 参数的泛型类型？

Question

嗯，我们有FunctionalInterface：

public interface Consumer<T> {

    void accept(T t);

}

我可以像这样使用它：

.handle(Integer p -> System.out.println(p * 2));

我们如何在代码中解析该 lambda 参数的实际 generic type？

当我们将它用作内联实现时，从该类的方法中提取Integer 并不难。

我错过了什么吗？或者只是 java 不支持 lambda 类？

为了更干净：

该 lambda 用 MethodInvoker 包装（在提到的 handle 中），它在其 execute(Message<?> message) 中提取实际参数以用于进一步的反射方法调用。在此之前，它使用 Spring 的 ConversionService 将提供的参数转换为目标参数。

本例中的方法handle是在真正的应用程序工作之前的一些配置器。

不同的问题，但对同一问题的解决方案的期望：Java: get actual type of generic method with lambda parameter

Answer 1

我最近添加了对 TypeTools 解析 lambda 类型参数的支持。例如：

MapFunction<String, Integer> fn = str -> Integer.valueOf(str);
Class<?>[] typeArgs = TypeResolver.resolveRawArguments(MapFunction.class, fn.getClass());

解析的类型参数符合预期：

assert typeArgs[0] == String.class;
assert typeArgs[1] == Integer.class;

注意：底层实现使用 @danielbodart 概述的 ConstantPool 方法，已知该方法适用于 Oracle JDK 和 OpenJDK。

Answer 2

目前这是可以解决的，但只能以一种非常老套的方式解决，但让我先解释一下：

当您编写 lambda 时，编译器会插入一个指向 LambdaMetafactory 的动态调用指令和一个带有 lambda 主体的私有静态合成方法。常量池中的合成方法和方法句柄都包含泛型类型（如果 lambda 使用该类型或在您的示例中是显式的）。

现在在运行时调用 LambdaMetaFactory 并使用 ASM 生成一个类，该类实现功能接口，然后方法体调用私有静态方法并传递任何参数。然后使用Unsafe.defineAnonymousClass（参见John Rose post）将其注入原始类，以便它可以访问私有成员等。

不幸的是，生成的 Class 不存储通用签名（它可以）所以你不能使用通常的反射方法来绕过擦除

对于普通类，您可以使用 Class.getResource(ClassName + ".class") 检查字节码，但对于使用 Unsafe 定义的匿名类，您就不走运了。但是，您可以使用 JVM 参数使 LambdaMetaFactory 转储它们：

java -Djdk.internal.lambda.dumpProxyClasses=/some/folder

通过查看转储的类文件（使用javap -p -s -v），可以看到它确实调用了静态方法。但问题仍然是如何从 Java 本身中获取字节码。

不幸的是，这就是它的难点：

使用反射，我们可以调用Class.getConstantPool，然后访问 MethodRefInfo 以获取类型描述符。然后我们可以使用 ASM 来解析它并返回参数类型。把它们放在一起：

Method getConstantPool = Class.class.getDeclaredMethod("getConstantPool");
getConstantPool.setAccessible(true);
ConstantPool constantPool = (ConstantPool) getConstantPool.invoke(lambda.getClass());
String[] methodRefInfo = constantPool.getMemberRefInfoAt(constantPool.size() - 2);

int argumentIndex = 0;
String argumentType = jdk.internal.org.objectweb.asm.Type.getArgumentTypes(methodRef[2])[argumentIndex].getClassName();
Class<?> type = (Class<?>) Class.forName(argumentType);

根据乔纳森的建议更新

现在理想情况下，LambdaMetaFactory 生成的类应该存储泛型类型签名（我可能会看看是否可以向 OpenJDK 提交补丁），但目前这是我们能做的最好的事情。上面的代码存在以下问题：

• 它使用未记录的方法和类
• 它极易受到 JDK 中代码更改的影响
• 它不保留泛型类型，因此如果将 List 传递给 lambda，它将以 List 的形式出现

Answer 3

使用 TypeRef 包装 lambda 表达式。

public interface Factory<T> {
    T create();
}

public abstract class TypeRef<T> {
    protected TypeRef(Factory<T> factory) {}

    public Class<?> getGenericType() {
        return (Class<?>) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0];
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println(getFactoryTypeParameter(new TypeRef<>(() -> "hello"){}));
    }

    private static <T> Class<?> getFactoryTypeParameter(TypeRef<T> typeRef) {
        return typeRef.getGenericType();
    }
}

输出：

class java.lang.String