Java 调用重载方法的反射 Area.equals(Area)

Question

正如中所讨论的，java.awt.geom.Area的equals方法被定义为

public boolean equals(Area other)

而不是覆盖 Object 中的 equals 方法。该问题涵盖 "why"，我对 "how can I force Java to use the most appropriate equals method".

感兴趣

考虑这个例子：

public static void main(String[] args) {
    Class<?> cls = Area.class;
    Area a1 = new Area(new Rectangle2D.Double(1, 2, 3, 4));
    Area a2 = new Area(new Rectangle2D.Double(1, 2, 3, 4));
    System.out.println("Areas equal: " + a1.equals(a2)); // true

    Object o1 = (Object) a1;
    Object o2 = (Object) a2;
    System.out.println("Objects equal: " + o1.equals(o2)); // false

    // Given only cls, o1, and o2, how can I get .equals() to return true?
    System.out.println("cls.cast() approach : " + cls.cast(o1).equals(cls.cast(o2))); // false

    try {
        Method equalsMethod = cls.getMethod("equals", cls); // Exception thrown in most cases
        System.out.println("Reflection approach: " + equalsMethod.invoke(o1, o2)); // true (when cls=Area.class)
    } catch (Exception e) {
        e.printStackTrace();
    }
}

我的问题是：给定 o1、o2 和 cls，其中 o1 和 o2 保证是 [=21 的实例=]（或子类），如何调用最合适的equals方法？假设 cls 是 X.class，我想要以下行为：

如果X定义了X.equals(X)，这是"most appropriate"的选择。（例如：X 是 Area）
否则，如果 X 定义 X.equals(Object)，这是第二个最合适的选择。（例如：X 是 Rectangle2D）
如果以上都不是，我想调用Object.equals(Object)作为回退。（例如：X 是 Path2D）

原则上，我可以使用反射来检查上述每个方法签名，但这似乎很笨拙。有没有更简单的方法？

为清楚起见进行编辑：o1、o2 和 cls 都在运行时发生变化，因此我不能像 [=42] 一样静态转换=]，因为 cls 可能不会一直是 Area.class。但是保证 cls.isAssignableFrom(o1.getClass()) 和 cls.isAssignableFrom(o2.getClass()) 都是 true.

Answer 1

你的第二个和第三个项目符号（使用 X.equals(Object) 或回退到 Object.equals(Object)）不需要任何努力，因为调用可覆盖方法 Object.equals(Object) 时无论如何都会发生这种情况，它将使用它能找到的最具体的覆盖方法。

所以剩下的唯一任务就是调用 X.equals(X) 方法（如果适用）。为了最小化相关成本，您可以缓存结果。自 Java 7 以来，有 class ClassValue 允许将信息与 class 相关联，以线程安全、延迟评估和高效查找的方式，仍然支持垃圾收集如果需要，密钥 class。

因此，Java7 解决方案可能如下所示：

import java.lang.invoke.*;

public final class EqualsOperation extends ClassValue<MethodHandle> {
    public static boolean equals(Object o, Object p) {
        if(o == p) return true;
        if(o == null || p == null) return false;
        Class<?> t1 = o.getClass(), t2 = p.getClass();
        if(t1 != t2) t1 = commonClass(t1, t2);
        try {
            return (boolean)OPS.get(t1).invokeExact(o, p);
        } catch(RuntimeException | Error unchecked) {
            throw unchecked;
        } catch(Throwable ex) {
            throw new IllegalStateException(ex);
        }
    }
    private static Class<?> commonClass(Class<?> t1, Class<?> t2) {
        while(t1 != Object.class && !t1.isAssignableFrom(t2)) t1 = t1.getSuperclass();
        return t1;
    }
    static final EqualsOperation OPS = new EqualsOperation();
    static final MethodHandle FALLBACK;
    static {
        try {
            FALLBACK = MethodHandles.lookup().findVirtual(Object.class, "equals",
                MethodType.methodType(boolean.class, Object.class));
        } catch (ReflectiveOperationException ex) {
            throw new ExceptionInInitializerError(ex);
        }
    }

    @Override
    protected MethodHandle computeValue(Class<?> type) {
        try {
            return MethodHandles.lookup()
                .findVirtual(type, "equals", MethodType.methodType(boolean.class, type))
                .asType(FALLBACK.type());
        } catch(ReflectiveOperationException ex) {
            return FALLBACK;
        }
    }
}

您可以使用

进行测试

Object[] examples1 = { 100, "foo",
    new Area(new Rectangle(10, 20)), new Area(new Rectangle(20, 20)) };
Object[] examples2 = { new Integer(100), new String("foo"),// enforce a!=b
   new Area(new Rectangle(10, 20)) };
for(Object a: examples1) {
    for(Object b: examples2) {
        System.out.printf("%30s %30s: %b%n", a, b, EqualsOperation.equals(a, b));
    }
}

从 Java 8 开始，我们可以在运行时生成功能接口的实例，这可能会提高性能，因为那时，我们在第一次遇到类型后不再执行任何反射操作：

import java.lang.invoke.*;
import java.util.function.BiPredicate;

public final class EqualsOperation extends ClassValue<BiPredicate<Object,Object>> {
    public static boolean equals(Object o, Object p) {
        if(o == p) return true;
        if(o == null || p == null) return false;
        Class<?> t1 = o.getClass(), t2 = p.getClass();
        if(t1 != t2) t1 = commonClass(t1, t2);
        return OPS.get(t1).test(o, p); // test(...) is not reflective
    }
    private static Class<?> commonClass(Class<?> t1, Class<?> t2) {
        while(t1 != Object.class && !t1.isAssignableFrom(t2)) t1 = t1.getSuperclass();
        return t1;
    }
    static final EqualsOperation OPS = new EqualsOperation();
    static final BiPredicate<Object,Object> FALLBACK = Object::equals;

    @Override
    protected BiPredicate<Object,Object> computeValue(Class<?> type) {
        if(type == Object.class) return FALLBACK;
        try {
            MethodType decl = MethodType.methodType(boolean.class, type);
            MethodHandles.Lookup lookup = MethodHandles.lookup();
            MethodHandle mh = lookup.findVirtual(type, "equals", decl);
            decl = mh.type();
            BiPredicate<Object,Object> p = (BiPredicate<Object,Object>)
                LambdaMetafactory.metafactory(lookup, "test",
                    MethodType.methodType(BiPredicate.class), decl.erase(), mh, decl)
                .getTarget().invoke();
            return p;
        } catch(Throwable ex) {
            return FALLBACK;
        }
    }
}

用法与其他变体一样。

这里的一个关键点是可访问性。我假设，无论如何，您只想支持 public classes 声明的 public 方法。不过，如果跨越模块边界，Java 9+ 可能需要微调。为了支持在应用程序代码中声明的自定义 X.equals(X) 方法，它可能需要向您的库开放自身以进行反射访问。

相等函数与其他代码（如集合）的相等逻辑不匹配的问题，已经在您的问题的评论中讨论过。在这里，与例如类似的问题IdentityHashMap，可能出现；小心处理……

Java 调用重载方法的反射 Area.equals(Area)

Java reflection to call overloaded method Area.equals(Area)

java

reflection

equals