SpringAOP专题之2、JDK动态代理和CGLIB代理

Spring中有个非常重要的知识点，AOP，即面相切面编程，spring中提供的一些非常牛逼的功能都是通过aop实现的，比如下面这些大家比较熟悉的功能
  1. spring事务管理：@Transactional
  2. spring异步处理：@EnableAsync
  3. spring缓存技术的使用：@EnableCaching
  4. spring中各种拦截器：@EnableAspectJAutoProxy

大家想玩转spring，成为一名spring高手，aop是必须要掌握的，aop这块东西比较多，我们将通过三四篇文章来详解介绍这块的内容，由浅入深，让大家全面掌握这块知识。

说的简单点，spring中的aop就是依靠代理实现的各种功能，通过代理来对bean进行增强。

spring中的aop功能主要是通过2种代理来实现的

  1. jdk动态代理
  2. cglib代理

继续向下之前，必须先看一下这篇文章：Spring系列第15篇：代理详解（Java动态代理&cglib代理）？

spring aop中用到了更多的一些特性，上面这边文章中没有介绍到，所以通过本文来做一个补充，这2篇文章看过之后，再去看spring aop的源码，理解起来会容易一些，这2篇算是最基础的知识，所以一定要消化理解，不然aop那块的原理你很难了解，会晕车，

jdk动态代理

特征

  1. 只能为接口创建代理对象
  2. 创建出来的代理都是java.lang.reflect.Proxy的子类

案例

案例源码位置：

  1. com.javacode2018.aop.demo1.JdkAopTest1

有2个接口

  1. interface IService1 {
  2.     void m1();
  3. }
  5. interface IService2 {
  6.     void m2();
  7. }

下面的类实现了上面2个接口

  1. public static class Service implements IService1, IService2 {
  2.     @Override
  3.     public void m1() {
  4.         System.out.println("我是m1");
  5.     }
  7.     @Override
  8.     public void m2() {
  9.         System.out.println("我是m2");
  10.     }
  11. }

下面通过jdk动态代理创建一个代理对象，实现上面定义的2个接口，将代理对象所有的请求转发给Service去处理，需要在代理中统计2个接口中所有方法的耗时。

比较简单，自定义一个InvocationHandler

  1. public static class CostTimeInvocationHandler implements InvocationHandler {
  3.     private Object target;
  5.     public CostTimeInvocationHandler(Object target) {
  6.         this.target = target;
  7.     }
  9.     @Override
  10.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  11.         long startime = System.nanoTime();
  12.         Object result = method.invoke(this.target, args); //将请求转发给target去处理
  13.         System.out.println(method + "，耗时(纳秒):" + (System.nanoTime() - startime));
  14.         return result;
  15.     }
  16. }

测试方法

  1. {
  2.     Service target = new Service();
  3.     CostTimeInvocationHandler costTimeInvocationHandler = new CostTimeInvocationHandler(target);
  4.     //创建代理对象
  5.     Object proxyObject = Proxy.newProxyInstance(
  6.             target.getClass().getClassLoader(),
  7.             new Class[]{IService1.class, IService2.class}, //创建的代理对象实现了2个接口
  8.             costTimeInvocationHandler);
  9.     //判断代理对象是否是Service类型的，肯定是false咯
  10.     System.out.println(String.format("proxyObject instanceof Service = %s", proxyObject instanceof Service));
  11.     //判断代理对象是否是IService1类型的，肯定是true
  12.     System.out.println(String.format("proxyObject instanceof IService1 = %s", proxyObject instanceof IService1));
  13.     //判断代理对象是否是IService2类型的，肯定是true
  14.     System.out.println(String.format("proxyObject instanceof IService2 = %s", proxyObject instanceof IService2));
  16.     //将代理转换为IService1类型
  17.     IService1 service1 = (IService1) proxyObject;
  18.     //调用IService2的m1方法
  19.     service1.m1();
  20.     //将代理转换为IService2类型
  21.     IService2 service2 = (IService2) proxyObject;
  22.     //调用IService2的m2方法
  23.     service2.m2();
  24.     //输出代理的类型
  25.     System.out.println("代理对象的类型:" + proxyObject.getClass());
  26. }

