Spring系列第十六讲 Spring中的Java动态代理技术(下)

蔚落 2022-12-18 04:57 176阅读 0赞

### Spring系列第十六讲 ###

*  什么是cglib
 *  cglib组成结构
 *  5个案例来演示cglib常见的用法
 *   *  案例1：拦截所有方法（MethodInterceptor）
     *  案例2：拦截所有方法（MethodInterceptor）
     *  案例3：拦截所有方法并返回固定值（FixedValue）
     *   *  案例4：直接放行，不做任何操作（NoOp.INSTANCE）
     *  案例5：不同的方法使用不同的拦截器（CallbackFilter）
     *  案例6：对案例5的优化（CallbackHelper）
     *  案例6：实现通用的统计任意类方法耗时代理类
 *  CGLIB和Java动态代理的区别

# 什么是cglib #

jdk动态代理只能为接口创建代理，使用上有局限性。实际的场景中我们的类不一定有接口，此时如果我们想为普通的类也实现代理功能，我们就需要用到cglib来实现了。

cglib是一个强大、高性能的字节码生成库，它用于在运行时扩展Java类和实现接口；本质上它是通过动态的生成一个子类去覆盖所要代理的类（非final修饰的类和方法）。Enhancer可能是CGLIB中最常用的一个类，和jdk中的Proxy不同的是，Enhancer既能够代理普通的class，也能够代理接口。Enhancer创建一个被代理对象的子类并且拦截所有的方法调用（包括从Object中继承的toString和hashCode方法）。Enhancer不能够拦截final方法，例如Object.getClass()方法，这是由于Java final方法语义决定的。基于同样的道理，Enhancer也不能对final类进行代理操作。

CGLIB作为一个开源项目，其代码托管在github，地址为：

https://github.com/cglib/cglib

# cglib组成结构 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ3MTU3Njc2_size_16_color_FFFFFF_t_70_pic_center]  
CGLIB底层使用了ASM（一个短小精悍的字节码操作框架）来操作字节码生成新的类。除了CGLIB库外，脚本语言（如Groovy和BeanShell）也使用ASM生成字节码。ASM使用类似SAX的解析器来实现高性能。我们不鼓励直接使用ASM，因为它需要对Java字节码的格式足够的了解。

spring已将第三方cglib jar包中所有的类集成到spring自己的jar包中，本系列内容都是和spring相关的，为了方便，我们直接使用spring内部已集成的来讲解

# 5个案例来演示cglib常见的用法 #

## 案例1：拦截所有方法（MethodInterceptor） ##

创建一个具体的类，如下：

package com.javacode2018.lesson001.demo17;
    
    public class Service1 {
        
        public void m1() {
        
            System.out.println("我是m1方法");
        }
    
        public void m2() {
        
            System.out.println("我是m2方法");
        }
    }

下面我们为这个类创建一个代理，代理中实现打印每个方法的调用日志。

package com.javacode2018.lesson001.demo17;
    
    import org.junit.Test;
    import org.springframework.cglib.proxy.Enhancer;
    import org.springframework.cglib.proxy.MethodInterceptor;
    import org.springframework.cglib.proxy.MethodProxy;
    
    import java.lang.reflect.Method;
    
    public class CglibTest {
        
    
        @Test
        public void test1() {
        
            //使用Enhancer来给某个类创建代理类，步骤
            //1.创建Enhancer对象
            Enhancer enhancer = new Enhancer();
            //2.通过setSuperclass来设置父类型，即需要给哪个类创建代理类
            enhancer.setSuperclass(Service1.class);
            /*3.设置回调，需实现org.springframework.cglib.proxy.Callback接口，
            此处我们使用的是org.springframework.cglib.proxy.MethodInterceptor，也是一个接口，实现了Callback接口，
            当调用代理对象的任何方法的时候，都会被MethodInterceptor接口的invoke方法处理*/
            enhancer.setCallback(new MethodInterceptor() {
        
                /**
                 * 代理对象方法拦截器
                 * @param o 代理对象
                 * @param method 被代理的类的方法，即Service1中的方法
                 * @param objects 调用方法传递的参数
                 * @param methodProxy 方法代理对象
                 * @return
                 * @throws Throwable
                 */
                @Override
                public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        
                    System.out.println("调用方法:" + method);
                    //可以调用MethodProxy的invokeSuper调用被代理类的方法
                    Object result = methodProxy.invokeSuper(o, objects);
                    return result;
                }
            });
            //4.获取代理对象,调用enhancer.create方法获取代理对象，这个方法返回的是Object类型的，所以需要强转一下
            Service1 proxy = (Service1) enhancer.create();
            //5.调用代理对象的方法
            proxy.m1();
            proxy.m2();
        }
    }

