• JDK动态代理和CGLIB动态代理

    为什么要用代理

    我们先来看一个案例。

    有一个接口IService，如下：

    1. package com.javacode2018.lesson001.demo15;
    2.  
    3. public interface IService {
    4.     void m1();
    5.     void m2();
    6.     void m3();
    7. }

    接口有2个实现类ServiceA和ServiceB，如下：

    1. package com.javacode2018.lesson001.demo15;
    2.  
    3. public class ServiceA implements IService {
    4.     @Override
    5.     public void m1() {
    6.         System.out.println("我是ServiceA中的m1方法!");
    7.     }
    8.  
    9.     @Override
    10.     public void m2() {
    11.         System.out.println("我是ServiceA中的m2方法!");
    12.     }
    13.  
    14.     @Override
    15.     public void m3() {
    16.         System.out.println("我是ServiceA中的m3方法!");
    17.     }
    18. }
    1. package com.javacode2018.lesson001.demo15;
    2.  
    3. public class ServiceB implements IService {
    4.     @Override
    5.     public void m1() {
    6.         System.out.println("我是ServiceB中的m1方法!");
    7.     }
    8.  
    9.     @Override
    10.     public void m2() {
    11.         System.out.println("我是ServiceB中的m2方法!");
    12.     }
    13.  
    14.     @Override
    15.     public void m3() {
    16.         System.out.println("我是ServiceB中的m3方法!");
    17.     }
    18. }

    来个测试用例来调用上面类的方法，如下：

    1. package com.javacode2018.lesson001.demo15;
    2.  
    3. import org.junit.Test;
    4.  
    5. public class ProxyTest {
    6.     @Test
    7.     public void m1() {
    8.         IService serviceA = new ServiceA();
    9.         IService serviceB = new ServiceB();
    10.         serviceA.m1();
    11.         serviceA.m2();
    12.         serviceA.m3();
    13.  
    14.         serviceB.m1();
    15.         serviceB.m2();
    16.         serviceB.m3();
    17.     }
    18. }

    上面的代码很简单，就不解释了，我们运行一下m1()方法，输出：

    1. 我是ServiceA中的m1方法!
    2. 我是ServiceA中的m2方法!
    3. 我是ServiceA中的m3方法!
    4. 我是ServiceA中的m1方法!
    5. 我是ServiceA中的m2方法!
    6. 我是ServiceA中的m3方法!

    上面是我们原本的程序，突然领导有个需求：调用IService接口中的任何方法的时候，需要记录方法的耗时。

    此时你会怎么做呢？

    IService接口有2个实现类ServiceA和ServiceB，我们可以在这两个类的所有方法中加上统计耗时的代码，如果IService接口有几十个实现，是不是要修改很多代码，所有被修改的方法需重新测试？是不是非常痛苦，不过上面这种修改代码的方式倒是可以解决问题，只是增加了很多工作量（编码 & 测试）。

    突然有一天，领导又说，要将这些耗时统计发送到监控系统用来做监控报警使用。

    此时是不是又要去一个修改上面的代码？又要去测试？此时的系统是难以维护。

    还有假如上面这些类都是第三方以jar包的方式提供给我们的，此时这些类都是class文件，此时我们无法去修改源码。

    比较好的方式：可以为IService接口创建一个代理类，通过这个代理类来间接访问IService接口的实现类，在这个代理类中去做耗时及发送至监控的代码，代码如下：

    1. package com.javacode2018.lesson001.demo15;
    2.  
    3. // IService的代理类
    4. public class ServiceProxy implements IService {
    5.     //目标对象，被代理的对象
    6.     private IService target;
    7.  
    8.     public ServiceProxy(IService target) {
    9.         this.target = target;
    10.     }
    11.  
    12.     @Override
    13.     public void m1() {
    14.         long starTime = System.nanoTime();
    15.         this.target.m1();
    16.         long endTime = System.nanoTime();
    17.         System.out.println(this.target.getClass() + ".m1()方法耗时(纳秒):" + (endTime - starTime));
    18.     }
    19.  
    20.     @Override
    21.     public void m2() {
    22.         long starTime = System.nanoTime();
    23.         this.target.m1();
    24.         long endTime = System.nanoTime();
    25.         System.out.println(this.target.getClass() + ".m1()方法耗时(纳秒):" + (endTime - starTime));
    26.     }
    27.  
    28.     @Override
    29.     public void m3() {
    30.         long starTime = System.nanoTime();
    31.         this.target.m1();
    32.         long endTime = System.nanoTime();
    33.         System.out.println(this.target.getClass() + ".m1()方法耗时(纳秒):" + (endTime - starTime));
    34.     }
    35. }

    ServiceProxy是IService接口的代理类，target为被代理的对象，即实际需要访问的对象，也实现了IService接口，上面的3个方法中加了统计耗时的代码，当我们需要访问IService的其他实现类的时候，可以通过ServiceProxy来间接的进行访问，用法如下：

    1. @Test
    2. public void serviceProxy() {
    3.     IService serviceA = new ServiceProxy(new ServiceA());//@1
    4.     IService serviceB = new ServiceProxy(new ServiceB()); //@2
    5.     serviceA.m1();
    6.     serviceA.m2();
    7.     serviceA.m3();
    8.  
    9.     serviceB.m1();
    10.     serviceB.m2();
    11.     serviceB.m3();
    12. }

    上面代码重点在于@1和@2，创建的是代理对象ServiceProxy，ServiceProxy构造方法中传入了被代理访问的对象，现在我们访问ServiceA或者ServiceB，都需要经过ServiceProxy，运行输出：

    1. 我是ServiceA中的m1方法!
    2. class com.javacode2018.lesson001.demo15.ServiceA.m1()方法耗时(纳秒):90100
    3. 我是ServiceA中的m1方法!
    4. class com.javacode2018.lesson001.demo15.ServiceA.m1()方法耗时(纳秒):31600
    5. 我是ServiceA中的m1方法!
    6. class com.javacode2018.lesson001.demo15.ServiceA.m1()方法耗时(纳秒):25800
    7. 我是ServiceB中的m1方法!
    8. class com.javacode2018.lesson001.demo15.ServiceB.m1()方法耗时(纳秒):142100
    9. 我是ServiceB中的m1方法!
    10. class com.javacode2018.lesson001.demo15.ServiceB.m1()方法耗时(纳秒):35000
    11. 我是ServiceB中的m1方法!
    12. class com.javacode2018.lesson001.demo15.ServiceB.m1()方法耗时(纳秒):32900

    上面实现中我们没有去修改ServiceA和ServiceB中的方法，只是给IService接口创建了一个代理类，通过代理类去访问目标对象，需要添加的一些共有的功能都放在代理中，当领导有其他需求的时候，我们只需修改ServiceProxy的代码，方便系统的扩展和测试。

    假如现在我们需要给系统中所有接口都加上统计耗时的功能，若按照上面的方式，我们需要给每个接口创建一个代理类，此时代码量和测试的工作量也是巨大的，那么我们能不能写一个通用的代理类，来满足上面的功能呢？

    通用代理的2种实现：

    1. jdk动态代理

    2. cglib代理

    jdk动态代理详解

    jdk中为实现代理提供了支持，主要用到2个类：

    1. java.lang.reflect.Proxy
    2. java.lang.reflect.InvocationHandler

    jdk自带的代理使用上面有个限制，只能为接口创建代理类，如果需要给具体的类创建代理类，需要用后面要说的cglib

    java.lang.reflect.Proxy

    这是jdk动态代理中主要的一个类，里面有一些静态方法会经常用到，我们来熟悉一下：

    getProxyClass方法

    为指定的接口创建代理类，返回代理类的Class对象

    1. public static Class getProxyClass(ClassLoader loader,
    2.                                          Class... interfaces)

    参数说明：

    loader：定义代理类的类加载器

    interfaces：指定需要实现的接口列表，创建的代理默认会按顺序实现interfaces指定的接口

    newProxyInstance方法

    创建代理类的实例对象

    1. public static Object newProxyInstance(ClassLoader loader,
    2.                                           Class[] interfaces,
    3.                                           InvocationHandler h)

    这个方法先为指定的接口创建代理类，然后会生成代理类的一个实例，最后一个参数比较特殊，是InvocationHandler类型的，这个是个借口如下：

    1. public Object invoke(Object proxy, Method method, Object[] args)
    2.         throws Throwable;

    上面方法会返回一个代理对象，当调用代理对象的任何方法的时候，会就被InvocationHandler接口的invoke方法处理，所以主要代码需要卸载invoke方法中，稍后会有案例细说。

    isProxy方法

    判断指定的类是否是一个代理类

    public static boolean isProxyClass(Class cl)

    getInvocationHandler方法

    获取代理对象的InvocationHandler对象

    1. public static InvocationHandler getInvocationHandler(Object proxy)
    2.         throws IllegalArgumentException

    上面几个方法大家熟悉一下，下面我们来看创建代理具体的2种方式。

    创建代理：方式一

    步骤

    1. 1.调用Proxy.getProxyClass方法获取代理类的Class对象
    2. 2.使用InvocationHandler接口创建代理类的处理器
    3. 3.通过代理类和InvocationHandler创建代理对象
    4. 4.上面已经创建好代理对象了，接着我们就可以使用代理对象了

    案例

    先来个接口IService

    1. package com.javacode2018.lesson001.demo16;
    2.  
    3. public interface IService {
    4.     void m1();
    5.     void m2();
    6.     void m3();
    7. }

    创建IService接口的代理对象

    1. @Test
    2. public void m1() throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
    3.     // 1. 获取接口对应的代理类
    4.     Class proxyClass = (Class) Proxy.getProxyClass(IService.class.getClassLoader(), IService.class);
    5.     // 2. 创建代理类的处理器
    6.     InvocationHandler invocationHandler = new InvocationHandler() {
    7.         @Override
    8.         public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    9.             System.out.println("我是InvocationHandler，被调用的方法是：" + method.getName());
    10.             return null;
    11.         }
    12.     };
    13.     // 3. 创建代理实例
    14.     IService proxyService = proxyClass.getConstructor(InvocationHandler.class).newInstance(invocationHandler);
    15.     // 4. 调用代理的方法
    16.     proxyService.m1();
    17.     proxyService.m2();
    18.     proxyService.m3();
    19. }

    运行输出

    1. 我是InvocationHandler，被调用的方法是：m1
    2. 我是InvocationHandler，被调用的方法是：m2
    3. 我是InvocationHandler，被调用的方法是：m3

    创建代理：方式二

    创建代理对象有更简单的方式。

    步骤

    1. 1.使用InvocationHandler接口创建代理类的处理器
    2. 2.使用Proxy类的静态方法newProxyInstance直接创建代理对象
    3. 3.使用代理对象

    案例

    1. @Test
    2. public void m2() throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
    3.     // 1. 创建代理类的处理器
    4.     InvocationHandler invocationHandler = new InvocationHandler() {
    5.         @Override
    6.         public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    7.             System.out.println("我是InvocationHandler，被调用的方法是：" + method.getName());
    8.             return null;
    9.         }
    10.     };
    11.     // 2. 创建代理实例
    12.     IService proxyService = (IService) Proxy.newProxyInstance(IService.class.getClassLoader(), new Class[]{IService.class}, invocationHandler);
    13.     // 3. 调用代理的方法
    14.     proxyService.m1();
    15.     proxyService.m2();
    16.     proxyService.m3();
    17. }

    运行输出：

    1. 我是InvocationHandler，被调用的方法是：m1
    2. 我是InvocationHandler，被调用的方法是：m2
    3. 我是InvocationHandler，被调用的方法是：m3

    案例：任意接口中的方法耗时统计

    下面我们通过jdk动态代理实现一个通用的代理，解决统计所有接口方法耗时的问题。

    主要的代码在代理处理器InvocationHandler实现上面，如下：

    1. package com.javacode2018.lesson001.demo16;
    2.  
    3. import java.lang.reflect.InvocationHandler;
    4. import java.lang.reflect.Method;
    5. import java.lang.reflect.Proxy;
    6.  
    7. public class CostTimeInvocationHandler implements InvocationHandler {
    8.  
    9.     private Object target;
    10.  
    11.     public CostTimeInvocationHandler(Object target) {
    12.         this.target = target;
    13.     }
    14.  
    15.     @Override
    16.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    17.         long starTime = System.nanoTime();
    18.         Object result = method.invoke(this.target, args);//@1
    19.         long endTime = System.nanoTime();
    20.         System.out.println(this.target.getClass() + ".m1()方法耗时(纳秒):" + (endTime - starTime));
    21.         return result;
    22.     }
    23.  
    24.     /**
    25.      * 用来创建targetInterface接口的代理对象
    26.      *
    27.      * @param target          需要被代理的对象
    28.      * @param targetInterface 被代理的接口
    29.      * @param 
    30.      * @return
    31.      */
    32.     public static  T createProxy(Object target, Class targetInterface) {
    33.         if (!targetInterface.isInterface()) {
    34.             throw new IllegalStateException("targetInterface必须是接口类型!");
    35.         } else if (!targetInterface.isAssignableFrom(target.getClass())) {
    36.             throw new IllegalStateException("target必须是targetInterface接口的实现类!");
    37.         }
    38.         return (T) Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), new CostTimeInvocationHandler(target));
    39.     }
    40. }

    上面主要是createProxy方法用来创建代理对象，2个参数：

    target：目标对象，需要实现targetInterface接口

    targetInterface：需要创建代理的接口

    invoke方法中通过method.invoke(this.target, args)调用目标方法，然后统计方法的耗时。

    测试用例

    1. @Test
    2. public void costTimeProxy() {
    3.     IService serviceA = CostTimeInvocationHandler.createProxy(new ServiceA(), IService.class);
    4.     IService serviceB = CostTimeInvocationHandler.createProxy(new ServiceB(), IService.class);
    5.     serviceA.m1();
    6.     serviceA.m2();
    7.     serviceA.m3();
    8.  
    9.     serviceB.m1();
    10.     serviceB.m2();
    11.     serviceB.m3();
    12. }

    运行输出

    1. 我是ServiceA中的m1方法!
    2. class com.javacode2018.lesson001.demo16.ServiceA.m1()方法耗时(纳秒):61300
    3. 我是ServiceA中的m2方法!
    4. class com.javacode2018.lesson001.demo16.ServiceA.m1()方法耗时(纳秒):22300
    5. 我是ServiceA中的m3方法!
    6. class com.javacode2018.lesson001.demo16.ServiceA.m1()方法耗时(纳秒):18700
    7. 我是ServiceB中的m1方法!
    8. class com.javacode2018.lesson001.demo16.ServiceB.m1()方法耗时(纳秒):54700
    9. 我是ServiceB中的m2方法!
    10. class com.javacode2018.lesson001.demo16.ServiceB.m1()方法耗时(纳秒):27200
    11. 我是ServiceB中的m3方法!
    12. class com.javacode2018.lesson001.demo16.ServiceB.m1()方法耗时(纳秒):19800

    我们再来的接口，也需要统计耗时的功能，此时我们无需去创建新的代理类即可实现同样的功能，如下：

    IUserService接口

    1. package com.javacode2018.lesson001.demo16;
    2.  
    3. public interface IUserService {
    4.     /**
    5.      * 插入用户信息
    6.      * @param name
    7.      */
    8.     void insert(String name);
    9. }

    IUserService接口实现类：

    1. package com.javacode2018.lesson001.demo16;
    2.  
    3. public class UserService implements IUserService {
    4.     @Override
    5.     public void insert(String name) {
    6.         System.out.println(String.format("用户[name:%s]插入成功!", name));
    7.     }
    8. }

    测试用例

    1. @Test
    2. public void userService() {
    3.     IUserService userService = CostTimeInvocationHandler.createProxy(new UserService(), IUserService.class);
    4.     userService.insert("路人甲Java");
    5. }

    运行输出：

    1. 用户[name:路人甲Java]插入成功!
    2. class com.javacode2018.lesson001.demo16.UserService.m1()方法耗时(纳秒):193000

    上面当我们创建一个新的接口的时候，不需要再去新建一个代理类了，只需要使用CostTimeInvocationHandler.createProxy创建一个新的代理对象就可以了，方便了很多。

    Proxy使用注意

    1. jdk中的Proxy只能为接口生成代理类，如果你想给某个类创建代理类，那么Proxy是无能为力的，此时需要我们用到下面要说的cglib了。

    2. Proxy类中提供的几个常用的静态方法大家需要掌握

    3. 通过Proxy创建代理对象，当调用代理对象任意方法时候，会被InvocationHandler接口中的invoke方法进行处理，这个接口内容是关键

    cglib代理详解

    什么是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组成结构

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

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

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

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

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

    1. package com.javacode2018.lesson001.demo17;
    2.  
    3. public class Service1 {
    4.     public void m1() {
    5.         System.out.println("我是m1方法");
    6.     }
    7.  
    8.     public void m2() {
    9.         System.out.println("我是m2方法");
    10.     }
    11. }

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

    1. package com.javacode2018.lesson001.demo17;
    2.  
    3. import org.junit.Test;
    4. import org.springframework.cglib.proxy.Enhancer;
    5. import org.springframework.cglib.proxy.MethodInterceptor;
    6. import org.springframework.cglib.proxy.MethodProxy;
    7.  
    8. import java.lang.reflect.Method;
    9.  
    10. public class CglibTest {
    11.  
    12.     @Test
    13.     public void test1() {
    14.         //使用Enhancer来给某个类创建代理类，步骤
    15.         //1.创建Enhancer对象
    16.         Enhancer enhancer = new Enhancer();
    17.         //2.通过setSuperclass来设置父类型，即需要给哪个类创建代理类
    18.         enhancer.setSuperclass(Service1.class);
    19.         /*3.设置回调，需实现org.springframework.cglib.proxy.Callback接口，
    20.         此处我们使用的是org.springframework.cglib.proxy.MethodInterceptor，也是一个接口，实现了Callback接口，
    21.         当调用代理对象的任何方法的时候，都会被MethodInterceptor接口的invoke方法处理*/
    22.         enhancer.setCallback(new MethodInterceptor() {
    23.             /**
    24.              * 代理对象方法拦截器
    25.              * @param o 代理对象
    26.              * @param method 被代理的类的方法，即Service1中的方法
    27.              * @param objects 调用方法传递的参数
    28.              * @param methodProxy 方法代理对象
    29.              * @return
    30.              * @throws Throwable
    31.              */
    32.             @Override
    33.             public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
    34.                 System.out.println("调用方法:" + method);
    35.                 //可以调用MethodProxy的invokeSuper调用被代理类的方法
    36.                 Object result = methodProxy.invokeSuper(o, objects);
    37.                 return result;
    38.             }
    39.         });
    40.         //4.获取代理对象,调用enhancer.create方法获取代理对象，这个方法返回的是Object类型的，所以需要强转一下
    41.         Service1 proxy = (Service1) enhancer.create();
    42.         //5.调用代理对象的方法
    43.         proxy.m1();
    44.         proxy.m2();
    45.     }
    46. }

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

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

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

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

    运行输出：

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

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

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

    在创建一个类，如下：

    1. package com.javacode2018.lesson001.demo17;
    2.  
    3.  
    4. public class Service2 {
    5.     public void m1() {
    6.         System.out.println("我是m1方法");
    7.         this.m2(); //@1
    8.     }
    9.  
    10.     public void m2() {
    11.         System.out.println("我是m2方法");
    12.     }
    13. }

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

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

    1. @Test
    2. public void test2() {
    3.     Enhancer enhancer = new Enhancer();
    4.     enhancer.setSuperclass(Service2.class);
    5.     enhancer.setCallback(new MethodInterceptor() {
    6.         @Override
    7.         public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
    8.             System.out.println("调用方法:" + method);
    9.             Object result = methodProxy.invokeSuper(o, objects);
    10.             return result;
    11.         }
    12.     });
    13.     Service2 proxy = (Service2) enhancer.create();
    14.     proxy.m1(); //@1
    15. }

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

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

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

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

    1. package com.javacode2018.lesson001.demo17;
    2.  
    3. import org.springframework.context.annotation.Bean;
    4. import org.springframework.context.annotation.Configuration;
    5.  
    6. @Configuration
    7. public class Config {
    8.  
    9.     @Bean
    10.     public C1 c1(){
    11.         return new C1();
    12.     }
    13.     @Bean
    14.     public C2 c2(){
    15.         C1 c1 = this.c1(); //@1
    16.         return new C2(c1);
    17.     }
    18.     @Bean
    19.     public C3 c3(){
    20.         C1 c1 = this.c1(); //@2
    21.         return new C3(c1);
    22.     }
    23.  
    24.     public static class C1{}
    25.  
    26.     public static class C2{
    27.         private C1 c1;
    28.  
    29.         public C2(C1 c1) {
    30.             this.c1 = c1;
    31.         }
    32.     }
    33.     public static class C3{
    34.         private C1 c1;
    35.  
    36.         public C3(C1 c1) {
    37.             this.c1 = c1;
    38.         }
    39.     }
    40.  
    41. }

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

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

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

    1. enhancer.setCallback(new FixedValue() {
    2.             @Override
    3.             public Object loadObject() throws Exception {
    4.                 return "路人甲";
    5.             }
    6.         });

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

    案例代码如下：

    创建一个类Service3，如下：

    1. package com.javacode2018.lesson001.demo17;
    2.  
    3. public class Service3 {
    4.     public String m1() {
    5.         System.out.println("我是m1方法");
    6.         return "hello:m1";
    7.     }
    8.  
    9.     public String m2() {
    10.         System.out.println("我是m2方法");
    11.         return "hello:m2";
    12.     }
    13. }

    对用的测试用例：

    1. @Test
    2. public void test3() {
    3.     Enhancer enhancer = new Enhancer();
    4.     enhancer.setSuperclass(Service3.class);
    5.     enhancer.setCallback(new FixedValue() {
    6.         @Override
    7.         public Object loadObject() throws Exception {
    8.             return "路人甲";
    9.         }
    10.     });
    11.     Service3 proxy = (Service3) enhancer.create();
    12.     System.out.println(proxy.m1());//@1
    13.     System.out.println(proxy.m2()); //@2
    14.     System.out.println(proxy.toString());//@3
    15. }

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

    运行输出：

    1. 路人甲
    2. 路人甲
    3. 路人甲

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

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

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

    1. @Test
    2. public void test6() {
    3.     Enhancer enhancer = new Enhancer();
    4.     enhancer.setSuperclass(Service3.class);
    5.     enhancer.setCallback(NoOp.INSTANCE);
    6.     Service3 proxy = (Service3) enhancer.create();
    7.     System.out.println(proxy.m1());
    8.     System.out.println(proxy.m2());
    9. }

    运行输出：

    1. 我是m1方法
    2. hello:m1
    3. 我是m2方法
    4. hello:m2

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

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

    有个类如下：

    1. package com.javacode2018.lesson001.demo17;
    2.  
    3. public class Service4 {
    4.     public void insert1() {
    5.         System.out.println("我是insert1");
    6.     }
    7.  
    8.     public void insert2() {
    9.         System.out.println("我是insert2");
    10.     }
    11.  
    12.     public String get1() {
    13.         System.out.println("我是get1");
    14.         return "get1";
    15.     }
    16.  
    17.     public String get2() {
    18.         System.out.println("我是get2");
    19.         return "get2";
    20.     }
    21. }

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

    1. 以insert开头的方法需要统计方法耗时

    2. 以get开头的的方法直接返回固定字符串`欢迎和【路人甲java】一起学spring！`

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

    1. @Test
    2. public void test4() {
    3.     Enhancer enhancer = new Enhancer();
    4.     enhancer.setSuperclass(Service4.class);
    5.     //创建2个Callback
    6.     Callback[] callbacks = {
    7.             //这个用来拦截所有insert开头的方法
    8.             new MethodInterceptor() {
    9.                 @Override
    10.                 public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
    11.                     long starTime = System.nanoTime();
    12.                     Object result = methodProxy.invokeSuper(o, objects);
    13.                     long endTime = System.nanoTime();
    14.                     System.out.println(method + "，耗时(纳秒):" + (endTime - starTime));
    15.                     return result;
    16.                 }
    17.             },
    18.             //下面这个用来拦截所有get开头的方法，返回固定值的
    19.             new FixedValue() {
    20.                 @Override
    21.                 public Object loadObject() throws Exception {
    22.                     return "路人甲Java";
    23.                 }
    24.             }
    25.     };
    26.     enhancer.setCallbackFilter(new CallbackFilter() {
    27.         @Override
    28.         public int accept(Method method) {
    29.             return 0;
    30.         }
    31.     });
    32.     //调用enhancer的setCallbacks传递Callback数组
    33.     enhancer.setCallbacks(callbacks);
    34.     /**
    35.      * 设置过滤器CallbackFilter
    36.      * CallbackFilter用来判断调用方法的时候使用callbacks数组中的哪个Callback来处理当前方法
    37.      * 返回的是callbacks数组的下标
    38.      */
    39.     enhancer.setCallbackFilter(new CallbackFilter() {
    40.         @Override
    41.         public int accept(Method method) {
    42.             //获取当前调用的方法的名称
    43.             String methodName = method.getName();
    44.             /**
    45.              * 方法名称以insert开头，
    46.              * 返回callbacks中的第1个Callback对象来处理当前方法，
    47.              * 否则使用第二个Callback处理被调用的方法
    48.              */
    49.             return methodName.startsWith("insert") ? 0 : 1;
    50.         }
    51.     });
    52.     Service4 proxy = (Service4) enhancer.create();
    53.     System.out.println("---------------");
    54.     proxy.insert1();
    55.     System.out.println("---------------");
    56.     proxy.insert2();
    57.     System.out.println("---------------");
    58.     System.out.println(proxy.get1());
    59.     System.out.println("---------------");
    60.     System.out.println(proxy.get2());
    61.  
    62. }

    运行输出：

    1. ---------------
    2. 我是insert1
    3. public void com.javacode2018.lesson001.demo17.Service4.insert1()，耗时(纳秒):15396100
    4. ---------------
    5. 我是insert2
    6. public void com.javacode2018.lesson001.demo17.Service4.insert2()，耗时(纳秒):66200
    7. ---------------
    8. 路人甲Java
    9. ---------------
    10. 路人甲Java

    代码说明：

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

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

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

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

    1. @Test
    2. public void test5() {
    3.     Enhancer enhancer = new Enhancer();
    4.     //创建2个Callback
    5.     Callback costTimeCallback = (MethodInterceptor) (Object o, Method method, Object[] objects, MethodProxy methodProxy) -> {
    6.         long starTime = System.nanoTime();
    7.         Object result = methodProxy.invokeSuper(o, objects);
    8.         long endTime = System.nanoTime();
    9.         System.out.println(method + "，耗时(纳秒):" + (endTime - starTime));
    10.         return result;
    11.     };
    12.     //下面这个用来拦截所有get开头的方法，返回固定值的
    13.     Callback fixdValueCallback = (FixedValue) () -> "路人甲Java";
    14.     CallbackHelper callbackHelper = new CallbackHelper(Service4.class, null) {
    15.         @Override
    16.         protected Object getCallback(Method method) {
    17.             return method.getName().startsWith("insert") ? costTimeCallback : fixdValueCallback;
    18.         }
    19.     };
    20.     enhancer.setSuperclass(Service4.class);
    21.     //调用enhancer的setCallbacks传递Callback数组
    22.     enhancer.setCallbacks(callbackHelper.getCallbacks());
    23.     /**
    24.      * 设置CallbackFilter,用来判断某个方法具体走哪个Callback
    25.      */
    26.     enhancer.setCallbackFilter(callbackHelper);
    27.     Service4 proxy = (Service4) enhancer.create();
    28.     System.out.println("---------------");
    29.     proxy.insert1();
    30.     System.out.println("---------------");
    31.     proxy.insert2();
    32.     System.out.println("---------------");
    33.     System.out.println(proxy.get1());
    34.     System.out.println("---------------");
    35.     System.out.println(proxy.get2());
    36.  
    37. }

    运行输出：

    1. ---------------
    2. 我是insert1
    3. public void com.javacode2018.lesson001.demo17.Service4.insert1()，耗时(纳秒):9777500
    4. ---------------
    5. 我是insert2
    6. public void com.javacode2018.lesson001.demo17.Service4.insert2()，耗时(纳秒):50600
    7. ---------------
    8. 路人甲Java
    9. ---------------
    10. 路人甲Java

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

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

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

    1. package com.javacode2018.lesson001.demo17;
    2.  
    3.  
    4. import org.springframework.cglib.proxy.Enhancer;
    5. import org.springframework.cglib.proxy.MethodInterceptor;
    6. import org.springframework.cglib.proxy.MethodProxy;
    7.  
    8. import java.lang.reflect.Method;
    9.  
    10. public class CostTimeProxy implements MethodInterceptor {
    11.     //目标对象
    12.     private Object target;
    13.  
    14.     public CostTimeProxy(Object target) {
    15.         this.target = target;
    16.     }
    17.  
    18.     @Override
    19.     public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
    20.         long starTime = System.nanoTime();
    21.         //调用被代理对象（即target）的方法，获取结果
    22.         Object result = method.invoke(target, objects); //@1
    23.         long endTime = System.nanoTime();
    24.         System.out.println(method + "，耗时(纳秒)：" + (endTime - starTime));
    25.         return result;
    26.     }
    27.  
    28.     /**
    29.      * 创建任意类的代理对象
    30.      *
    31.      * @param target
    32.      * @param 
    33.      * @return
    34.      */
    35.     public static  T createProxy(T target) {
    36.         CostTimeProxy costTimeProxy = new CostTimeProxy(target);
    37.         Enhancer enhancer = new Enhancer();
    38.         enhancer.setCallback(costTimeProxy);
    39.         enhancer.setSuperclass(target.getClass());
    40.         return (T) enhancer.create();
    41.     }
    42. }

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

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

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

    1. @Test
    2. public void test7() {
    3.     //创建Service1代理
    4.     Service1 service1 = CostTimeProxy.createProxy(new Service1());
    5.     service1.m1();
    6.  
    7.     //创建Service3代理
    8.     Service3 service3 = CostTimeProxy.createProxy(new Service3());
    9.     System.out.println(service3.m1());
    10. }

    运行输出：

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

    CGLIB和Java动态代理的区别

    1. Java动态代理只能够对接口进行代理，不能对普通的类进行代理（因为所有生成的代理类的父类为Proxy，Java类继承机制不允许多重继承）；CGLIB能够代理普通类；

    2. Java动态代理使用Java原生的反射API进行操作，在生成类上比较高效；CGLIB使用ASM框架直接对字节码进行操作，在类的执行过程中比较高效

  • 相关阅读:
    原子物理中的组合常数
    【Kubernetes】当K8s出现问题时，我们可以从哪些方面排查出
    centos7安装mysql8.x的注意事项，与5.x版本有许多不同
    OpenCV之GOTURN目标追踪
    计算机视觉与深度学习 | 视觉里程计（Visual Odometry，VO）研究现状
    山东大学人工智能导论实验二 前向传播和反向传播
    车载软件架构 —— AUTOSAR Vector SIP包（二）
    Python学习备忘录
    服务器防止SSH暴力破解
    精选历年大厂高频Java面试真题集锦（含答案），助力面试一路开挂
  • 原文地址：https://blog.csdn.net/weixin_69413377/article/details/126128295