【探索Spring底层】8.手撕jdk代理原理与cglib代理原理

骑猪看日落 2024-04-06 13:20 111阅读 0赞

#### 文章目录 ####

*  【探索Spring底层】手撕jdk代理原理与cglib代理原理
 *  1. 前言回顾
 *  2. 手撕jdk代理
 *  3. jdk反射优化
 *  4. 手撕cglib代理

## 【探索Spring底层】手撕jdk代理原理与cglib代理原理 ##

## 1. 前言回顾 ##

**Spring的AOP实现有两个方式：**

*  jdk代理
 *  cglib代理

**两者不同之处在于**

*  jdk要求实现接口，cglib不要求目标实现接口
 *  jdk代理与目标之间是平级的兄弟关系，cglib代理与目标之间是父子关系

--------------------

## 2. 手撕jdk代理 ##

接口

public interface Foo {
        
        void foo();
        int bar();
    }

目标

public class Target implements Foo {
        
        public void foo() {
        
            System.out.println("target foo");
        }
    
        @Override
        public int bar() {
        
            System.out.println("target bar");
            return 100;
        }
    }

自定义InvocationHandler接口，里面有三个参数

*  proxy是指代理对象
 *  Method是指方法
 *  Object是指方法执行需要的参数

public interface InvocationHandler {
        
        Object invoke(Object proxy, Method method, Object[] args) throws Throwable;
    }

**手撕开始！！！**

首先新建一个类$Proxy0实现Foo接口

在$Proxy0定义两个方法，通过反射获取到Foo类中的需要增强的两个方法foo和bar

同时还需要在类中定义一个成员变量InvocationHandler

**之所以出现这个InvocationHandler（函数式接口），是因为aop增强的内容各不相同，如果写死在代理类中，那么就不能实现动态代理了（也就是说不这样做的话，一个代理类就只能实现一种增强方式，如果需要一百种不同的aop增强，那就需要一百种代理类），所以需要这个函数式接口，定义不同的增强内容**

**这个类可不简单，是实现动态代理的核心**

然后调用InvocationHandler的invoke方法，将代理对象、需要增强的方法、方法的参数作为参数传递过去

public class $Proxy0 implements Foo {
        private InvocationHandler h;
    
        public $Proxy0(InvocationHandler h) {
            this.h = h1;
        }
        
        static Method foo;
        static Method bar;
        static {
            try {
                foo = A12.Foo.class.getMethod("foo");
                bar = A12.Foo.class.getMethod("bar");
            } catch (NoSuchMethodException e) {
                throw new NoSuchMethodError(e.getMessage());
            }
        }
    
        @Override
        public void foo() {
            try {
                h.invoke(this, foo, new Object[0]);
            } catch (RuntimeException | Error e) {
                throw e;
            } catch (Throwable e) {
                throw new UndeclaredThrowableException(e);
            }
        }
    
        @Override
        public int bar() {
            try {
                Object result = h.invoke(this, bar, new Object[0]);
                return (int) result;
            } catch (RuntimeException | Error e) {
                throw e;
            } catch (Throwable e) {
                throw new UndeclaredThrowableException(e);
            }
        }
    }

编写测试代码测试

返回值之所以是Object是因为不是所有的方法返回值是void

为了避免返回值不是void 所以这里设计为Object

public static void main(String[] param) {
        
        Foo proxy = new $Proxy0(new InvocationHandler() {
        
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable{
        
                // 1. 功能增强
                System.out.println("before...");
                // 2. 调用目标
                //方法反射调用
                return method.invoke(new Target(), args);
            }
        });
        proxy.foo();
        proxy.bar();
    }

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

> **注意：**
> 
> **method.invoke(" 要调用的方法的名字所隶属的对象实体",方法的参数值);**
> 
> **所以这里需要传递参数Target，因为需要增强的方法属于这个实体类**
> 
> **在完成增强之后的操作之后，就应该输入原来的实体类的对应方法的执行结果，并return**

--------------------

## 3. jdk反射优化 ##

在前面调用目标的方法的时候是使用反射调用

**反射调用效率性能要比正常调用要低，那么jdk代理对此有做什么优化吗？**

// 运行时请添加 --add-opens java.base/java.lang.reflect=ALL-UNNAMED --add-opens java.base/jdk.internal.reflect=ALL-UNNAMED
    
    /**
     * 前16次是基于java本地api实现的，性能低
     *  代理是在运行期间生成的代理类
     */
    public class TestMethodInvoke {
        
        public static void main(String[] args) throws Exception {
        
            Method foo = TestMethodInvoke.class.getMethod("foo", int.class);
            for (int i = 1; i <= 17; i++) {
        
                show(i, foo);
                foo.invoke(null, i);
            }
            System.in.read();
        }
    
        // 方法反射调用时, 底层 MethodAccessor 的实现类
        private static void show(int i, Method foo) throws Exception {
        
            Method getMethodAccessor = Method.class.getDeclaredMethod("getMethodAccessor");
            getMethodAccessor.setAccessible(true);
            Object invoke = getMethodAccessor.invoke(foo);
            if (invoke == null) {
        
                System.out.println(i + ":" + null);
                return;
            }
            Field delegate = Class.forName("jdk.internal.reflect.DelegatingMethodAccessorImpl").getDeclaredField("delegate");
            delegate.setAccessible(true);
            System.out.println(i + ":" + delegate.get(invoke));
        }
    
        public static void foo(int i) {
        
            System.out.println(i + ":" + "foo");
        }
    }

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