运行输出

  1. proxyObject instanceof Service = false
  2. proxyObject instanceof IService1 = true
  3. proxyObject instanceof IService2 = true
  4. 我是m1
  5. public abstract void com.javacode2018.aop.demo1.JdkAopTest1$IService1.m1()，耗时(纳秒):225600
  6. 我是m2
  7. public abstract void com.javacode2018.aop.demo1.JdkAopTest1$IService2.m2()，耗时(纳秒):36000
  8. 代理对象的类型:class com.javacode2018.aop.demo1.$Proxy0

m1方法和m2方法被CostTimeInvocationHandler#invoke给增强了，调用目标方法的过程中统计了耗时。

最后一行输出可以看出代理对象的类型，类名中包含了$Proxy的字样，所以以后注意，看到这种字样的，基本上都是通过jdk动态代理创建的代理对象。

下面来说cglib代理的一些特殊案例。

cglib代理

cglib的特点

  1. cglib弥补了jdk动态代理的不足，jdk动态代理只能为接口创建代理，而cglib非常强大，不管是接口还是类，都可以使用cglib来创建代理
  2. cglib创建代理的过程，相当于创建了一个新的类，可以通过cglib来配置这个新的类需要实现的接口，以及需要继承的父类
  3. cglib可以为类创建代理，但是这个类不能是final类型的，cglib为类创建代理的过程，实际上为通过继承来实现的，相当于给需要被代理的类创建了一个子类，然后会重写父类中的方法，来进行增强，继承的特性大家应该都知道，final修饰的类是不能被继承的，final修饰的方法不能被重写，static修饰的方法也不能被重写，private修饰的方法也不能被子类重写，而其他类型的方法都可以被子类重写，被重写的这些方法可以通过cglib进行拦截增强

cglib整个过程如下

  1. Cglib根据父类,Callback, Filter 及一些相关信息生成key
  2. 然后根据key 生成对应的子类的二进制表现形式
  3. 使用ClassLoader装载对应的二进制,生成Class对象,并缓存
  4. 最后实例化Class对象,并缓存

案例1：为多个接口创建代理

代码比较简单，定义了2个接口，然后通过cglib来创建一个代理类，代理类会实现这2个接口，通过setCallback来对2个接口的方法进行增强。

  1. public class CglibTest1 {
  2.     interface IService1 {
  3.         void m1();
  4.     }
  6.     interface IService2 {
  7.         void m2();
  8.     }
  10.     public static void main(String[] args) {
  11.         Enhancer enhancer = new Enhancer();
  12.         //设置代理对象需要实现的接口
  13.         enhancer.setInterfaces(new Class[]{IService1.class, IService2.class});
  14.         //通过Callback来对被代理方法进行增强
  15.         enhancer.setCallback(new MethodInterceptor() {
  16.             @Override
  17.             public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
  18.                 System.out.println("方法：" + method.getName());
  19.                 return null;
  20.             }
  21.         });
  22.         Object proxy = enhancer.create();
  23.         if (proxy instanceof IService1) {
  24.             ((IService1) proxy).m1();
  25.         }
  26.         if (proxy instanceof IService2) {
  27.             ((IService2) proxy).m2();
  28.         }
  29.         //看一下代理对象的类型
  30.         System.out.println(proxy.getClass());
  31.         //看一下代理类实现的接口
  32.         System.out.println("创建代理类实现的接口如下：");
  33.         for (Class<?> cs : proxy.getClass().getInterfaces()) {
  34.             System.out.println(cs);
  35.         }
  36.     }
  37. }

运行输出

  1. 方法：m1
  2. 方法：m2
  3. class com.javacode2018.aop.demo2.CglibTest1$IService1$$EnhancerByCGLIB$$1d32a82
  4. 创建代理类实现的接口如下：
  5. interface com.javacode2018.aop.demo2.CglibTest1$IService1
  6. interface com.javacode2018.aop.demo2.CglibTest1$IService2
  7. interface org.springframework.cglib.proxy.Factory

