本文内容

  1. 为什么需要用代理
  2. jdk动态代理玩法详解
  3. cglib代理常见的各种玩法详解

代理spring中用到的挺多的，比如上篇文章中的lookup-method和replaced-method，以及后面我们要学的aop、spring中的事务、spring中解析@configuration注解等等，这些都是依靠代理来实现的，所以我们先把代理拿出来讲讲，有利于我们理解其他内容。

为什么要用代理

我们先来看一个案例。

有一个接口IService，如下：

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

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

  1. package com.javacode2018.lesson001.demo15;
  3. public class ServiceA implements IService {
  4.     @Override
  5.     public void m1() {
  6.         System.out.println("我是ServiceA中的m1方法!");
  7.     }
  9.     @Override
  10.     public void m2() {
  11.         System.out.println("我是ServiceA中的m2方法!");
  12.     }
  14.     @Override
  15.     public void m3() {
  16.         System.out.println("我是ServiceA中的m3方法!");
  17.     }
  18. }
  19. package com.javacode2018.lesson001.demo15;
  21. public class ServiceB implements IService {
  22.     @Override
  23.     public void m1() {
  24.         System.out.println("我是ServiceB中的m1方法!");
  25.     }
  27.     @Override
  28.     public void m2() {
  29.         System.out.println("我是ServiceB中的m2方法!");
  30.     }
  32.     @Override
  33.     public void m3() {
  34.         System.out.println("我是ServiceB中的m3方法!");
  35.     }
  36. }

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

  1. package com.javacode2018.lesson001.demo15;
  3. import org.junit.Test;
  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();
  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;
  3. // IService的代理类
  4. public class ServiceProxy implements IService {
  5.     //目标对象，被代理的对象
  6.     private IService target;
  8.     public ServiceProxy(IService target) {
  9.         this.target = target;
  10.     }
  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.     }
  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.     }
  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();
  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, 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方法

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

  1. 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;
  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<IService> proxyClass = (Class<IService>) 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;
  3. import java.lang.reflect.InvocationHandler;
  4. import java.lang.reflect.Method;
  5. import java.lang.reflect.Proxy;
  7. public class CostTimeInvocationHandler implements InvocationHandler {
  9.     private Object target;
  11.     public CostTimeInvocationHandler(Object target) {
  12.         this.target = target;
  13.     }
  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.     }
  24.     /**
  25.      * 用来创建targetInterface接口的代理对象
  26.      *
  27.      * @param target          需要被代理的对象
  28.      * @param targetInterface 被代理的接口
  29.      * @param <T>
  30.      * @return
  31.      */
  32.     public static <T> T createProxy(Object target, Class<T> 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();
  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;
  3. public interface IUserService {
  4.     /**
  5.      * 插入用户信息
  6.      * @param name
  7.      */
  8.     void insert(String name);
  9. }

IUserService接口实现类：

  1. package com.javacode2018.lesson001.demo16;
  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

CGlib(Code Generation Library)

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，地址为：

  1. https://github.com/cglib/cglib

cglib组成结构

image.png

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;
  3. public class Service1 {
  4.     public void m1() {
  5.         System.out.println("我是m1方法");
  6.     }
  8.     public void m2() {
  9.         System.out.println("我是m2方法");
  10.     }
  11. }

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

  1. package com.javacode2018.lesson001.demo17;
  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;
  8. import java.lang.reflect.Method;
  10. public class CglibTest {
  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;
  4. public class Service2 {
  5.     public void m1() {
  6.         System.out.println("我是m1方法");
  7.         this.m2(); //@1
  8.     }
  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;
  3. import org.springframework.context.annotation.Bean;
  4. import org.springframework.context.annotation.Configuration;
  6. @Configuration
  7. public class Config {
  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.     }
  24.     public static class C1{}
  26.     public static class C2{
  27.         private C1 c1;
  29.         public C2(C1 c1) {
  30.             this.c1 = c1;
  31.         }
  32.     }
  33.     public static class C3{
  34.         private C1 c1;
  36.         public C3(C1 c1) {
  37.             this.c1 = c1;
  38.         }
  39.     }
  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;
  3. public class Service3 {
  4.     public String m1() {
  5.         System.out.println("我是m1方法");
  6.         return "hello:m1";
  7.     }
  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;
  3. public class Service4 {
  4.     public void insert1() {
  5.         System.out.println("我是insert1");
  6.     }
  8.     public void insert2() {
  9.         System.out.println("我是insert2");
  10.     }
  12.     public String get1() {
  13.         System.out.println("我是get1");
  14.         return "get1";
  15.     }
  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());
  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());
  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;
  4. import org.springframework.cglib.proxy.Enhancer;
  5. import org.springframework.cglib.proxy.MethodInterceptor;
  6. import org.springframework.cglib.proxy.MethodProxy;
  8. import java.lang.reflect.Method;
  10. public class CostTimeProxy implements MethodInterceptor {
  11.     //目标对象
  12.     private Object target;
  14.     public CostTimeProxy(Object target) {
  15.         this.target = target;
  16.     }
  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.     }
  28.     /**
  29.      * 创建任意类的代理对象
  30.      *
  31.      * @param target
  32.      * @param <T>
  33.      * @return
  34.      */
  35.     public static <T> 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();
  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框架直接对字节码进行操作，在类的执行过程中比较高效
  3. 代理的就介绍到这里，spring中很多地方会用到这块，所以大家一定要熟悉，欢迎大家留言交流

案例源码

  1. 链接：https://pan.baidu.com/s/1p6rcfKOeWQIVkuhVybzZmQ 
  2. 提取码：zr99

Spring系列

  1. Spring系列第1篇：为何要学spring？
  2. Spring系列第2篇：控制反转（IoC）与依赖注入（DI）
  3. Spring系列第3篇：Spring容器基本使用及原理
  4. Spring系列第4篇：xml中bean定义详解(-)
  5. Spring系列第5篇：创建bean实例这些方式你们都知道？
  6. Spring系列第6篇：玩转bean scope，避免跳坑里！
  7. Spring系列第7篇：依赖注入之手动注入
  8. Spring系列第8篇：自动注入（autowire）详解，高手在于坚持
  9. Spring系列第9篇：depend-on到底是干什么的？
  10. Spring系列第10篇：primary可以解决什么问题？
  11. Spring系列第11篇：bean中的autowire-candidate又是干什么的？
  12. Spring系列第12篇：lazy-init：bean延迟初始化
  13. Spring系列第13篇：使用继承简化bean配置(abstract & parent)
  14. Spring系列第14篇：lookup-method和replaced-method比较陌生，怎么玩的？

更多好文章

  1. Java高并发系列（共34篇）
  2. MySql高手系列（共27篇）
  3. Maven高手系列（共10篇）
  4. Mybatis系列（共12篇）
  5. 聊聊db和缓存一致性常见的实现方式
  6. 接口幂等性这么重要，它是什么？怎么实现？
  7. 泛型，有点难度，会让很多人懵逼，那是因为你没有看这篇文章！

参考文档

面试被问到java代理，一脸懵逼！！！