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

Question

如 this question 中所述，java.awt.geom.Area的equals方法定义为

public boolean equals(Area other)

而不是覆盖 Object 中的 equals 方法。这个问题涵盖了“为什么”，我对“如何强制 Java 使用最合适的 equals 方法”感兴趣。

考虑这个例子:

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 保证是 cls (或子类)的实例，我怎样才能调用最合适的 equals 方法？假设 cls 是 X.class，我想要以下行为:

• 如果 X 定义了 X.equals(X)，这是“最合适”的选择。 (例如:X 是 Area)
• 否则，如果 X 定义了 X.equals(Object)，这是第二合适的选择。 (例如:X 是 Rectangle2D)
• 如果以上都不成立，我想调用 Object.equals(Object) 作为回退。 (例如:X 是 Path2D)

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

为清楚起见编辑:o1、o2 和 cls 在运行时都不同，所以我不能静态转换像 ((Area) o1).equals((Area) o2)，因为 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 开始，就有了类 ClassValue允许以线程安全、延迟评估和高效查找的方式将信息与类相关联，如果需要，仍然支持关键类的垃圾收集。

因此，Java 7 解决方案可能如下所示:

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 开始，我们可以在运行时生成功能接口(interface)的实例，这可能会提高性能，因为那时，我们在第一次遇到类型后不再执行任何反射操作:

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 类声明的 public 方法。不过，如果跨越模块边界，Java 9+ 可能需要微调。为了支持在应用程序代码中声明的自定义 X.equals(X) 方法，它可能需要向您的库开放自身以进行反射访问。

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