上面创建的代理类相当于下面代码

  1. public class CglibTest1$IService1$$EnhancerByCGLIB$$1d32a82 implements IService1, IService2 {
  2.     @Override
  3.     public void m1() {
  4.         System.out.println("方法：m1");
  5.     }
  7.     @Override
  8.     public void m2() {
  9.         System.out.println("方法：m2");
  11.     }
  12. }

案例2：为类和接口同时创建代理

下面定义了2个接口：IService1和IService2，2个接口有个实现类：Service，然后通过cglib创建了个代理类，实现了这2个接口，并且将Service类作为代理类的父类。

  1. public class CglibTest2 {
  2.     interface IService1 {
  3.         void m1();
  4.     }
  6.     interface IService2 {
  7.         void m2();
  8.     }
  10.     public static class Service implements IService1, IService2 {
  11.         @Override
  12.         public void m1() {
  13.             System.out.println("m1");
  14.         }
  16.         @Override
  17.         public void m2() {
  18.             System.out.println("m2");
  19.         }
  20.     }
  22.     public static void main(String[] args) {
  23.         Enhancer enhancer = new Enhancer();
  24.         //设置代理类的父类
  25.         enhancer.setSuperclass(Service.class);
  26.         //设置代理对象需要实现的接口
  27.         enhancer.setInterfaces(new Class[]{IService1.class, IService2.class});
  28.         //通过Callback来对被代理方法进行增强
  29.         enhancer.setCallback(new MethodInterceptor() {
  30.             @Override
  31.             public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
  32.                 long startime = System.nanoTime();
  33.                 Object result = methodProxy.invokeSuper(o, objects); //调用父类中的方法
  34.                 System.out.println(method + "，耗时(纳秒):" + (System.nanoTime() - startime));
  35.                 return result;
  36.             }
  37.         });
  38.         //创建代理对象
  39.         Object proxy = enhancer.create();
  40.         //判断代理对象是否是Service类型的
  41.         System.out.println("proxy instanceof Service" + (proxy instanceof Service));
  42.         if (proxy instanceof Service) {
  43.             Service service = (Service) proxy;
  44.             service.m1();
  45.             service.m2();
  46.         }
  47.         //看一下代理对象的类型
  48.         System.out.println(proxy.getClass());
  49.         //输出代理对象的父类
  50.         System.out.println("代理类的父类：" + proxy.getClass().getSuperclass());
  51.         //看一下代理类实现的接口
  52.         System.out.println("创建代理类实现的接口如下：");
  53.         for (Class<?> cs : proxy.getClass().getInterfaces()) {
  54.             System.out.println(cs);
  55.         }
  56.     }
  57. }

运行输出

  1. proxy instanceof Servicetrue
  2. m1
  3. public void com.javacode2018.aop.demo2.CglibTest2$Service.m1()，耗时(纳秒):14219700
  4. m2
  5. public void com.javacode2018.aop.demo2.CglibTest2$Service.m2()，耗时(纳秒):62800
  6. class com.javacode2018.aop.demo2.CglibTest2$Service$$EnhancerByCGLIB$$80494536
  7. 代理类的父类：class com.javacode2018.aop.demo2.CglibTest2$Service
  8. 创建代理类实现的接口如下：
  9. interface com.javacode2018.aop.demo2.CglibTest2$IService1
  10. interface com.javacode2018.aop.demo2.CglibTest2$IService2
  11. interface org.springframework.cglib.proxy.Factory

输出中可以代理对象的类型是：

  1. class com.javacode2018.aop.demo2.CglibTest2$Service$$EnhancerByCGLIB$$80494536

带有EnhancerByCGLIB字样的，在调试spring的过程中，发现有这样字样的，基本上都是cglib创建的代理对象。

