java动态代理

动态代理是一种设计模式，它允许在运行时创建一个代理对象，该代理对象可以在不改变原始对象的情况下，拦截并处理特定方法的调用。

在动态代理中，代理对象通常是通过实现或继承一个特定的接口来创建的。当我们调用代理对象的方法时，这些方法的调用会被重定向到一个中介方法（也称为处理器或调用处理程序），而不是直接调用原始对象的方法。这个中介方法将根据需求执行一些附加操作，如日志记录、性能监控、安全检查等，然后再将控制权转发给原始对象的方法。

动态代理的优点在于它能够在运行时创建代理对象，而无需提前编写具体的代理类。这种灵活性使得动态代理特别适用于以下情况：

1. AOP（面向切面编程）：通过动态代理，可以在方法调用前后插入额外的逻辑，例如日志记录、事务管理等，而无需修改原始对象的代码。
2. 远程方法调用（RMI）：动态代理可以用于在分布式环境中调用远程服务，隐藏底层网络通信细节。
3. 延迟加载：动态代理可以将实际对象的初始化推迟到真正需要时进行，以提高系统性能和资源利用。

通常，Java中的动态代理使用Java标准库中的 java.lang.reflect.Proxy 类来创建代理对象。这个类提供了一组静态方法，可以在运行时生成代理类并创建代理实例。

要使用动态代理，需要满足以下条件：

1. 创建一个接口或者已知的接口列表。
2. 创建一个实现 InvocationHandler 接口的处理器类，该类将实现中介方法的逻辑，即决定如何处理被代理方法的调用。
3. 使用 Proxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler handler) 方法创建代理对象。其中，loader 是代理对象的类加载器，interfaces 是代理对象需要实现的接口列表，handler 是中介方法的处理器。

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

interface MyInterface {
    void doSomething();
}

class MyRealObject implements MyInterface {
    public void doSomething() {
        System.out.println("Doing something in real object...");
    }
}

class MyProxyHandler implements InvocationHandler {
    private MyInterface realObject;

    public MyProxyHandler(MyInterface realObject) {
        this.realObject = realObject;
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 在方法调用前执行一些操作
        System.out.println("Before method invocation...");

        // 调用实际对象的方法
        Object result = method.invoke(realObject, args);

        // 在方法调用后执行一些操作
        System.out.println("After method invocation...");

        return result;
    }
}

public class ProxyExample {
    public static void main(String[] args) {
        MyRealObject realObject = new MyRealObject();
        MyProxyHandler handler = new MyProxyHandler(realObject);

        MyInterface proxyObject = (MyInterface) Proxy.newProxyInstance(
            MyInterface.class.getClassLoader(),
            new Class[]{MyInterface.class},
            handler
        );

        proxyObject.doSomething();
    }
}

 

这段代码是一个简单的示例，演示了如何使用动态代理来拦截方法调用，并在调用前后执行额外的逻辑。

首先，我们定义了一个接口 MyInterface，该接口声明了一个 doSomething() 方法，用于执行某些操作。

接下来，我们创建了一个实现 MyInterface 接口的具体类 MyRealObject。这个类实现了接口中定义的 doSomething() 方法，其中的逻辑是输出一条消息。

然后，我们定义了一个处理器类 MyProxyHandler，它实现了 InvocationHandler 接口。在这个处理器类中，我们需要存储一个真实对象 realObject，它是实际执行操作的对象。在处理器的 invoke() 方法中，我们定义了在方法调用前后执行的逻辑。

在 invoke() 方法中，我们首先在方法调用前输出一条消息，表示即将调用方法。然后，通过反射调用真实对象的方法，并传递相应的参数。这里使用了 method.invoke(realObject, args) 进行方法的调用。反射机制允许我们在运行时动态地调用对象的方法。

在方法调用完成后，我们在方法调用后输出一条消息，表示方法调用已经完成。最后，我们将返回值返回给调用者。

在 main() 方法中，我们首先创建了一个真实对象 realObject，它是 MyRealObject 类的一个实例。然后，我们创建了一个处理器对象 handler，并将真实对象传递给它。

接下来，通过 Proxy.newProxyInstance() 方法创建了代理对象 proxyObject。这个方法接收三个参数：类加载器（MyInterface.class.getClassLoader()）、要实现的接口列表（new Class[]{MyInterface.class}）和处理器对象（handler）。该方法返回一个代理对象，它实现了指定接口，并在方法调用时会委托给处理器对象的中介方法进行处理。

最后，我们调用代理对象的 doSomething() 方法。在这个调用过程中，将会依次执行中介方法处理器的前置逻辑、真实对象的 doSomething() 方法以及中介方法处理器的后置逻辑。输出的结果将会是：

Before method invocation...
Doing something in real object...
After method invocation...