jdk动态代理使用详解

以你之姓@ 2023-09-30 14:07 20阅读 0赞

### 前言 ###

代理模式不管是JDK，spring框架，还是日常的开发中几乎可以说无处不在，下面一张简图描述了代理这个模式的业务场景，有过一些开发经验的同学对这张图应该不难理解；

![在这里插入图片描述][34e831e5f4f341409b784266733ec95d.png]

### 为什么需要代理 ###

**1、原有功能增强**

举例来说，当现有的类的代码只能满足一些基本的功能，而这些功能满足不了新需求，但又不能改动以前的代码，这时候就可以考虑使用代理，通过代理类，扩展原有类的功能，客户端访问的入口只是聪目标对象切换到代理对象而已；

**2、降低耦合**

在程序设计时，需要遵循一个叫做“单一职责”的原则，该原则要求每个类功能尽可能单一，为什么要单一，因为只有功能单一这个类被改动的可能性才会最小。

现在突然接到需求，需要对现有类的增删改这样的事务性操作增加审计日志，很多人第一想到的是给每个增删改的地方增加日志，如果这样的类特别多，这就很折腾了，比较好的办法就是，使用代理类，在不对原来类修改的基础上，进行日志功能的扩展即可（spring aop功能即是如此）；

### java中常用的代理模式 ###

总结下来，java中常用的代理实现主要包括：

*  jdk动态代理；
 *  cglib静态代理

### 一、JDK 动态代理 ###

JDK 动态代理是基于拦截器和反射实现的，不需要第三方库支持，只需要 JDK 环境即可

*  必须实现 InvocationHandler 接口；
 *  使用 Proxy.newProxyInstance 产生代理对象；
 *  被代理的对象必须要实现接口；
 *  内部采用asm技术动态生成字节码；

下面来看一个jdk动态代理的简单案例，深入理解下其用法

public class JdkProxyDemo {
        
    
        interface Foo{
        
            void foo();
        }
    
        static class Target implements Foo{
        
            @Override
            public void foo() {
        
                System.out.println(" target foo");
            }
        }
    
        /**
         * jdk代理只能针对接口进行代理
         * 内部采用asm技术动态生成字节码（）
         * @param args
         */
        public static void main(String[] args) {
        
    
            Target target = new Target();
    
            ClassLoader classLoader = JdkProxyDemo.class.getClassLoader();
            Foo proxy = (Foo)Proxy.newProxyInstance(classLoader, new Class[]{
        Foo.class}, new InvocationHandler() {
        
                //proxy 代理对象自身
                //method 正在执行的方法
                //方法参数
                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        
                    System.out.println("before");
                    Object result = method.invoke(target, args);
                    //代理类返回的是目标方法执行的结果
                    System.out.println("after");
                    return result;
                }
            });
            proxy.foo();
        }
    }

运行这段代码，观察下效果

![在这里插入图片描述][16af7382a94a4d6ea62c821c5610e354.png]

public static Object newProxyInstance(ClassLoader loader,
                                              Class<?>[] interfaces,
                                              InvocationHandler h)
            throws IllegalArgumentException

代码本身很简单，最重要的就是Proxy.newProxyInstance 这个方法，理解这里面的几个参数至关重要，分别说明下几个参数的含义：

*  classLoader，类加载器；
 *  interfaces，目标对象接口；
 *  InvocationHandler，真正完成相关方法反射代理的处理器；

> JDK动态代理，其关键的步骤就是在InvocationHandler 中执行目标实现类的方法反射调用

由于JDK动态代理，底层是采用了asm字节码技术动态生成，我们无法通过debug源码的方式去学习，为了深入了解其原理，不妨模拟下其实现的过程吧；

**要模拟这个过程，大概需要下面的这些准备：**

*  接口和接口实现类；
 *  自定义的invocationHandler；
 *  自定义的Proxy对象（实现与目标类相同的接口）；

**1、自定义接口和实现**

interface Foo{
        
            void foo();
        }
    
        static class Target implements Foo{
        
            @Override
            public void foo() {
        
                System.out.println(" target foo");
            }
        }

**2、自定义的invocationHandler；**

通过上面的demo也可以看到，invocationHandler其实就是一个接口，真正执行时，需要传入到Proxy对象中，通过接口回调的方式实现，这里只需要参照JDK中的invocationHandler，定义好方法参数即可；

public interface MyInvocationHandler {
        
            Object invoke(Object proxy, Method method, Object[] params);
        }

**3、自定义的Proxy对象**

