当我不知道它是否是预先的 lambda 时，如何安全地代理 lambda？

Question

我们有一些遗留的反射代理生成代码，如果你把它看成一个黑盒子，它们基本上是这样工作的：

Object someObject = new Anything();
Object debugObject = ProxyUtils.wrapWithDebugLogging(someObject);

wrapWithDebugLogging 接受任何对象并覆盖它可以的任何方法（如果你正在扩展一个真实的类，最终方法显然是无法修复的），拦截它以记录有关调用的消息，然后调用真实的方法。

在内部，它使用 cglib 来完成工作，并且在构造代理之前有一些保护性逻辑，因为匿名类是最终的，但可以通过使用它们实现的超类或单个接口来处理：

Class<?> clazz = someObject.getClass();
Class<?> interfaces = clazz.getInterfaces();

// Anonymous classes are final so you can't extend them, but we know they only have one
// superclass or one interface.
if (clazz.isAnonymousClass()) {
    clazz = interfaces.length > 0 ?
            interfaces[0] : primaryType.getSuperclass();
}

Enhancer enhancer = new Enhancer();

if (clazz.isInterface()) {
    interfaces.add(clazz);
} else {
    enhancer.setSuperclass(primaryType);
}
enhancer.setInterfaces(interfaces.toArray(new Class[interfaces.size()]));

问题在于 Java 8 的“lambda”类为 isAnonymousClass() 返回 false。但我们希望将它们与匿名类完全相同。

pointed out before 一直没有办法确定一个类是“设计”的 lambda 类。但这在我看来更像是反射 API 中缺少的东西，而且这肯定不是 Java 第一次“忘记”向新 API 添加明显的东西。

那么有没有一种明智的方法来区分 lambda 和非 lambda，而无需在 API 中提供此功能？我可以看到 isSynthetic() 返回 true，但它也可能对各种其他事物返回 true。

Answer 1

您不应根据是否为 ​​lambda 生成类的问题来创建条件代码。毕竟，只有类的属性很重要。

类是final，所以你不能继承它。即使不是final，子类也是不可能的，因为它只有private 构造函数。它实现了interface。这些是类的相关属性。

在没有任何 lambda 表达式的情况下遇到相同的场景并非不现实：

final class NotALambda implements Function<String,String> {

    public static final Function<String,String> INSTANCE=new NotALambda();

    private NotALambda() {}

    public String apply(String t) {
        return t.toLowerCase();
    }
}

为什么要将此类与通过
Function<String,String> f=String::toLowerCase; 生成的类区别对待？它具有相同的属性和创建代理的相同障碍。在您所说的 cmets 中，您希望根据该方法是否声明为 final 的问题有所作为。这更没有意义，因为我可以在上面示例中的方法中添加 final 修饰符，而无需更改任何内容，无论是语义还是创建代理时将面临的困难。

Answer 2

我不认为这个限制（如果你想这样称呼它）应该是一个问题。

如果您在适当的情况下对接口进行了适当的编程，则无需让您的代理具有超类（Object 除外）。在可用时设置代理的超类（没有private 构造函数，不是final 等）。

在所有情况下，您需要做的就是捕获代理对象、目标、拦截其上的所有方法调用、进行日志记录，然后将调用委托或路由给它。

public static Object wrapWithDebugLogging(Object target) {
    ... // prepare the enhancer as described above
    enhancer.setCallback(new MethodInterceptor() {        
        @Override
        public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
            logger.debug("Some useful logging message.");
            return method.invoke(target, args);            
        }
    });
    return enhancer.create();
}

调用的方法是否为final 无关紧要，你不是要覆盖它，你只是在拦截它。

Answer 3

以下是快速实验的结果。 foo 方法只输出其参数的getClass().toString()。 （getClass().getName() 输出相同的结果。）

    foo (new Runnable() {
            @Override
            public void run() {
                System.out.println("run");
            }
         });

输出：Test32$1

    foo (() -> System.out.println("run"));

输出：Test32$$Lambda$1/640070680

不保证它的便携性。