上面代码中的注释很详细，列出了给指定的类创建代理的具体步骤，整个过程中主要用到了Enhancer类和MethodInterceptor接口。

enhancer.setSuperclass用来设置代理类的父类，即需要给哪个类创建代理类，此处是Service1

enhancer.setCallback传递的是MethodInterceptor接口类型的参数，MethodInterceptor接口有个intercept方法，这个方法会拦截代理对象所有的方法调用。

还有一个重点是Object result = methodProxy.invokeSuper(o, objects);可以调用被代理类，也就是Service1类中的具体的方法，从方法名称的意思可以看出是调用父类，实际对某个类创建代理，cglib底层通过修改字节码的方式为Service1类创建了一个子类。

运行输出：

调用方法:public void com.javacode2018.lesson001.demo17.Service1.m1()
    我是m1方法
    调用方法:public void com.javacode2018.lesson001.demo17.Service1.m2()
    我是m2方法

从输出中可以看出Service1中的2个方法都被MethodInterceptor中的invoke拦截处理了。

## 案例2：拦截所有方法（MethodInterceptor） ##

在创建一个类，如下：

package com.javacode2018.lesson001.demo17;
    
    
    public class Service2 {
        
        public void m1() {
        
            System.out.println("我是m1方法");
            this.m2(); //@1
        }
    
        public void m2() {
        
            System.out.println("我是m2方法");
        }
    }

这个类和上面的Service1类似，有点不同是@1，在m1方法中调用了m2方法。

下面来采用案例1中同样的方式来给Service2创建代理，如下：

@Test
    public void test2() {
        
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(Service2.class);
        enhancer.setCallback(new MethodInterceptor() {
        
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        
                System.out.println("调用方法:" + method);
                Object result = methodProxy.invokeSuper(o, objects);
                return result;
            }
        });
        Service2 proxy = (Service2) enhancer.create();
        proxy.m1(); //@1
    }

注意上面@1的代码，只调用了m1方法，看一下输出效果：

调用方法:public void com.javacode2018.lesson001.demo17.Service2.m1()
    我是m1方法
    调用方法:public void com.javacode2018.lesson001.demo17.Service2.m2()
    我是m2方法

从输出中可以看出m1和m2方法都被拦截器处理了，而m2方法是在Service1的m1方法中调用的，也被拦截处理了。

spring中的@configuration注解就是采用这种方式实现的，给大家上个@configuration案例眼熟一下：

package com.javacode2018.lesson001.demo17;
    
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    @Configuration
    public class Config {
        
    
        @Bean
        public C1 c1(){
        
            return new C1();
        }
        @Bean
        public C2 c2(){
        
            C1 c1 = this.c1(); //@1
            return new C2(c1);
        }
        @Bean
        public C3 c3(){
        
            C1 c1 = this.c1(); //@2
            return new C3(c1);
        }
    
        public static class C1{
        }
    
        public static class C2{
        
            private C1 c1;
    
            public C2(C1 c1) {
        
                this.c1 = c1;
            }
        }
        public static class C3{
        
            private C1 c1;
    
            public C3(C1 c1) {
        
                this.c1 = c1;
            }
        }
    
    }

上面代码中C2和C3依赖于C1，都是通过构造器注入C1，注意代码中的@1和@2都是调用c1方法获取容器中的C1，如何确保多次获取的C1都是一个的？这个地方就是使用cglib代理拦截@Bean注解的方法来实现的。

## 案例3：拦截所有方法并返回固定值（FixedValue） ##

当调用某个类的任何方法的时候，都希望返回一个固定的值，此时可以使用FixedValue接口，如下：

enhancer.setCallback(new FixedValue() {
        
                @Override
                public Object loadObject() throws Exception {
        
                    return "路人甲";
                }
            });

上面创建的代理对象，调用其任意方法返回的都是"路人甲"。

案例代码如下：

创建一个类Service3，如下：

package com.javacode2018.lesson001.demo17;
    
    public class Service3 {
        
        public String m1() {
        
            System.out.println("我是m1方法");
            return "hello:m1";
        }
    
        public String m2() {
        
            System.out.println("我是m2方法");
            return "hello:m2";
        }
    }

对用的测试用例：

@Test
    public void test3() {
        
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(Service3.class);
        enhancer.setCallback(new FixedValue() {
        
            @Override
            public Object loadObject() throws Exception {
        
                return "路人甲";
            }
        });
        Service3 proxy = (Service3) enhancer.create();
        System.out.println(proxy.m1());//@1
        System.out.println(proxy.m2()); //@2
        System.out.println(proxy.toString());//@3
    }

