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

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）

原则上，我可以使用反射来检查每个上述方法签名，但那似乎太重-handed手了。是否有更简单的方法？

编辑以使内容更清晰：在运行时，o1，o2和cls都会变化，因此我无法像((Area) o1).equals((Area) o2)那样进行静态转换，因为cls可能不是始终为Area.class。但可以保证cls.isAssignableFrom(o1.getClass())和cls.isAssignableFrom(o2.getClass())都为true。

- k_ssb

---

你的问题似乎不够清晰，有些混淆。请编辑以简单明了的语言提供整洁的信息来描述您的问题。只需描述您的问题即可。 - Sikandar Sahab

@BadshahTracker，老实说，我不知道如何让我的问题更加清晰明了。正如已经说明的那样，我有两个对象和它们的类。我想以某种方式调用最合适的equals方法，就像项目符号示例所描述的那样。 - k_ssb

@pkpnd，我不太明白为什么在你对方法解析的要求中，第一件事就是使用反射。其实没有必要这样做。查找动态方法调用解析的方式。你只需要将两个对象转换为适当的类型即可。 - M. Prokhorov

@pkpnd，这意味着你的问题文本是错误的。你似乎没有尝试选择一个“最佳匹配”。另一方面，“也可以是任何其他类型”的情况属于你要求的最后一个要点。你再次没有说服我你实际上不能在那里使用静态转换。 - M. Prokhorov

如果您作为通用方法的实现者认为，当给定两个对象A和B时，使用map = singletonMap(A, VAL);简单调用map.contains(B)将返回false是可以接受的，那么请继续使用您现有的基于反射的方法。我觉得我已经说得足够多了，以使您相信通用方法将与equals()的常见定义一致，并与hashCode保持一致。而Area.equals(Area)则不是这样，因此远非“通用”。 - M. Prokhorov

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

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;
        }
    }
}

使用方法与其他变体类似。 一个关键点在于可访问性。我假设你只想支持由公共类声明的公共方法。然而，如果越过模块边界，可能需要对Java 9+进行微调。为了支持在应用程序代码中声明的自定义X.equals(X)方法，它可能需要向您的库开放反射访问权限。 已经在您的问题评论中讨论了等式函数不匹配其他代码（如集合）的等式逻辑的问题。在这里，可能会出现与IdentityHashMap等类似的问题；请小心处理...

- Holger