【Java动态代理】—— 每天一点小知识

🐳Java动态代理

在Java编程中，动态代理是一种强大的技术，可以在运行时创建代理对象，以便在不修改原始类代码的情况下对其进行扩展或修改。动态代理使得我们能够在调用方法前后插入自定义的逻辑，例如日志记录、性能监测、事务处理等。在本篇博客中，我将详细讲解Java动态代理的概念、用法，并提供代码示例，帮助你深入理解和应用该技术。

1. 动态代理的概念

💧在传统的代理模式中，我们需要为每个被代理的类手动编写代理类。而动态代理则允许我们在运行时创建代理对象，无需事先编写代理类。动态代理是通过Java的反射机制实现的，它允许我们在运行时创建接口的代理实例。

💧动态代理的核心是java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口。Proxy类提供了创建代理类的静态方法，而InvocationHandler接口则定义了代理类需要实现的方法。

2. 动态代理的用法

💧让我们通过一个示例来演示动态代理的使用过程。假设我们有一个接口MyInterface，以及一个实现该接口的类MyClass。我们希望在调用MyClass的方法前后打印日志。

2.1 接口 MyInterface

💧接口MyInterface表示一个我们希望创建的动态代理对象的接口。在示例中，我们将使用一个简单的接口作为示范。以下是MyInterface的定义：

public interface MyInterface {
    void myMethod();
}

💧在MyInterface接口中定义了一个名为myMethod的抽象方法。我们希望在调用该方法前后插入自定义的逻辑。通过动态代理，我们可以实现在调用myMethod方法时执行额外的操作。

2.2 接口实现类 MyClass

💧MyClass是一个实现了MyInterface接口的具体类。在示例中，我们将使用一个简单的MyClass类来作为被代理对象。以下是MyClass的定义：

public class MyClass implements MyInterface {
    @Override
    public void myMethod() {
        System.out.println("This is myMethod");
    }
}

2.4 代理处理器类 MyInvocationHandler

💧在演示前，我们还需要创建一个实现了InvocationHandler接口的代理处理器类。在该类中，我们可以定义在调用代理对象方法前后执行的逻辑。以下是MyInvocationHandler 的定义：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class MyInvocationHandler implements InvocationHandler {
    private Object target;
    public MyInvocationHandler(Object target) {
        this.target = target;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 在调用方法前执行的逻辑
        System.out.println("Before method invocation");
        // 调用目标对象的方法
        Object result = method.invoke(target, args);
        // 在调用方法后执行的逻辑
        System.out.println("After method invocation");
        return result;
    }
}

💧在上述代码中，MyInvocationHandler实现了InvocationHandler接口，并重写了其中的invoke方法。在invoke方法中，我们可以根据需要在调用方法前后执行自定义的逻辑。其中，proxy参数表示生成的代理对象，method参数表示被调用的方法，args参数表示方法的参数数组。

2.5 示例演示

💧接下来，我们可以使用Proxy类的newProxyInstance方法创建代理对象。这个方法接受三个参数：类加载器（ClassLoader）、接口数组和代理处理器对象。示例如下：

import java.lang.reflect.Proxy;
public class Main {
    public static void main(String[] args) {
        MyClass myClass = new MyClass();
        MyInterface proxyInstance = (MyInterface) Proxy.newProxyInstance(
                MyClass.class.getClassLoader(),
                new Class[]{MyInterface.class},
                new MyInvocationHandler(myClass)
        );
        proxyInstance.myMethod();
    }
}

💧在上述代码中，我们创建了一个MyClass的实例myClass，然后使用Proxy.newProxyInstance方法创建了一个代理对象proxyInstance。该代理对象实现了MyInterface接口，并由MyInvocationHandler来处理方法的调用。最后，我们调用了代理对象的myMethod方法。

2.6 调用之后的结果

💧当我们运行上述示例代码时，将会得到以下输出：

Before method invocation
This is myMethod
After method invocation

💧可以看到，在调用代理对象的myMethod方法前后，MyInvocationHandler中定义的逻辑被执行了。这意味着我们成功地在方法调用前后插入了自定义的代码。

补充： InvocationHandler是什么

💧其实InvocationHandler是一个接口，位于java.lang.reflect包中。它定义了代理对象的方法调用处理逻辑。在使用动态代理时，我们需要实现该接口，并重写其中的invoke方法。

💧方法invoke接收三个参数：代理对象、被调用的方法和方法的参数。我们可以在该方法中定义在方法调用前后执行的逻辑。该方法的返回值为方法的返回值。

3. 动态代理的工作原理

💧当我们调用代理对象的方法时，实际上会调用代理对象的invoke方法。invoke方法中通过反射机制调用了被代理对象的相应方法，并在调用前后执行了自定义的逻辑。这样，我们就实现了动态代理的效果。