上面创建的代理类相当于下面代码

  1. public class CglibTest2$Service$$EnhancerByCGLIB$$80494536 extends Service implements IService1, IService2 {
  2.     @Override
  3.     public void m1() {
  4.         long starttime = System.nanoTime();
  5.         super.m1();
  6.         System.out.println("方法m1，耗时(纳秒):" + (System.nanoTime() - starttime));
  7.     }
  9.     @Override
  10.     public void m2() {
  11.         long starttime = System.nanoTime();
  12.         super.m1();
  13.         System.out.println("方法m1，耗时(纳秒):" + (System.nanoTime() - starttime));
  14.     }
  15. }

案例3：LazyLoader的使用

LazyLoader是cglib用于实现懒加载的callback。当被增强bean的方法初次被调用时，会触发回调，之后每次再进行方法调用都是对LazyLoader第一次返回的bean调用，hibernate延迟加载有用到过这个。

看案例吧，通过案例理解容易一些。

  1. public class LazyLoaderTest1 {
  3.     public static class UserModel {
  4.         private String name;
  6.         public UserModel() {
  7.         }
  9.         public UserModel(String name) {
  10.             this.name = name;
  11.         }
  13.         public void say() {
  14.             System.out.println("你好：" + name);
  15.         }
  16.     }
  18.     public static void main(String[] args) {
  19.         Enhancer enhancer = new Enhancer();
  20.         enhancer.setSuperclass(UserModel.class);
  21.         //创建一个LazyLoader对象
  22.         LazyLoader lazyLoader = new LazyLoader() {
  23.             @Override
  24.             public Object loadObject() throws Exception {
  25.                 System.out.println("调用LazyLoader.loadObject()方法");
  26.                 return new UserModel("路人甲java");
  27.             }
  28.         };
  29.         enhancer.setCallback(lazyLoader);
  30.         Object proxy = enhancer.create();
  31.         UserModel userModel = (UserModel) proxy;
  32.         System.out.println("第1次调用say方法");
  33.         userModel.say();
  34.         System.out.println("第1次调用say方法");
  35.         userModel.say();
  36.     }
  37. }

运行输出

  1. 第1次调用say方法
  2. 调用LazyLoader.loadObject()方法
  3. 你好：路人甲java
  4. 第1次调用say方法
  5. 你好：路人甲java

当第1次调用say方法的时候，会被cglib拦截，进入lazyLoader的loadObject内部，将这个方法的返回值作为say方法的调用者，loadObject中返回了一个路人甲Java的UserModel，cglib内部会将loadObject方法的返回值和say方法关联起来，然后缓存起来，而第2次调用say方法的时候，通过方法名去缓存中找，会直接拿到第1次返回的UserModel，所以第2次不会进入到loadObject方法中了。

将下代码拆分开来

  1. System.out.println("第1次调用say方法");
  2. userModel.say();
  3. System.out.println("第1次调用say方法");
  4. userModel.say();

相当于下面的代码

  1. System.out.println("第1次调用say方法");
  2. System.out.println("调用LazyLoader.loadObject()方法");
  3. userModel = new UserModel("路人甲java");
  4. userModel.say();
  5. System.out.println("第1次调用say方法");
  6. userModel.say();

下面通过LazyLoader实现延迟加载的效果。

案例4：LazyLoader实现延迟加载

博客的内容一般比较多，需要用到内容的时候，我们再去加载，下面来模拟博客内容延迟加载的效果。

  1. public class LazyLoaderTest2 {
  2.     //博客信息
  3.     public static class BlogModel {
  4.         private String title;
  5.         //博客内容信息比较多，需要的时候再去获取
  6.         private BlogContentModel blogContentModel;
  8.         public BlogModel() {
  9.             this.title = "spring aop详解!";
  10.             this.blogContentModel = this.getBlogContentModel();
  11.         }
  13.         private BlogContentModel getBlogContentModel() {
  14.             Enhancer enhancer = new Enhancer();
  15.             enhancer.setSuperclass(BlogContentModel.class);
  16.             enhancer.setCallback(new LazyLoader() {
  17.                 @Override
  18.                 public Object loadObject() throws Exception {
  19.                     //此处模拟从数据库中获取博客内容
  20.                     System.out.println("开始从数据库中获取博客内容.....");
  21.                     BlogContentModel result = new BlogContentModel();
  22.                     result.setContent("欢迎大家和我一起学些spring，我们一起成为spring高手！");
  23.                     return result;
  24.                 }
  25.             });
  26.             return (BlogContentModel) enhancer.create();
  27.         }
  28.     }
  30.     //表示博客内容信息
  31.     public static class BlogContentModel {
  32.         //博客内容
  33.         private String content;
  35.         public String getContent() {
  36.             return content;
  37.         }
  39.         public void setContent(String content) {
  40.             this.content = content;
  41.         }
  42.     }
  44.     public static void main(String[] args) {
  45.         //创建博客对象
  46.         BlogModel blogModel = new BlogModel();
  47.         System.out.println(blogModel.title);
  48.         System.out.println("博客内容");
  49.         System.out.println(blogModel.blogContentModel.getContent()); //@1
  50.     }
  51. }

