动态代理

Posted on by — No Comments ↓

在 Java 中，InvocationHandler 和 Proxy 是实现 动态代理 的核心组件，属于 Java 的反射机制（java.lang.reflect 包）。动态代理允许在运行时动态创建代理类，用于拦截和增强目标对象的方法调用。以下是对 InvocationHandler 和 Proxy 的解释，以及它们如何实现动态代理的详细说明。

1. 什么是 InvocationHandler 和 Proxy？

InvocationHandler

  • InvocationHandler 是一个接口，定义在 java.lang.reflect 包中。
  • 作用：它是动态代理的核心逻辑，负责处理代理对象的方法调用。
  • 接口定义： 
  public interface InvocationHandler {
      Object invoke(Object proxy, Method method, Object[] args) throws Throwable;
  }
  • invoke 方法：
    • proxy：代理对象本身（通常不直接使用）。
    • method：被调用的目标方法（通过反射获取）。
    • args：方法调用的参数。
    • 返回值：方法执行的结果。
  • 实现 InvocationHandler 接口的类可以自定义方法调用的行为，比如在方法执行前后添加逻辑（如日志、事务、权限检查等）。

Proxy

  • Proxy 是一个类，也在 java.lang.reflect 包中。
  • 作用：用于在运行时动态生成代理类，代理类会实现指定的接口，并将方法调用委托给 InvocationHandler。
  • 核心方法： 
  public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)
  • loader：类加载器，用于加载动态生成的代理类。
  • interfaces：代理类需要实现的接口数组。
  • h：InvocationHandler 实例，处理方法调用逻辑。
  • 返回值：一个实现了指定接口的代理对象。

动态代理的概念

  • 动态代理是指在运行时动态创建代理类，而无需在代码中手动编写代理类。
  • 用途：增强目标对象的功能（如日志、性能监控、事务管理）或实现接口的代理。
  • 对比静态代理：静态代理需要为每个目标类手动编写代理类，而动态代理通过 Proxy 和 InvocationHandler 自动生成代理类，更加灵活。

2. 动态代理的工作原理

  1. 创建代理对象：
    • 使用 Proxy.newProxyInstance 创建一个代理对象。
    • 代理对象实现指定的接口（interfaces 参数），并将所有方法调用委托给 InvocationHandler 的 invoke 方法。
  2. 方法调用：
    • 当调用代理对象的方法时，JVM 将调用转发到 InvocationHandler 的 invoke 方法。
    • 在 invoke 方法中，可以：
      • 执行目标对象的实际方法（通过反射）。
      • 添加前置/后置逻辑（比如日志、权限检查）。
  3. 运行时生成：
    • 代理类是运行时动态生成的字节码，继承自 Proxy 类并实现指定的接口。
    • 生成的代理类会自动调用 InvocationHandler 的 invoke 方法。

3. 如何使用 InvocationHandler 和 Proxy 实现动态代理

以下是一个完整的动态代理示例，展示如何使用 InvocationHandler 和 Proxy 来代理一个接口的实现。

示例场景

假设有一个接口 UserService 和它的实现类 UserServiceImpl，我们希望通过动态代理在方法调用前后添加日志。

  1. 定义接口和实现类 
// 接口
public interface UserService {
    void addUser(String name);
    String getUser(int id);
}

// 实现类
public class UserServiceImpl implements UserService {
    @Override
    public void addUser(String name) {
        System.out.println("Adding user: " + name);
    }

    @Override
    public String getUser(int id) {
        return "User" + id;
    }
}
  1. 实现 InvocationHandler
    创建一个自定义的 InvocationHandler，在方法调用前后添加日志： 
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class LoggingInvocationHandler implements InvocationHandler {
    private final Object target; // 目标对象（被代理的对象）

    public LoggingInvocationHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 前置逻辑：打印方法调用日志
        System.out.println("Before invoking method: " + method.getName());

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

        // 后置逻辑：打印方法返回日志
        System.out.println("After invoking method: " + method.getName() + ", result: " + result);
        return result;
    }
}
  1. 创建代理对象并使用
    使用 Proxy.newProxyInstance 创建代理对象，并测试： 
