如何在 JDK8 中通过反射将 Lambda 表达式作为方法参数传递

Question

在 JDK 8 中，我可以使用反射来调用具有 FunctionalInterface 参数的方法，并传递一个 Lambda 表达式。例如，这是可行的。

import java.util.function.IntPredicate;  
import java.lang.reflect.Method;

public class LambdaReflect {

    public static void main(String args[]) {
        System.out.println(test(x->true));
        // Now do this in reflection
        Class<LambdaReflect> thisC = LambdaReflect.class;
        Method meths[] = thisC.getDeclaredMethods();
        Method m = meths[1];  // test method
        try {
            IntPredicate lamb = x->true;
            boolean result = (Boolean) m.invoke(null, lamb);
            System.out.println(result);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    public static boolean test(IntPredicate func) {
        return func.test(1);
    }
}

但是，如果参数类型仅在运行时已知，我如何将 lambda 表达式传递给方法？也就是说，如果我在编译的时候不知道方法的参数类型，只知道它是一个函数式接口，我可以用反射用lambda表达式调用它吗？

Answer 1

在编译时不知道目标类型的情况下，您无法创建 lambda 表达式。但是您可以将 lambda 的代码放入一个方法中，并创建对该方法的方法引用。这类似于 lambda 表达式的编译方式。不同之处在于功能接口实现是使用反射代码显式创建的：

import java.lang.invoke.*;
import java.util.function.IntPredicate;  
import java.lang.reflect.Method;

public class LambdaReflect {

    public static void main(String args[]) {
        try {
            for(Method m: LambdaReflect.class.getDeclaredMethods()) {
                if(!m.getName().equals("test")) continue;
                // we don’t know the interface at compile-time:
                Class<?> funcInterface=m.getParameterTypes()[0];
                // but we have to know the signature to provide implementation code:
                MethodType type=MethodType.methodType(boolean.class, int.class);
                MethodHandles.Lookup l=MethodHandles.lookup();
                MethodHandle target=l.findStatic(LambdaReflect.class, "lambda", type);
                Object lambda=LambdaMetafactory.metafactory(l, "test",
                    MethodType.methodType(funcInterface), type, target, type)
                .getTarget().invoke();
                boolean result = (Boolean) m.invoke(null, lambda);
                System.out.println(result);
                break;
            }
        } catch (Throwable ex) {
            ex.printStackTrace();
        }
    }

    private static boolean lambda(int x) { return true; }

    public static boolean test(IntPredicate func) {
        return func.test(1);
    }
}

---

如果你想实现任意函数签名（这意味着实现相当简单，不依赖于未知参数），你可以使用MethodHandleProxies。不同之处在于 MethodHandle 不需要是 direct 的，即不需要代表一个真实的方法。所以你可以创建一个handle invariably returning a constant 并使用dropArguments 插入额外的形式参数，直到你拥有一个可以传递给asInterfaceInstance 的具有正确功能签名的句柄

Answer 2

您始终可以使用允许编译器推断功能接口的类型转换来指示 lambda 表达式：

m.invoke(null, (IntPredicate) (x -> true));

但是，如果您对签名非常了解，为什么还要使用反射呢？如果要生成接口的运行时实现，则应使用运行时生成的类来实现接口。为此，请查看 Java 代理或我的库 Byte Buddy。这样，您可以提供如下参数：

IntPredicate instance = new ByteBuddy()
  .subclass(IntPredicate.class)
  .method(named("test")).intercept(FixedValue.value(true));
  .make()
  .load(getClass().getClassLoader(), ClassLoadingStrategy.Default.WRAPPER)
  .getLoadedClass()
  .newInstance();
 m.invoke(null, instance);