@1：调用blogContentModel.getContent()方法的时候，才会通过LazyLoader#loadObject方法从db中获取到博客内容信息

运行输出

  1. spring aop详解!
  2. 博客内容
  3. 开始从数据库中获取博客内容.....
  4. 欢迎大家和我一起学些spring，我们一起成为spring高手！

案例5：Dispatcher

Dispatcher和LazyLoader作用很相似，区别是用Dispatcher的话每次对增强bean进行方法调用都会触发回调。

看案例代码

  1. public class DispatcherTest1 {
  2.     public static class UserModel {
  3.         private String name;
  5.         public UserModel() {
  6.         }
  8.         public UserModel(String name) {
  9.             this.name = name;
  10.         }
  12.         public void say() {
  13.             System.out.println("你好：" + name);
  14.         }
  15.     }
  17.     public static void main(String[] args) {
  18.         Enhancer enhancer = new Enhancer();
  19.         enhancer.setSuperclass(LazyLoaderTest1.UserModel.class);
  20.         //创建一个Dispatcher对象
  21.         Dispatcher dispatcher = new Dispatcher() {
  22.             @Override
  23.             public Object loadObject() throws Exception {
  24.                 System.out.println("调用Dispatcher.loadObject()方法");
  25.                 return new LazyLoaderTest1.UserModel("路人甲java," + UUID.randomUUID().toString());
  26.             }
  27.         };
  28.         enhancer.setCallback(dispatcher);
  29.         Object proxy = enhancer.create();
  30.         LazyLoaderTest1.UserModel userModel = (LazyLoaderTest1.UserModel) proxy;
  31.         System.out.println("第1次调用say方法");
  32.         userModel.say();
  33.         System.out.println("第1次调用say方法");
  34.         userModel.say();
  35.     }
  36. }

运行输出

  1. 第1次调用say方法
  2. 调用Dispatcher.loadObject()方法
  3. 你好：路人甲java,514f911e-06ac-4e3b-aee4-595f82c16a5f
  4. 第1次调用say方法
  5. 调用Dispatcher.loadObject()方法
  6. 你好：路人甲java,bc062990-bc16-4226-97e3-b1b321a03468

案例6：通过Dispathcer对类扩展一些接口

下面有个UserService类，我们需要对这个类创建一个代理。

代码中还定义了一个接口：IMethodInfo，用来统计被代理类的一些方法信息，有个实现类：DefaultMethodInfo。

通过cglib创建一个代理类，父类为UserService，并且实现IMethodInfo接口，将接口IMethodInfo所有方法的转发给DefaultMethodInfo处理，代理类中的其他方法，转发给其父类UserService处理。