@1、@2、@3调用了代理对象的3个方法，运行输出：

运行输出：

路人甲
    路人甲
    路人甲

可以看出输出的都是一个拱顶的值。

### 案例4：直接放行，不做任何操作（NoOp.INSTANCE） ###

Callback接口下面有个子接口org.springframework.cglib.proxy.NoOp，将这个作为Callback的时候，被调用的方法会直接放行，像没有任何代理一样，感受一下效果：

@Test
    public void test6() {
        
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(Service3.class);
        enhancer.setCallback(NoOp.INSTANCE);
        Service3 proxy = (Service3) enhancer.create();
        System.out.println(proxy.m1());
        System.out.println(proxy.m2());
    }

运行输出：

我是m1方法
    hello:m1
    我是m2方法
    hello:m2

从输出中可以看出，被调用的方法没有被代理做任何处理，直接进到目标类Service3的方法中了。

## 案例5：不同的方法使用不同的拦截器（CallbackFilter） ##

有个类如下：

package com.javacode2018.lesson001.demo17;
    
    public class Service4 {
        
        public void insert1() {
        
            System.out.println("我是insert1");
        }
    
        public void insert2() {
        
            System.out.println("我是insert2");
        }
    
        public String get1() {
        
            System.out.println("我是get1");
            return "get1";
        }
    
        public String get2() {
        
            System.out.println("我是get2");
            return "get2";
        }
    }

需求，给这个类创建一个代理需要实现下面的功能：

1.  以insert开头的方法需要统计方法耗时
2.  以get开头的的方法直接返回固定字符串`欢迎和【易兮科技】一起学spring！`

下来看代码，然后再解释：

@Test
    public void test4() {
        
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(Service4.class);
        //创建2个Callback
        Callback[] callbacks = {
        
                //这个用来拦截所有insert开头的方法
                new MethodInterceptor() {
        
                    @Override
                    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        
                        long starTime = System.nanoTime();
                        Object result = methodProxy.invokeSuper(o, objects);
                        long endTime = System.nanoTime();
                        System.out.println(method + "，耗时(纳秒):" + (endTime - starTime));
                        return result;
                    }
                },
                //下面这个用来拦截所有get开头的方法，返回固定值的
                new FixedValue() {
        
                    @Override
                    public Object loadObject() throws Exception {
        
                        return "易兮科技";
                    }
                }
        };
        enhancer.setCallbackFilter(new CallbackFilter() {
        
            @Override
            public int accept(Method method) {
        
                return 0;
            }
        });
        //调用enhancer的setCallbacks传递Callback数组
        enhancer.setCallbacks(callbacks);
        /**
         * 设置过滤器CallbackFilter
         * CallbackFilter用来判断调用方法的时候使用callbacks数组中的哪个Callback来处理当前方法
         * 返回的是callbacks数组的下标
         */
        enhancer.setCallbackFilter(new CallbackFilter() {
        
            @Override
            public int accept(Method method) {
        
                //获取当前调用的方法的名称
                String methodName = method.getName();
                /**
                 * 方法名称以insert开头，
                 * 返回callbacks中的第1个Callback对象来处理当前方法，
                 * 否则使用第二个Callback处理被调用的方法
                 */
                return methodName.startsWith("insert") ? 0 : 1;
            }
        });
        Service4 proxy = (Service4) enhancer.create();
        System.out.println("---------------");
        proxy.insert1();
        System.out.println("---------------");
        proxy.insert2();
        System.out.println("---------------");
        System.out.println(proxy.get1());
        System.out.println("---------------");
        System.out.println(proxy.get2());
    
    }

运行输出：

---------------
    我是insert1
    public void com.javacode2018.lesson001.demo17.Service4.insert1()，耗时(纳秒):15396100
    ---------------
    我是insert2
    public void com.javacode2018.lesson001.demo17.Service4.insert2()，耗时(纳秒):66200
    ---------------
    易兮科技
    ---------------
    易兮科技

代码说明：

由于需求中要对不同的方法做不同的处理，所以需要有2个Callback对象，当调用代理对象的方法的时候，具体会走哪个Callback呢，此时会通过CallbackFilter中的accept来判断，这个方法返回callbacks数组的索引。

上面这个案例还有一种简单的实现，见案例6

## 案例6：对案例5的优化（CallbackHelper） ##

cglib中有个CallbackHelper类，可以对案例5的代码进行有环，CallbackHelper类相当于对一些代码进行了封装，方便实现案例5的需求，实现如下：

