Java中的动态代理（JDK Proxy VS CGLib）

偏执的太偏执、 2024-03-26 22:26 62阅读 0赞

## 前言 ##

动态代理可以说是Java基础中一个比较重要的内容，这块内容关系到Spring框架中的AOP实现原理，所以特别写了一篇作为个人对这块知识的总结。这部分内容主要包括：JDK Proxy和CGLib的基本介绍、二者的实现原理、代码示例等。

## 什么是动态代理 ##

动态代理是指程序在运行过程中，动态代理的实现是基于某个特点类而生成的增强类，也就是说，`动态代理生成的类会顶替掉原来的类而被执行从而做到达到增强的目前`

目前流行的动态代理机制有两种：JDK Proxy 和 CGLIB

这两个人实现动态代理的方式不同，前者是要求被代理类必须继承接口，而后者则没有这个要求，因为他是通过生成代理类的子类来进行构造的。

## JDK Proxy ##

JDK Proxy 是Java官方提供的一种动态代理类实现方式，它的实现动态代理特点如下：

*  代理类实现接口
 *  通过反射生产代理类

### 为什么被代理类要实现接口 ###

可能有人会有疑惑为什么说JDK Proxy仅支持实现了接口的被代理类，这个问题需要分几点来回答

【首先】生成的代理类是通过反射的方式构建的，这个过程中，这个代理类可以认为就是被代理类的“克隆体”，但是与之不同的其中一个点的是，这个生产的代理类也需要继承Proxy才行，但是假如`被代理类继承了其他类，但是Java中是不允许多继承的`，所以被代理类是不能继承其他类，否则就会出现多继承的错误！！！

【其次】在Java中实现接口和继承类是不冲突的，为了在生产代理类后，我们可以拿到被代理类的同名方法然后进行重写（重写内容后续说明），所以JDK Proxy选择了实现接口的这种方式

### 代码示例 ###

以下是动态代理的一个代码示例：

import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    
    // 定义接口
    interface UserService {
        
        void save();
    }
    
    // 实现接口的具体类
    class UserServiceImpl implements UserService {
        
        public void save() {
        
            System.out.println("Save user");
        }
    }
    
    // 实现InvocationHandler接口来自定义代理逻辑
    class MyInvocationHandler implements InvocationHandler {
        
        private Object target;
    
        public MyInvocationHandler(Object target) {
        
            this.target = target;
        }
    
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        
            System.out.println("Before method");
            Object result = method.invoke(target, args);
            System.out.println("After method");
            return result;
        }
    }
    
    public class Main {
        
        public static void main(String[] args) {
        
            UserService userService = new UserServiceImpl();
    
            // 创建InvocationHandler对象
            MyInvocationHandler handler = new MyInvocationHandler(userService);
    
            // 通过Proxy类的静态方法创建代理对象
            UserService proxy = (UserService) Proxy.newProxyInstance(
                    userService.getClass().getClassLoader(),
                    userService.getClass().getInterfaces(),
                    handler
            );
    
            // 调用代理对象的方法
            proxy.save();
        }
    }

在这段代码中

【1】我们先看接口和被代理类，实现比较简单，接口实现类重写接口方法。

【2】MyInvocationHandler是一个接口实现类，它的目的是为了创建自定义的代理规则逻辑，target属性就是被代理类，MyInvocationHandler的构造方法必须将被代理对象的引用传递进来，然后进行属性赋值

【3】MyInvocationHandler中的invoke()方法是最核心的，它才是实现动态代理规则逻辑的主要部分

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

在这个方法中，method.invoke这个语句就是我们被代理类的方法执行，这个方法中通过传递被代理类target，在内部调用这个被代理类的方法，然后在metho.invoke方法上下就可以执行其他前置后置增强逻辑，也就是说，我们生成的动态代理类的同名方法是`通过实现前置逻辑和后置逻辑＋被代理类的同名方法`来实现动态代理，这样既不会丢失原本逻辑也可以做大增强！！！

【4】在main方法中

proxy.save()

这个方法其实即是动态代理生成的方法，也就是MyInvocationHandler中的invoke方法

### 图解（逻辑） ###

![在这里插入图片描述][e542ca94634d40e0aae8cafffaeebda0.png_pic_center]

## CGLIB ##

CGLIB是非官方创建的动态代理库。`它通过继承被代理类来创建代理类。`CGLib不需要被代理类实现接口，它能够代理普通的类。CGLib通过修改字节码来实现代理。

### 代码示例 ###

import net.sf.cglib.proxy.Enhancer;
    import net.sf.cglib.proxy.MethodInterceptor;
    import net.sf.cglib.proxy.MethodProxy;
    
    import java.lang.reflect.Method;
    
    // 被代理类
    class RealSubject {
        
        public void doSomething() {
        
            System.out.println("RealSubject doSomething");
        }
    }
    
    // 代理类
    class ProxySubject implements MethodInterceptor {
        
        private Object target; // 被代理对象
    
        public Object getInstance(Object target) {
        
            this.target = target;
            Enhancer enhancer = new Enhancer();
            enhancer.setSuperclass(this.target.getClass());
            enhancer.setCallback(this);
            return enhancer.create();
        }
    
        public Object intercept(Object obj, 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;
        }
    }
    
    public class CGLIBDynamicProxyExample {
        
        public static void main(String[] args) {
        
            ProxySubject proxy = new ProxySubject();
            RealSubject realSubject = (RealSubject) proxy.getInstance(new RealSubject());
            realSubject.doSomething();
        }
    }

【1】在这段代码中，我们会发现在ProxySubject类中的getInstance方法也需要传入被代理类target，但与JDK 不同的是，这个方法内部是为了获取他的class类，然后生成一个代理类继承自被代理类。

【2】与JDK Proxy中类似，也有一个类似于invoke方法的intercept方法，他内部执行的`proxy.invokeSuper(obj,args)`，其实就是调用父类的目标方法，也就是被代理类的方法

【3】在main方法中，我们会发现其创建代理类的方式和JDK Proxy很相似，都需要把代理规则类放入到代理工厂中进行创建，最后创建出来的对象就是被代理对象的子类

### 图解 ###

![在这里插入图片描述][28e0984b57cf4288b39b0c9a7ed8d042.png_pic_center]

仅为个人学习笔记 感谢阅读

[e542ca94634d40e0aae8cafffaeebda0.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/4e047c19fa264537ad934d52e9675f33.png
[28e0984b57cf4288b39b0c9a7ed8d042.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/26579943eb154f3f92a4ac74120869e7.png