这段代码的逻辑大致如下：

*  以构造的方式将自定义invocationHandler传入；
 *  通过反射拿到目标接口的方法；
 *  通过自定义invocationHandler的接口回调，通过反射完成代理逻辑实现；

import java.lang.reflect.Method;
    
    public class MyProxy implements SelfJdkProxy.Foo {
        
    
        private SelfJdkProxy.MyInvocationHandler invocationHandler;
    
        public MyProxy(SelfJdkProxy.MyInvocationHandler invocationHandler) {
        
            this.invocationHandler = invocationHandler;
        }
    
        @Override
        public void foo() {
        
            try {
        
                Method foo = SelfJdkProxy.Foo.class.getMethod("foo");
                invocationHandler.invoke(this, foo, new Object[0]);
            } catch (NoSuchMethodException e) {
        
                e.printStackTrace();
            }
    
    
        }
    
        @Override
        public int bar() {
        
            Method bar = null;
            Object result = null;
            try {
        
                bar = SelfJdkProxy.Foo.class.getMethod("bar");
                result = invocationHandler.invoke(this, bar, new Object[0]);
            } catch (NoSuchMethodException e) {
        
                e.printStackTrace();
            }
            return (int) result;
        }
    }

运行上面的代码，观察效果，可以看到，输出效果是一样的，通过这个实现，我们简单模拟了JDK动态代理内部的简单实现；  
![在这里插入图片描述][f8b087c2455043a8acabb486e100c23e.png]

### 二、cglib静态代理 ###

JDK实现动态代理需要实现类通过接口定义业务方法，对于没有接口的类，如何实现动态代理呢，这就需要cglib了；

cglib采用了非常底层的字节码技术，其原理是通过字节码技术为一个类创建子类，并在子类中采用方法拦截的技术拦截所有父类方法的调用，顺势织入横切逻辑。

下面先看一个简单的cglib使用案例

**1、原始目标方法**

/**
     * 原始目标方法
     */
    public class CglibTarget {
        
    
        public void save() {
        
            System.out.println("save()");
        }
    
        public void save(int i) {
        
            System.out.println("save(int)");
        }
    
        public void save(long i) {
        
            System.out.println("save(long)");
        }
    
    }

**2、代理实现核心逻辑**

/**
     * cglib代理是通过父子继承关系创建代理
     * 代理对象自身是作为一个子类型的存在
     */
    public class CglibProxyDemo {
        
    
        static class Target {
        
            public void foo() {
        
                System.out.println(" target foo");
            }
        }
    
        public static void main(String[] args) {
        
            Target target = new Target();
            Target proxy = (Target)Enhancer.create(Target.class, new MethodInterceptor() {
        
                // o : 代理类对象自身
                //method : 代理类执行的方法
                //args : 方法执行参数
                //methodProxy :  方法代理【采用这个参数，可以避免使用方法反射进行调用，但是内部未使用反射】
                @Override
                public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        
    
                   /* System.out.println("before");
                    Object result = method.invoke(target, args);
                    System.out.println("after");
                    return result;*/
    
                   //methodProxy 使用 ，使用目标进行代理
                    /*System.out.println("before");
                    Object result = methodProxy.invoke(target,args);
                    System.out.println("after");
                    return result;*/
    
                    //methodProxy 使用 ，使用自身进行代理
                    System.out.println("before");
                    Object result = methodProxy.invokeSuper(o,args);
                    System.out.println("after");
                    return result;
    
                }
            });
            proxy.foo();
        }
    
    }

cglib的使用相对JDK代理来说，显得更灵活，用起来也很方便，比较核心的地方在于通过调用CglibProxy这个方法的setMethodInterceptor，在回调接口中完成代理逻辑的实现；

这里需要说明的是， 在MethodInterceptor 接口回调方法中，提供了两种完成代理逻辑实现的方式，

*  method.invoke(target,args); 基于反射实现；
 *  methodProxy.invoke(target,args); 直接调用目标类的方法；
 *  methodProxy.invokeSuper(o,args);直接调用目标类的方法；

> 需要特别注意的是，CGLib创建的动态代理对象性能比JDK创建的动态代理对象的性能高不少，但CGLib在创建代理对象时所花费的时间却比JDK多得多，所以对于单例对象，因无需频繁创建对象，用CGLib合适，反之，使用JDK方式要更为合适一些。同时，由于CGLib由于是采用动态创建子类的方法，对于final方法，无法进行代理。