@Test
    public void test5() {
        
        Enhancer enhancer = new Enhancer();
        //创建2个Callback
        Callback costTimeCallback = (MethodInterceptor) (Object o, Method method, Object[] objects, MethodProxy methodProxy) -> {
        
            long starTime = System.nanoTime();
            Object result = methodProxy.invokeSuper(o, objects);
            long endTime = System.nanoTime();
            System.out.println(method + "，耗时(纳秒):" + (endTime - starTime));
            return result;
        };
        //下面这个用来拦截所有get开头的方法，返回固定值的
        Callback fixdValueCallback = (FixedValue) () -> "路人甲Java";
        CallbackHelper callbackHelper = new CallbackHelper(Service4.class, null) {
        
            @Override
            protected Object getCallback(Method method) {
        
                return method.getName().startsWith("insert") ? costTimeCallback : fixdValueCallback;
            }
        };
        enhancer.setSuperclass(Service4.class);
        //调用enhancer的setCallbacks传递Callback数组
        enhancer.setCallbacks(callbackHelper.getCallbacks());
        /**
         * 设置CallbackFilter,用来判断某个方法具体走哪个Callback
         */
        enhancer.setCallbackFilter(callbackHelper);
        Service4 proxy = (Service4) enhancer.create();
        System.out.println("---------------");
        proxy.insert1();
        System.out.println("---------------");
        proxy.insert2();
        System.out.println("---------------");
        System.out.println(proxy.get1());
        System.out.println("---------------");
        System.out.println(proxy.get2());
    
    }

运行输出：

---------------
    我是insert1
    public void com.javacode2018.lesson001.demo17.Service4.insert1()，耗时(纳秒):9777500
    ---------------
    我是insert2
    public void com.javacode2018.lesson001.demo17.Service4.insert2()，耗时(纳秒):50600
    ---------------
    路人甲Java
    ---------------
    路人甲Java

输出效果和案例4一模一样的，上面重点在于CallbackHelper，里面做了一些封装，有兴趣的可以去看一下源码，比较简单。

## 案例6：实现通用的统计任意类方法耗时代理类 ##

直接上代码，比较简单，如下：

package com.javacode2018.lesson001.demo17;
    
    
    import org.springframework.cglib.proxy.Enhancer;
    import org.springframework.cglib.proxy.MethodInterceptor;
    import org.springframework.cglib.proxy.MethodProxy;
    
    import java.lang.reflect.Method;
    
    public class CostTimeProxy implements MethodInterceptor {
        
        //目标对象
        private Object target;
    
        public CostTimeProxy(Object target) {
        
            this.target = target;
        }
    
        @Override
        public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        
            long starTime = System.nanoTime();
            //调用被代理对象（即target）的方法，获取结果
            Object result = method.invoke(target, objects); //@1
            long endTime = System.nanoTime();
            System.out.println(method + "，耗时(纳秒)：" + (endTime - starTime));
            return result;
        }
    
        /**
         * 创建任意类的代理对象
         *
         * @param target
         * @param <T>
         * @return
         */
        public static <T> T createProxy(T target) {
        
            CostTimeProxy costTimeProxy = new CostTimeProxy(target);
            Enhancer enhancer = new Enhancer();
            enhancer.setCallback(costTimeProxy);
            enhancer.setSuperclass(target.getClass());
            return (T) enhancer.create();
        }
    }

我们可以直接使用上面的静态方法createProxy来为目标对象target创建一个代理对象，被代理的对象自动实现方法调用耗时统计。

@1：调用被代理对象的方法获取真正的结果。

使用非常简单，来个测试用例，如下：

@Test
    public void test7() {
        
        //创建Service1代理
        Service1 service1 = CostTimeProxy.createProxy(new Service1());
        service1.m1();
    
        //创建Service3代理
        Service3 service3 = CostTimeProxy.createProxy(new Service3());
        System.out.println(service3.m1());
    }

运行输出：

我是m1方法
    public void com.javacode2018.lesson001.demo17.Service1.m1()，耗时(纳秒)：53200
    我是m1方法
    public java.lang.String com.javacode2018.lesson001.demo17.Service3.m1()，耗时(纳秒)：49200
    hello:m1

# CGLIB和Java动态代理的区别 #

1.  Java动态代理只能够对接口进行代理，不能对普通的类进行代理（因为所有生成的代理类的父类为Proxy，Java类继承机制不允许多重继承）；CGLIB能够代理普通类；
2.  Java动态代理使用Java原生的反射API进行操作，在生成类上比较高效；CGLIB使用ASM框架直接对字节码进行操作，在类的执行过程中比较高效
3.  代理的就介绍到这里，spring中很多地方会用到这块，所以大家一定要熟悉，欢迎大家留言交流

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzQ3MTU3Njc2_size_16_color_FFFFFF_t_70_pic_center]: /images/20221122/1c407ecbdc37414f9b3714896c77a190.png