详解基于JDK和cglib的两种java动态代理实现方式，通俗易懂_jdk动态代理底层依赖反射实现-CSDN博客

本文链接：https://blog.csdn.net/RudeTomatoes/article/details/134387953

Java动态代理

1.基于JDK的动态代理
2.基于cglib的动态代理

Java动态代理是一种在运行时生成代理类以代替实际类的技术。它通常用于实现面向切面编程（AOP），允许你创建一个代理对象，该代理对象可以拦截方法调用，并在方法调用前后执行自定义的逻辑。在实际项目中通常用于日志记录、性能监控、事务管理等方面。本文主要介绍两种常见的java动态代理方式。

1.基于JDK的动态代理

该方法必须要求被代理类和代理类实现相关行为的接口（例如UserServiceImpl要实现UserService接口，代理类也要实现UserService接口），所以基于JDK的动态代理也称为基于接口的动态代理。

由于基于JDK的动态代理依赖于Java的反射机制，通常使用以下两个类来实现：

java.lang.reflect.Proxy：代理类，用于创建动态代理对象。它提供了一个静态方法newProxyInstance()，该方法接受一个类加载器、一组接口（被代理对象实现的接口）以及一个InvocationHandler对象作为参数，然后生成代理对象。
java.lang.reflect.InvocationHandler：调用处理程序。这是一个接口，你可以实现它以提供在代理对象上调用方法时的逻辑。通常，你会创建一个自定义的InvocationHandler实现类，并在其中定义代理对象的行为。

下面是一个简单的示例，演示如何使用Java动态代理创建一个代理对象：

// 定义接口
public interface UserService {
    void insert();
    void update();
}

// 定义实现类（被代理类）
public class UserServiceImpl implements UserService{
    @Override
    public void insert() {
        System.out.println("新增一个数据");
    }

    @Override
    public void update() {
        System.out.println("修改一个数据");
    }
}

注意：每个生成的代理对象都有调用处理程序（InvocationHandler接口的实现类）与之关联。当用代理对象调用方法时，调用的是MyInvocationHandler中的invoke方法。

// 实现InvocationHandler接口
public class MyInvocationHandler implements InvocationHandler {
    /**
     * 被代理的真实对象
     */
    private Object realObject;

    public MyInvocationHandler(Object realObject) {
        this.realObject = realObject;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 在方法调用前执行自定义逻辑
        System.out.println("Before "+method.getName());

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

        // 在方法调用后执行自定义逻辑
        System.out.println("After "+method.getName());

        return result;
    }
}

注意：在创建代理对象时，注意传参

// 创建真实对象（被代理的对象），代理对象，并用代理对象调用方法
public class UserController {
    public static void main(String[] args) {
        // 创建真实对象
        UserService userService = new UserServiceImpl();

        // 创建代理对象
        /**
         * 参数1：加载代理类的类加载器
         * 参数2：被代理类实现的接口，代理类也要实现
         * 参数3：InvocationHandler的实例
         */
        UserService proxyObject = (UserService) Proxy.newProxyInstance(
                UserController.class.getClassLoader(),
                userService.getClass().getInterfaces(),
                new MyInvocationHandler(userService)
        );
        // 使用代理对象
        proxyObject.update();
    }
}

2.基于cglib的动态代理

CGLIB（Code Generation Library）是一个用于生成Java字节码的开源库，它通常用于创建基于类的动态代理。与基于Java动态代理的方式不同，CGLIB不需要接口，并且可以代理普通类，而不仅仅是接口。下面是一个基于CGLIB的动态代理的简单示例：

引入cglib依赖：

<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>3.3.0</version> <!-- 版本号可以根据你的需求进行更改 -->
</dependency>

需要被代理的类为上文中的UserServiceImpl，需要注意的是基于cglib的动态代理，被代理的类可以实现接口，也可以不实现。
设置一个MethodInterceptor（方法拦截器）接口的实例作为代理的处理逻辑。当我们调用代理对象的方法时，MyMethodInterceptor中的逻辑将被触发，允许我们在方法调用前后添加自定义行为。

class MyMethodInterceptor implements MethodInterceptor {
    @Override
    public Object intercept(Object obj, java.lang.reflect.Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("Before "+method.getName());

        // 调用真实对象的方法
        Object result = proxy.invokeSuper(obj, args);

        System.out.println("After "+method.getName());

        return result;
    }
}

用代理对象调用相关增强后的方法

public class UserController2 {
    public static void main(String[] args) {
        // 创建一个Enhancer对象
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(UserServiceImpl.class);
        // 设置方法拦截器
        enhancer.setCallback(new MyMethodInterceptor());
        // 创建代理对象
        UserServiceImpl proxy = (UserServiceImpl) enhancer.create();
        // 调用代理对象的方法
        proxy.update();
    }
}