这个代码相当于对UserService这个类进行了增强，使其具有了IMethodInfo接口中的功能。

  1. public class DispatcherTest2 {
  3.     public static class UserService {
  4.         public void add() {
  5.             System.out.println("新增用户");
  6.         }
  8.         public void update() {
  9.             System.out.println("更新用户信息");
  10.         }
  11.     }
  13.     //用来获取方法信息的接口
  14.     public interface IMethodInfo {
  15.         //获取方法数量
  16.         int methodCount();
  18.         //获取被代理的对象中方法名称列表
  19.         List<String> methodNames();
  20.     }
  22.     //IMethodInfo的默认实现
  23.     public static class DefaultMethodInfo implements IMethodInfo {
  25.         private Class<?> targetClass;
  27.         public DefaultMethodInfo(Class<?> targetClass) {
  28.             this.targetClass = targetClass;
  29.         }
  31.         @Override
  32.         public int methodCount() {
  33.             return targetClass.getDeclaredMethods().length;
  34.         }
  36.         @Override
  37.         public List<String> methodNames() {
  38.             return Arrays.stream(targetClass.getDeclaredMethods()).
  39.                     map(Method::getName).
  40.                     collect(Collectors.toList());
  41.         }
  42.     }
  44.     public static void main(String[] args) {
  45.         Class<?> targetClass = UserService.class;
  46.         Enhancer enhancer = new Enhancer();
  47.         //设置代理的父类
  48.         enhancer.setSuperclass(targetClass);
  49.         //设置代理需要实现的接口列表
  50.         enhancer.setInterfaces(new Class[]{IMethodInfo.class});
  51.         //创建一个方法统计器
  52.         IMethodInfo methodInfo = new DefaultMethodInfo(targetClass);
  53.         //创建会调用器列表，此处定义了2个，第1个用于处理UserService中所有的方法，第2个用来处理IMethodInfo接口中的方法
  54.         Callback[] callbacks = {
  55.                 new MethodInterceptor() {
  56.                     @Override
  57.                     public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
  58.                         return methodProxy.invokeSuper(o, objects);
  59.                     }
  60.                 },
  61.                 new Dispatcher() {
  62.                     @Override
  63.                     public Object loadObject() throws Exception {
  64.                         /**
  65.                          * 用来处理代理对象中IMethodInfo接口中的所有方法
  66.                          * 所以此处返回的为IMethodInfo类型的对象，
  67.                          * 将由这个对象来处理代理对象中IMethodInfo接口中的所有方法
  68.                          */
  69.                         return methodInfo;
  70.                     }
  71.                 }
  72.         };
  73.         enhancer.setCallbacks(callbacks);
  74.         enhancer.setCallbackFilter(new CallbackFilter() {
  75.             @Override
  76.             public int accept(Method method) {
  77.                 //当方法在IMethodInfo中定义的时候，返回callbacks中的第二个元素
  78.                 return method.getDeclaringClass() == IMethodInfo.class ? 1 : 0;
  79.             }
  80.         });
  82.         Object proxy = enhancer.create();
  83.         //代理的父类是UserService
  84.         UserService userService = (UserService) proxy;
  85.         userService.add();
  86.         //代理实现了IMethodInfo接口
  87.         IMethodInfo mf = (IMethodInfo) proxy;
  88.         System.out.println(mf.methodCount());
  89.         System.out.println(mf.methodNames());
  90.     }
  91. }

运行输出

  1. 新增用户
  2. 2
  3. [add, update]

案例7：cglib中的NamingPolicy接口

接口NamingPolicy表示生成代理类的名字的策略，通过Enhancer.setNamingPolicy方法设置命名策略。

默认的实现类：DefaultNamingPolicy， 具体cglib动态生成类的命名控制。

DefaultNamingPolicy中有个getTag方法。

DefaultNamingPolicy生成的代理类的类名命名规则：

  1. 被代理class name + "$$" + 使用cglib处理的class name + "ByCGLIB" + "$$" + key的hashcode

如：

  1. com.javacode2018.aop.demo2.DispatcherTest2$UserService$$EnhancerByCGLIB$$e7ec0be5@17d10166

自定义NamingPolicy，通常会继承DefaultNamingPolicy来实现，spring中默认就提供了一个，如下

  1. public class SpringNamingPolicy extends DefaultNamingPolicy {
  3.     public static final SpringNamingPolicy INSTANCE = new SpringNamingPolicy();
  5.     @Override
  6.     protected String getTag() {
  7.         return "BySpringCGLIB";
  8.     }
  10. }

