Java中如何校验Runnable实例绑定的具体方法值

Java中每次对lambda表达式、方法引用（比如c2::f）求值时，JVM会通过invokedynamic动态生成匿名类实例，Java语言规范不保证两次求值得到的实例满足equals()相等，也不保证实例地址相同。直接用isEqualTo()比对本质走的是对象默认相等判断，自然会出现两个Lambda实例地址不匹配的报错——哪怕两个实例绑定的是同一个对象的同一个方法。
C#的委托在语言层面原生实现了相等逻辑，会自动比对绑定的目标对象、方法签名，Java的函数式接口默认没有这套逻辑，因此直接比对无法生效。

方案1：行为验证（单元测试场景首选，无侵入、兼容性最好） #

单元测试不需要死磕实例身份相等，核心是验证行为符合预期：只要执行c1.r时确实调用了c2.f()，就说明赋值正确。直接用Mock框架做行为校验即可，以Mockito为例：

// 生成c2的spy对象，用来监听方法调用
C2 spyC2 = Mockito.spy(new C2());
c1.r = spyC2::f;

// 执行待验证的逻辑
c1.r.run();

// 验证f()确实被调用了1次，证明r绑定的就是spyC2的f方法
Mockito.verify(spyC2, Mockito.times(1)).f();

这种写法不依赖JDK内部实现，不需要修改业务代码类型，是工业界单元测试的常规做法。

方案2：自定义可比对的函数式接口（适合事件解耦的业务场景） #

如果你接受调整Runnable类型定义，可以自己实现带相等判断的函数式接口，内部存储绑定的目标对象、方法元数据，重写equals和hashCode逻辑：

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Objects;

@FunctionalInterface
public interface EventRunnable {
    void run();

    // 工厂方法，绑定目标对象和方法，自动存储元数据
    static EventRunnable bind(Object target, String methodName) throws NoSuchMethodException {
        Method boundMethod = target.getClass().getMethod(methodName);
        boundMethod.setAccessible(true);

        return new EventRunnable() {
            // 存储绑定的元数据，用于相等判断
            private final Object target = target;
            private final Method method = boundMethod;

            @Override
            public void run() {
                try {
                    method.invoke(target);
                } catch (ReflectiveOperationException e) {
                    throw new RuntimeException(e);
                }
            }

            @Override
            public boolean equals(Object o) {
                if (this == o) return true;
                if (!(o instanceof EventRunnable other)) return false;
                try {
                    // 取出另一个实例绑定的元数据做比对
                    Field otherTargetField = other.getClass().getDeclaredField("target");
                    Field otherMethodField = other.getClass().getDeclaredField("method");
                    otherTargetField.setAccessible(true);
                    otherMethodField.setAccessible(true);
                    return Objects.equals(target, otherTargetField.get(other))
                            && Objects.equals(method, otherMethodField.get(other));
                } catch (Exception e) {
                    return false;
                }
            }

            @Override
            public int hashCode() {
                return Objects.hash(target, method);
            }
        };
    }
}

使用时直接替换原来的Runnable类型即可，相等断言可以正常生效：

class C1 {
    EventRunnable r;
}

// 赋值
c1.r = EventRunnable.bind(c2, "f");
// 断言，可正常通过
assertThat(c1.r).isEqualTo(EventRunnable.bind(c2, "f"));

这个方案完全适配事件解耦设计需求，你还可以根据业务需要给接口加事件标识、优先级等扩展属性，比原生Runnable更适配事件驱动场景。

方案3：通过SerializedLambda提取元数据比对（不推荐，依赖JDK内部实现） #

如果你必须使用原生Runnable，可以将方法引用声明为可序列化类型，通过JDK内部的SerializedLambda类提取绑定的实例、方法信息做比对：

import java.lang.invoke.SerializedLambda;
import java.lang.reflect.Method;

public static boolean isSameBoundMethod(Runnable a, Runnable b) {
    try {
        SerializedLambda slA = extractLambdaMeta(a);
        SerializedLambda slB = extractLambdaMeta(b);
        // 比对绑定的目标实例、方法名、方法签名、所属类
        return slA.getCapturedArg(0).equals(slB.getCapturedArg(0))
                && slA.getImplMethodName().equals(slB.getImplMethodName())
                && slA.getImplMethodSignature().equals(slB.getImplMethodSignature())
                && slA.getImplClass().equals(slB.getImplClass());
    } catch (Exception e) {
        throw new IllegalArgumentException("传入的方法引用必须实现Serializable接口", e);
    }
}

private static SerializedLambda extractLambdaMeta(Runnable lambda) throws Exception {
    Method writeReplace = lambda.getClass().getDeclaredMethod("writeReplace");
    writeReplace.setAccessible(true);
    return (SerializedLambda) writeReplace.invoke(lambda);
}

使用时需要将方法引用强转为可序列化类型：

// 赋值
c1.r = (Runnable & Serializable) c2::f;
// 断言
assertThat(isSameBoundMethod(c1.r, (Runnable & Serializable) c2::f)).isTrue();

这个方案的缺点是依赖JDK内部Lambda实现细节，不同JDK版本、不同厂商的JDK可能存在兼容性问题，仅建议在临时场景使用。

不要尝试直接强转方法引用后用==或者默认equals比对，只要是动态生成的Lambda实例，两次独立创建的实例永远不会相等。如果是静态方法引用，比对时需要跳过实例校验逻辑，因为静态方法不绑定对象实例。

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