import java.lang.reflect.Proxy;

public class DynamicProxyExample {
    public static void main(String[] args) {
        // 创建目标对象
        UserService target = new UserServiceImpl();

        // 创建 InvocationHandler
        InvocationHandler handler = new LoggingInvocationHandler(target);

        // 创建代理对象
        UserService proxy = (UserService) Proxy.newProxyInstance(
            target.getClass().getClassLoader(), // 类加载器
            new Class<?>[]{UserService.class},  // 代理的接口
            handler                             // InvocationHandler
        );

        // 通过代理对象调用方法
        proxy.addUser("Alice");             // 将触发 InvocationHandler 的 invoke 方法
        String user = proxy.getUser(123);
        System.out.println("Returned: " + user);
    }
}
  1. 运行结果 
Before invoking method: addUser
Adding user: Alice
After invoking method: addUser, result: null
Before invoking method: getUser
After invoking method: getUser, result: User123
Returned: User123

代码解释

  • 代理对象：
    • proxy 是动态生成的代理对象，实现了 UserService 接口。
    • 调用 proxy.addUser("Alice") 时，JVM 将调用转发到 LoggingInvocationHandler 的 invoke 方法。

  • InvocationHandler：

    • 在 invoke 方法中：
    • 打印前置日志（Before invoking method）。
    • 使用 method.invoke(target, args) 调用目标对象的实际方法（UserServiceImpl 的方法）。
    • 打印后置日志（After invoking method）。

  • Proxy.newProxyInstance：

    • 动态生成一个类（继承 Proxy，实现 UserService 接口），将方法调用委托给 handler。

4. 动态代理的常见应用场景

  • 日志记录：如上例，在方法调用前后记录日志。
  • 权限控制：检查调用者权限后决定是否执行方法。
  • 事务管理：在方法开始前开启事务，结束后提交或回滚。
  • AOP（面向切面编程）：Spring 框架广泛使用动态代理实现 AOP（如 @Transactional、@Aspect）。
  • 延迟加载：代理数据库查询，延迟实际加载数据。
  • 远程调用：如 RMI 或 RPC，使用代理隐藏网络通信细节。

5. 动态代理的限制

  • 只能代理接口：
    • Java 的动态代理（基于 Proxy）只能为接口创建代理，无法直接代理类（因为代理类需要实现接口）。
    • 如果需要代理类，可以使用 CGLIB（基于字节码操作，Spring 中常用）。

  • 性能开销：

    • 动态代理使用反射，性能略低于直接调用（通常影响不大）。

  • 代理对象不能直接使用：

    • 在 invoke 方法中，proxy 参数是代理对象本身，不能直接调用其方法（会导致无限递归）。

6. 与 CGLIB 的对比

  • Java 动态代理：
    • 基于接口，使用 Proxy 和 InvocationHandler。
    • 适用于代理接口实现。
    • 原生支持，简单易用。

  • CGLIB：

    • 基于字节码操作，可以代理类（无需接口）。
    • 通过继承目标类生成子类，拦截方法调用。
    • Spring 框架默认使用 CGLIB 代理没有接口的类。

7. 总结

  • InvocationHandler：定义方法调用的处理逻辑，核心是 invoke 方法。
  • Proxy：运行时生成代理类，代理对象将方法调用委托给 InvocationHandler。
  • 动态代理步骤：
    1. 定义接口和目标实现类。
    2. 实现 InvocationHandler，编写代理逻辑。
    3. 使用 Proxy.newProxyInstance 创建代理对象。
    4. 通过代理对象调用方法，触发 InvocationHandler 的逻辑。

如果你有更具体的需求（比如特定的代理逻辑、结合 Spring 使用、或处理复杂场景），可以提供更多细节，我会进一步优化答案！

Leave a Reply