案例代码

  1. public class NamingPolicyTest {
  2.     public static void main(String[] args) {
  3.         Enhancer enhancer = new Enhancer();
  4.         enhancer.setSuperclass(NamingPolicyTest.class);
  5.         enhancer.setCallback(NoOp.INSTANCE);
  6.         //通过Enhancer.setNamingPolicy来设置代理类的命名策略
  7.         enhancer.setNamingPolicy(new DefaultNamingPolicy() {
  8.             @Override
  9.             protected String getTag() {
  10.                 return "-test-";
  11.             }
  12.         });
  13.         Object proxy = enhancer.create();
  14.         System.out.println(proxy.getClass());
  15.     }
  16. }

输出

  1. class com.javacode2018.aop.demo2.NamingPolicyTest$$Enhancer-test-$$5946713

Objenesis：实例化对象的一种方式

先来看一段代码，有一个有参构造函数：

  1. public static class User {
  2.     private String name;
  4.     public User(String name) {
  5.         this.name = name;
  6.     }
  8.     @Override
  9.     public String toString() {
  10.         return "User{" +
  11.                 "name='" + name + '\'' +
  12.                 '}';
  13.     }
  14. }

大家来思考一个问题：如果不使用这个有参构造函数的情况下，如何创建这个对象？

通过反射？大家可以试试，如果不使用有参构造函数，是无法创建对象的。

cglib中提供了一个接口：Objenesis，通过这个接口可以解决上面这种问题，它专门用来创建对象，即使你没有空的构造函数，都木有问题，它不使用构造方法创建Java对象，所以即使你有空的构造方法，也是不会执行的。

用法比较简单：

  1. @Test
  2. public void test1() {
  3.     Objenesis objenesis = new ObjenesisStd();
  4.     User user = objenesis.newInstance(User.class);
  5.     System.out.println(user);
  6. }

输出

  1. User{name='null'}

大家可以在User类中加一个默认构造函数，来验证一下上面的代码会不会调用默认构造函数？

  1. public User() {
  2.     System.out.println("默认构造函数");
  3. }

再次运行会发现，并不会调用默认构造函数。

如果需要多次创建User对象，可以写成下面方式重复利用

  1. @Test
  2. public void test2() {
  3.     Objenesis objenesis = new ObjenesisStd();
  4.     ObjectInstantiator<User> userObjectInstantiator = objenesis.getInstantiatorOf(User.class);
  5.     User user1 = userObjectInstantiator.newInstance();
  6.     System.out.println(user1);
  7.     User user2 = userObjectInstantiator.newInstance();
  8.     System.out.println(user2);
  9.     System.out.println(user1 == user2);
  10. }

运行输出

  1. User{name='null'}
  2. User{name='null'}
  3. false

代码位置

  1. com.javacode2018.aop.demo2.CreateObjectTest

总结

  1. 代理这2篇文章是spring aop的基础，基础牢靠了，才能走的更远，大家一定要将这2篇文章中的内容吃透，全面掌握jdk动态代理和cglib代理的使用
  2. 这些知识点spring aop中全部都用到了，大家消化一下，下一篇讲解spring aop具体是如何玩的

案例源码

  1. https://gitee.com/javacode2018/spring-series

本博客所有案例代码以后都会放到这个上面，大家watch一下，可以持续关注动态。

继续收门徒，月薪 4W 以下的可以来找我，4W 以上的靠你们自己的天赋了

最新资料

  1. 尚硅谷 Java 学科全套教程（总 207.77GB）
  2. 2021 最新版 Java 微服务学习线路图 + 视频
  3. 阿里技术大佬整理的《Spring 学习笔记.pdf》
  4. 阿里大佬的《MySQL 学习笔记高清.pdf》
  5. 2021 版 java 高并发常见面试题汇总.pdf
  6. Idea 快捷键大全.pdf

来源：http://www.itsoku.com/course/11/112
posted @ 2022-04-26 11:10  程序员小明1024  阅读(87)  评论(0)  编辑  收藏  举报