同样来说，cglib底层的字节码技术的实现导致我们很难通过debug的方式去调试源码，下面来通过代码模拟上面的实现过程；

**自定义一个类，模拟Enhancer 实现**

整段代码逻辑做如下说明

*  注入MethodInterceptor ，模拟cglib的create方法中的Enhancer；
 *  继承CglibTarget，即cglib采用的是继承目标类的方式完成代理；
 *  将代理类中的方法重写，并通过methodInterceptor.intercept 完成接口回调；
 *  将目标类中的方法，以静态代码块方式注入，避免每次调用重新实例化；
 *  自定义saveSuper方法，模拟MethodProxy 的实现过程；

/**
     * cglib的代理是基于继承，并重写父类方法进行增强
     */
    public class CglibProxy extends CglibTarget {
        
    
        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 = CglibTarget.class.getMethod("save");
                save1 = CglibTarget.class.getMethod("save", int.class);
                save2 = CglibTarget.class.getMethod("save", long.class);
    
                save0Proxy = MethodProxy.create(CglibTarget.class, CglibProxy.class, "()V", "save", "saveSuper");
                save1Proxy = MethodProxy.create(CglibTarget.class, CglibProxy.class, "(I)V", "save1", "saveSuper");
                save2Proxy = MethodProxy.create(CglibTarget.class, CglibProxy.class, "(J)V", "save2", "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 i) {
        
            super.save(i);
        }
    
        @Override
        public void save() {
        
            try {
        
                methodInterceptor.intercept(this, save0, new Object[0], save0Proxy);
            } catch (Throwable throwable) {
        
                //throwable.printStackTrace();
                throw new UndeclaredThrowableException(throwable);
            }
        }
    
        @Override
        public void save(int i) {
        
            try {
        
                methodInterceptor.intercept(this, save1, new Object[]{
        i}, save1Proxy);
            } catch (Throwable throwable) {
        
                //throwable.printStackTrace();
                throw new UndeclaredThrowableException(throwable);
            }
        }
    
        @Override
        public void save(long i) {
        
            try {
        
                methodInterceptor.intercept(this, save2, new Object[]{
        i}, save2Proxy);
            } catch (Throwable throwable) {
        
                //throwable.printStackTrace();
                throw new UndeclaredThrowableException(throwable);
            }
        }
    }

**编写测试类**

public class CglibTest {
        
    
        public static void main(String[] args) {
        
            CglibProxy proxy = new CglibProxy();
            CglibTarget target = new CglibTarget();
    
            proxy.setMethodInterceptor(new MethodInterceptor() {
        
                @Override
                public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        
                    System.out.println("before...");
                    //return method.invoke(target,args);
                    //return methodProxy.invoke(target,args);
                    return methodProxy.invokeSuper(o,args);
                }
            });
            proxy.save();
        }
    }

运行上面的代码，通过控制台输出结果，可以看到和上面的效果一致；

![在这里插入图片描述][f394d1c2d6f04d98a365d67bdd91b049.png]

这里需要对这个MethodProxy稍作说明，通过上面的案例可以看到，cglib的回调逻辑中，不仅可以通过类似JDK的反射实现代理，还可以通过MethodProxy提供的invoke()或者invokeSuper()方式实现，之所以说，cglib在某些情况下比JDK代理高效，就在于通过MethodProxy的两个方法，将不走反射，而是直接调用目标类的方法；

### 三、spring中代理的使用 ###

在spring框架中，使用代理模式比较典型的场景就是AOP的实现了，代理逻辑核心要点如下：

*  默认使用 JDK 动态代理，这样可以代理所有的接口类型；
 *  如果目标对象没有实现任何接口，则默认采用CGLIB代理；
 *  可强制使用CGLIB，指定proxy-target-class = “true” 或者 基于注解@EnableAspectJAutoProxy(proxyTargetClass = true)

下面以AOP的功能使用为入口，来感受下以上三点在AOP的代理中的实现，

来看下面这段以spring底层模拟实现的方式的AOP功能代码