**由运行结果可以看出，前16次是通过NativeMethodAccessorImpl来反射调用方法的，效率比较低，这是基于java本地api实现的**

**但是从17次开始，就使用GeneratedMethodAccessor来调用方法了，效率相对较高**

**之所以效率相对较高，是因这里是直接调用方法，而不是反射调用**

**当然，完成这一系列的操作也是有代价的，这是借助代理来实现，代理是在运行期间生成的代理类**

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

--------------------

## 4. 手撕cglib代理 ##

在了解了上面的jdk代理之后，想要理解cglib代理就会变得简单不少了

同样的通过一个案例来理解其底层实现

目标

public class Target {
        
        public void save() {
        
            System.out.println("save()");
        }
    
        public void save(int i) {
        
            System.out.println("save(int)");
        }
    
        public void save(long j) {
        
            System.out.println("save(long)");
        }
    }

代理类：

简单来说，这里的实现流程如下

首先如果增强的方法是使用反射调用的话

*  需要获取需要增强的目标对象的各种方法对象Method
 *  代理对类继承目标类，并重写目标类需要增强的方法
 *  使用MethodInterceptor类进行增强（其四个参数分别是指代理类、需要增强的方法对象、方法执行所需参数、方法的代理类）
 *  最后在测试类中通过methodProxy.invoke(target, args)反射调用，在反射之前或者之后就可以进行增强，最后只需要将反射调用的结果retun即可

但是如果增强的方法是使用代理调用的话

*  不仅需要准备带增强功能的方法，并且还需要准备带原始功能的方法
 *  对每个方法创建其代理对象（MethodProxy.create）
 *  创建方法的代理对象的五个参数分别代表
    
    1.  需要增强的对象的class
    2.  代理对象的class
    3.  描述–》
        
        1.  （）里面是指带增强方法的参数，如果括号里面什么也没有代表不需要参数；如果括号里面是I，代表参数为int类型；如果括号里面是J，代表是long类型
    4.  带增强功能的方法
    5.  带增强功能的方法对象的其带原始功能的方法
 *  最后在测试类通过methodProxy.invokeSuper(p, args)代理调用方法

public class Proxy extends Target {
        
    
        private MethodInterceptor methodInterceptor;
    
        public void setMethodInterceptor(MethodInterceptor methodInterceptor) {
        
            this.methodInterceptor = methodInterceptor;
        }
    
        static Method save0;
        static Method save1;
        static Method save2;
        static MethodProxy save0Proxy;
        static MethodProxy save1Proxy;
        static MethodProxy save2Proxy;
        static {
        
            try {
        
                save0 = Target.class.getMethod("save");
                save1 = Target.class.getMethod("save", int.class);
                save2 = Target.class.getMethod("save", long.class);
                save0Proxy = MethodProxy.create(Target.class, Proxy.class, "()V", "save", "saveSuper");
                save1Proxy = MethodProxy.create(Target.class, Proxy.class, "(I)V", "save", "saveSuper");
                save2Proxy = MethodProxy.create(Target.class, Proxy.class, "(J)V", "save", "saveSuper");
            } catch (NoSuchMethodException e) {
        
                throw new NoSuchMethodError(e.getMessage());
            }
        }
    
        // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 带原始功能的方法
        public void saveSuper() {
        
            super.save();
        }
        public void saveSuper(int i) {
        
            super.save(i);
        }
        public void saveSuper(long j) {
        
            super.save(j);
        }
        // >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 带增强功能的方法
        @Override
        public void save() {
        
            try {
        
                methodInterceptor.intercept(this, save0, new Object[0], save0Proxy);
            } catch (Throwable e) {
        
                throw new UndeclaredThrowableException(e);
            }
        }
    
        @Override
        public void save(int i) {
        
            try {
        
                methodInterceptor.intercept(this, save1, new Object[]{
        i}, save1Proxy);
            } catch (Throwable e) {
        
                throw new UndeclaredThrowableException(e);
            }
        }
    
        @Override
        public void save(long j) {
        
            try {
        
                methodInterceptor.intercept(this, save2, new Object[]{
        j}, save2Proxy);
            } catch (Throwable e) {
        
                throw new UndeclaredThrowableException(e);
            }
        }
    }

测试类

public class A13 {
        
    
        public static void main(String[] args) {
        
            Proxy proxy = new Proxy();
            Target target = new Target();
            proxy.setMethodInterceptor(new MethodInterceptor() {
        
                @Override
                public Object intercept(Object p, Method method, Object[] args,
                                        MethodProxy methodProxy) throws Throwable {
        
                    System.out.println("before...");
    //                return method.invoke(target, args); // 反射调用
                    // FastClass
    //                return methodProxy.invoke(target, args); // 内部无反射, 结合目标用
                    return methodProxy.invokeSuper(p, args); // 内部无反射, 结合代理用
                }
            });
    
            proxy.save();
            proxy.save(1);
            proxy.save(2L);
        }
    }

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

--------------------

[9a6d035eb5a64b1ea88c15f57eeb8a2a.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/12e111ce46dd4aaaa57d5982aa711f50.png
[1ec998fdd50c4afc9416509bc8df8b8a.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/073ec0cdfead4785ae7985215e1e0301.png
[68694ef37c3747f499fb2391baa04da0.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/4228f63a31aa451a826e25ea59ab0c06.png
[775f2d24dfbf4d8f8bc68807bcadbb17.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/c4eb196b30a14b1e800c19cdfcc99e58.png