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

java dynamic-proxy

2022-08-31 10:25:19

根据文档：

[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

答案 1

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

Adam 使用 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();

这将产生以下输出：

Woof!
Handling public abstract void mock.Dog.fetch() via the method handler

答案 2

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

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

如果我以你的狗类为例，你的调用处理程序的 invoke 方法可能看起来像这样（有一个现有的关联狗子类，叫做..好吧......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 类是抽象的，因此您无法创建实例，因此您有现有的子类。此外，正如对代理源代码的严格检查所显示的那样，您可能会发现（在 Proxy.java：362）不可能为不表示接口的 Class 对象创建代理。dog

所以，除了现实之外，你想做的事情是完全可能的。