import org.aopalliance.intercept.MethodInterceptor;
    import org.aopalliance.intercept.MethodInvocation;
    import org.springframework.aop.aspectj.AspectJExpressionPointcut;
    import org.springframework.aop.framework.ProxyFactory;
    import org.springframework.aop.support.DefaultPointcutAdvisor;
    
    public class SpringAopTest {
        
    
        public static void main(String[] args) {
        
            //1、定义切点
            AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut();
            pointcut.setExpression("execution(* foo())");
    
            //2、定义通知
            MethodInterceptor advice = new MethodInterceptor() {
        
                @Override
                public Object invoke(MethodInvocation methodInvocation) throws Throwable {
        
                    return methodInvocation.proceed();
                }
            };
    
            //3、定义切面
            DefaultPointcutAdvisor advisor = new DefaultPointcutAdvisor(pointcut, advice);
    
            //4、创建代理
            Target1 target1 = new Target1();
            ProxyFactory proxyFactory = new ProxyFactory();
            proxyFactory.setTarget(target1);
            proxyFactory.addAdvisor(advisor);
    
            F1 proxy = (F1)proxyFactory.getProxy();
            //查看代理类的类型
            System.out.println(proxy.getClass());
            proxy.foo();
            proxy.bar();
    
        }
    
        interface F1 {
        
            void foo();
            void bar();
        }
    
        static class Target1 implements F1 {
        
            @Override
            public void foo() {
        
                System.out.println("Target1 foo() ...");
            }
    
            @Override
            public void bar() {
        
                System.out.println("Target1 bar() ...");
            }
        }
    
        static class Target2 implements F1 {
        
            @Override
            public void foo() {
        
                System.out.println("Target2 foo() ...");
            }
    
            @Override
            public void bar() {
        
                System.out.println("Target2 bar() ...");
            }
        }
    }

主要逻辑思路可以参考注释，然后运行这段代码，观察控制台效果  
![在这里插入图片描述][1b28101079374e7995d47d1bf2e41267.png]

通过控制台输出结果，可以大致得出下面几点结论，

*  AOP技术底层采用了代理实现；
 *  如果目标类实现了接口，spring默认情况下使用的是JDK代理；
 *  可以通过修改ProxyConfig中的属性proxyTargetClass 值来改变代理方式；

![在这里插入图片描述][bf31caf850a74c7c98cc158476e6d25c.png]

根据这个属性的不同，将会产生下面几种代理方式

*  proxyTargetClass = false; 目标实现了接口，采用JDK代理实现；
 *  proxyTargetClass = false; 目标没有实现接口，采用cglib实现；
 *  proxyTargetClass = true; 总是使用cglib实现；

关于上面这几点，我们来通过上面代码的微调来观察效果，上面为什么会输出的是cglib的代理呢？因为在程序中并没有设置这个属性，因此被判断为并未实现接口，所以走的是cglib代理，

**调整1：设置代理类的接口**

![在这里插入图片描述][39a3b8ee52f940689365ca74eee5c19f.png]

再次运行上面的代码，这次走的就是JDK动态代理  
![在这里插入图片描述][197e6bcde77c438188dbf1948a39d03a.png]

**调整2：设置proxyTargetClass 属性为true**

![在这里插入图片描述][8eb7314d56774c13aa94b7cea7c09971.png]

再次运行上面的代码，这次走的就是cglib代理  
![在这里插入图片描述][5b524dab25324e04baa96c40921b9680.png]

[34e831e5f4f341409b784266733ec95d.png]: https://img-blog.csdnimg.cn/34e831e5f4f341409b784266733ec95d.png
[16af7382a94a4d6ea62c821c5610e354.png]: https://img-blog.csdnimg.cn/16af7382a94a4d6ea62c821c5610e354.png
[f8b087c2455043a8acabb486e100c23e.png]: https://img-blog.csdnimg.cn/f8b087c2455043a8acabb486e100c23e.png
[f394d1c2d6f04d98a365d67bdd91b049.png]: https://img-blog.csdnimg.cn/f394d1c2d6f04d98a365d67bdd91b049.png
[1b28101079374e7995d47d1bf2e41267.png]: https://img-blog.csdnimg.cn/1b28101079374e7995d47d1bf2e41267.png
[bf31caf850a74c7c98cc158476e6d25c.png]: https://img-blog.csdnimg.cn/bf31caf850a74c7c98cc158476e6d25c.png
[39a3b8ee52f940689365ca74eee5c19f.png]: https://img-blog.csdnimg.cn/39a3b8ee52f940689365ca74eee5c19f.png
[197e6bcde77c438188dbf1948a39d03a.png]: https://img-blog.csdnimg.cn/197e6bcde77c438188dbf1948a39d03a.png
[8eb7314d56774c13aa94b7cea7c09971.png]: https://img-blog.csdnimg.cn/8eb7314d56774c13aa94b7cea7c09971.png
[5b524dab25324e04baa96c40921b9680.png]: https://img-blog.csdnimg.cn/5b524dab25324e04baa96c40921b9680.png