java.lang.reflect.Proxy的替代品，用于创建抽象类的代理（而不是接口）

Question 1

根据文档：

[ java.lang.reflect.]Proxy提供了用于创建动态代理类和实例的静态方法，它还是由这些方法创建的所有动态代理类的超类。

该newProxyMethod方法（负责生成动态代理）具有以下签名：

public static Object newProxyInstance(ClassLoader loader,
                                      Class<?>[] interfaces,
                                      InvocationHandler h)
                             throws IllegalArgumentException

不幸的是，这阻止了人们生成扩展特定抽象类的动态代理（而不是实现特定接口）。考虑到java.lang.reflect.Proxy“所有动态代理的超类”，这是有道理的，因此可以防止另一个类成为超类。

因此，是否有替代方法java.lang.reflect.Proxy可以生成从特定抽象类继承的动态代理，从而将对抽象方法的所有调用重定向到调用处理程序？

例如，假设我有一个抽象类Dog：

public abstract class Dog {

    public void bark() {
        System.out.println("Woof!");
    }

    public abstract void fetch();

}

有没有可以让我做以下事情的课程？

Dog dog = SomeOtherProxy.newProxyInstance(classLoader, Dog.class, h);

dog.fetch(); // Will be handled by the invocation handler
dog.bark();  // Will NOT be handled by the invocation handler

Question 2

可以使用Javassist（请参见ProxyFactory）或CGLIB来完成。

亚当使用Javassist的示例：

我（Adam Paynter）使用Javassist编写了以下代码：

ProxyFactory factory = new ProxyFactory();
factory.setSuperclass(Dog.class);
factory.setFilter(
    new MethodFilter() {
        @Override
        public boolean isHandled(Method method) {
            return Modifier.isAbstract(method.getModifiers());
        }
    }
);

MethodHandler handler = new MethodHandler() {
    @Override
    public Object invoke(Object self, Method thisMethod, Method proceed, Object[] args) throws Throwable {
        System.out.println("Handling " + thisMethod + " via the method handler");
        return null;
    }
};

Dog dog = (Dog) factory.create(new Class<?>[0], new Object[0], handler);
dog.bark();
dog.fetch();

产生以下输出：

纬！
通过方法处理程序处理公共抽象void mock.Dog.fetch（）

Question 3

在这种情况下，您可以做的是拥有一个代理处理程序，该处理程序会将调用重定向到抽象类的现有方法。

您当然必须对其进行编码，但这非常简单。要创建代理，您必须给他一个InvocationHandler。然后，您只需要在invoke(..)调用处理程序的方法中检查方法类型。但要注意：您必须对照与您的处理程序关联的基础对象而不是抽象类的声明类型来检查方法类型。

以我的狗类为例，您的调用处理程序的invoke方法可能看起来像这样（具有一个名为.. well ...的现有关联狗子类dog）。

public void invoke(Object proxy, Method method, Object[] args) {
    if(!Modifier.isAbstract(method.getModifiers())) {
        method.invoke(dog, args); // with the correct exception handling
    } else {
        // what can we do with abstract methods ?
    }
}

但是，有些事情让我感到疑惑：我已经谈论了一个dog对象。但是，由于Dog类是抽象的，因此您无法创建实例，因此您已有现有的子类。此外，正如对代理源代码的严格检查所揭示的那样，您可能会发现（在Proxy.java:362上）无法为不代表接口的Class对象创建代理）。

因此，除了现实之外，您完全可以做您想做的事情。