017-Java 动态代理详解

一、动态代理概述

1.1、动态代理介绍

动态代理是一种设计模式，它允许在运行时创建代理对象，并将方法调用重定向到不同的实际对象。它使我们能够在不修改现有代码的情况下增加或改变某个对象的行为。

1.2、动态代理作用

动态代理提供了一种灵活且非侵入式的方式，可以对对象的行为进行定制和扩展。它在代码重用、解耦和业务逻辑分离、性能优化以及系统架构中起到了重要的作用。

增强对象的功能：通过动态代理，可以在不修改原始对象的情况下，对其方法进行增强或添加额外的行为。可以在方法执行前后进行一些操作，比如日志记录、性能监测、事务管理等。

解耦和业务逻辑分离：动态代理可以将对象的特定操作从业务逻辑中解耦，使得代码更加模块化和可维护。代理对象可以负责处理一些通用的横切关注点，而业务对象可以专注于核心业务逻辑。

实现懒加载：通过动态代理，可以延迟加载对象，只有在真正需要使用对象时才会进行创建和初始化，从而提高性能和资源利用效率。

实现远程方法调用：动态代理可以用于实现远程方法调用(RPC)和分布式系统中的服务代理。客户端通过代理对象调用远程服务，并隐藏了底层网络通信的细节。

实现AOP编程：动态代理是实现面向切面编程(AOP)的基础。通过代理对象，可以将横切关注点（如日志、事务、安全性）与业务逻辑进行解耦，提供更高层次的模块化和可重用性。

二、JDK动态代理

在Java中，可以使用Java的反射机制来实现动态代理。Java提供了java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口来实现动态代理。

2.1、定义接口和实现

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

// 实现接口的具体类
class UserServiceImpl implements UserService {
    public void addUser(String username) {
        System.out.println("添加用户：" + username);
    }
}

2.2、实现InvocationHandler接口

// 实现InvocationHandler接口
class MyInvocationHandler implements InvocationHandler {
	// 声明一个私有变量
    private Object target;

	// 构造函数
    public MyInvocationHandler(Object target) {
        this.target = target;
    }

	//  实现InvocationHandler接口的invoke方法，该方法在代理对象调用方法时被触发。
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("动态代理前置操作");
        Object result = method.invoke(target, args);
        System.out.println("动态代理后置操作");
        return result;
    }
}

这段代码实现了InvocationHandler接口，它是实现动态代理的关键部分。

2.3、实现代理

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

        // 创建InvocationHandler实例
        MyInvocationHandler handler = new MyInvocationHandler(userService);

        // 创建动态代理对象
        UserService proxy = (UserService) Proxy.newProxyInstance(
                userService.getClass().getClassLoader(),
                userService.getClass().getInterfaces(),
                handler
        );

        // 通过代理对象调用方法
        proxy.addUser("Alice");
    }
}

三、CGLIB代理

CGLIB，全称为Code Generation Library，是一个用于在运行时扩展Java类的库。它是基于ASM（Java字节码操作框架）的高性能代码生成库。CGLIB的主要功能之一是通过生成子类来实现动态代理，这使得它在许多框架和库中得到广泛应用，特别是在Spring框架中，用于实现AOP功能。

3.1、实现代理

CGLIB通过创建目标类的子类来实现动态代理。在动态代理中，一个代理类包装了一个目标类，并拦截对目标类方法的调用。CGLIB创建的子类继承自目标类，并重写了需要代理的方法。通过重写这些方法，CGLIB可以在调用目标类方法之前或之后注入额外的逻辑。

CGLIB的主要步骤包括：
1. 选择目标类：CGLIB需要一个目标类，它将生成一个代理类来拦截目标类的方法调用。
2. 创建Enhancer对象：Enhancer是CGLIB中的主要类，用于生成代理类。通过配置Enhancer对象，您可以定义代理类的行为，例如指定拦截器。
3. 设置回调：在CGLIB中，回调是拦截器的一种，它允许您在调用目标方法之前或之后执行额外的逻辑。您可以创建自定义拦截器并将其设置为Enhancer对象的回调。
4. 生成代理类：通过调用Enhancer对象的create()方法，CGLIB将生成一个代理类。这个代理类是目标类的子类，并且重写了需要代理的方法。

3.2、定义目标类

目标类：CGLIB需要一个目标类，它将生成一个代理类来拦截目标类的方法调用。

// 目标类
static class UserService {
   public void getUser() {
            System.out.println("Fetching user from the database...");
        }
    }

3.2、定义拦截器

  // 自定义拦截器
    static class LoggingInterceptor implements MethodInterceptor {
        @Override
        public Object intercept(Object obj, java.lang.reflect.Method method, Object[] args,
                                MethodProxy proxy) throws Throwable {
            System.out.println("Before method: " + method.getName());
            Object result = proxy.invokeSuper(obj, args); // 调用目标方法
            System.out.println("After method: " + method.getName());
            return result;
        }
    }

3.3、实现代理

public static void main(String[] args) {
        // 1. 创建Enhancer对象
        Enhancer enhancer = new Enhancer();
 
        // 2. 设置目标类
        enhancer.setSuperclass(UserService.class);
 
        // 3. 设置回调（拦截器）
        enhancer.setCallback(new LoggingInterceptor());
 
        // 4. 生成代理类
        UserService proxyUserService = (UserService) enhancer.create();
 
        // 5. 调用代理类方法，实际会调用拦截器中的逻辑
        proxyUserService.getUser();

CGLIB动态代理在很多框架和项目中得到广泛应用，特别是在那些需要对现有类进行增强或修改的情况下。一些常见的应用场景包括：

     AOP（面向切面编程）：在Spring等框架中，CGLIB常用于实现AOP，以在运行时为目标对象的方法注入额外的逻辑。

     延迟加载：CGLIB动态代理可以用于实现延迟加载，当需要使用某个对象时，才实际创建它，从而提高系统的性能。

     缓存代理：CGLIB可以用于在调用某个方法前先检查缓存中是否存在结果，如果有则直接返回缓存中的值，从而避免重复计算。（Spring中的循环依赖问题）

     事务管理：在数据库事务管理中，CGLIB可以用于在方法调用前后开启、提交或回滚事务。