java动态代理介绍

1. 什么是 Java 动态代理？

Java 动态代理就像你的私人助理，除了处理你的请求外，还偷偷在旁边加些额外操作（比如记账、提醒）！在 Java 中，动态代理的存在使得我们无需直接修改业务代码就能给方法加“特效”，像是日志记录、性能监控，甚至可以实现一些自动化的复杂逻辑。动态代理不仅让代码变得更灵活，还让开发者可以专注在核心业务上。是不是很酷？

Java 动态代理主要通过 java.lang.reflect 包下的 Proxy 类和 InvocationHandler 接口实现。简单来说，就是通过反射实现代理类，在方法调用前、后可以偷偷加些额外操作，像一个“隐形的小跟班”。

2. 来点代码演示一下！

先来看下我们要代理的对象接口和实现类。假设我们现在要处理一个 UserService 接口：

// 定义接口 
public interface UserService { 
    void addUser(String name); 
}



 // 实现接口 
public class UserServiceImpl implements UserService { 
    @Override 
    public void addUser(String name) { 
        System.out.println("User added: " + name); 
    } 
}

这个 UserServiceImpl 是个正经的“好同事”，它只知道老老实实地执行 addUser。而我们又不想直接修改它，但希望在调用它的每次操作前后记录日志。这时候，动态代理就派上用场啦！我们定义一个“代理助手” UserServiceInvocationHandler：

// 定义代理处理器 
import java.lang.reflect.InvocationHandler; 
import java.lang.reflect.Method; 
public class UserServiceInvocationHandler implements InvocationHandler { 
    private final Object target; 

    public UserServiceInvocationHandler(Object target) { 
        this.target = target; 
    } 
    
    @Override 
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
        System.out.println("Before method: " + method.getName()); 
        Object result = method.invoke(target, args); 
        System.out.println("After method: " + method.getName()); return result; 
    } 

}

最后，我们需要在实际操作中让这个代理助手“跟班”到 UserServiceImpl 上，这就靠 Proxy.newProxyInstance()出手了：

import java.lang.reflect.Proxy; 

public class ProxyDemo { 
    public static void main(String[] args) { 
        UserService userService = new UserServiceImpl();
        UserServiceInvocationHandler handler = new UserServiceInvocationHandler(userService); // 创建代理对象 
        UserService proxy = (UserService) Proxy.newProxyInstance( userService.getClass().getClassLoader(), userService.getClass().getInterfaces(), handler); 
        // 通过代理对象调用方法 
        proxy.addUser("John Doe"); 
     }

}

运行这个小示例时，输出如下：

Before method: addUser
User added: John Doe
After method: addUser

每次 addUser 被调用前后，都会显示我们额外加上的“日志”信息！

3. 深入分析代理实现过程

让我们逐步拆解上面的代码片段：

接口和实现类：UserService 是接口，而 UserServiceImpl 是它的忠实实现者。它只负责添加用户，一丝不苟、毫无花哨。
代理处理器：UserServiceInvocationHandler 是关键点。它通过实现 InvocationHandler 接口的 invoke 方法，起到“看门人”的作用。在 invoke 方法中，使用 method.invoke(target, args) 来执行目标方法，并在前后输出日志。
代理对象创建：Proxy.newProxyInstance 是代理工厂。它接收以下参数：
- ClassLoader：用于加载代理类；
- Class<?>[] interfaces：代理类要实现的接口（我们这里是 UserService）；
- InvocationHandler h：刚才定义的“看门人”，它负责在方法前后加点“调味料”。

最终得到的 proxy 就是代理对象，我们可以用它来“装扮”成 UserServiceImpl，在执行方法的前后悄悄进行日志记录。

4. Java 动态代理的幕后工作原理

在 JDK 动态代理机制中，Proxy.newProxyInstance() 其实是生成了一个代理类，这个类在后台帮我们动态生成并实现了 UserService 接口。这种方式虽然看似复杂，但让我们得以灵活控制对象方法的调用过程。

步骤分解

代理类生成：Java 使用 Proxy 类生成代理类，其形式类似于以下伪代码：

public final class $Proxy0 extends Proxy implements UserService {
    public $Proxy0(InvocationHandler handler) {
        super(handler);
    }

    @Override
    public void addUser(String name) throws Throwable {
        handler.invoke(this, UserService.class.getMethod("addUser", String.class), new Object[]{name});
    }
}

字节码生成：Java 动态代理通过字节码生成一个继承 Proxy 并实现目标接口的类。这让我们在代码编译阶段无需编写代理类，而是依赖 JVM 在运行时生成代理对象。
方法调用处理：每次调用方法都会进入 InvocationHandler 的 invoke 方法，调用过程完全由 InvocationHandler 控制。