【Mybatis源码分析】10-CglibProxyFactory

smart哥

于 2024-05-11 14:47:16 发布

阅读量421

点赞数 5

分类专栏： mybatis专题文章标签： mybatis

本文链接：https://blog.csdn.net/smart_an/article/details/138715585

版权

mybatis专题专栏收录该内容

44 篇文章 1 订阅

订阅专栏

作者简介：大家好，我是smart哥，前中兴通讯、美团架构师，现某互联网公司CTO

联系qq：184480602，加我进群，大家一起学习，一起进步，一起对抗互联网寒冬

学习必须往深处挖，挖的越深，基础越扎实！

阶段1、深入多线程

 阶段2、深入多线程设计模式

 阶段3、深入juc源码解析

阶段4、深入jdk其余源码解析

阶段5、深入jvm源码解析

码哥源码部分

码哥讲源码-原理源码篇【2024年最新大厂关于线程池使用的场景题】

码哥讲源码【炸雷啦！炸雷啦！黄光头他终于跑路啦！】

码哥讲源码-【jvm课程前置知识及c/c++调试环境搭建】

码哥讲源码-原理源码篇【揭秘join方法的唤醒本质上决定于jvm的底层析构函数】

码哥源码-原理源码篇【Doug Lea为什么要将成员变量赋值给局部变量后再操作？】

码哥讲源码【你水不是你的错,但是你胡说八道就是你不对了！】

码哥讲源码【谁再说Spring不支持多线程事务，你给我抽他！】

终结B站没人能讲清楚红黑树的历史，不服等你来踢馆！

打脸系列【020-3小时讲解MESI协议和volatile之间的关系，那些将x86下的验证结果当作最终结果的水货们请闭嘴】

Mybatis懒加载是通过动态代理完成的，通常来说Mybaits的映射实体都是POJO，所以Mybatis默认使用Cglib来做动态代理框架的。使用CglibProxyFactory的createProxy方法创建代理对象。其中又直接调用了EnhancedResultObjectProxyImpl静态createProxy方法。

    public Object createProxy(Object target, ResultLoaderMap lazyLoader, Configuration configuration, ObjectFactory objectFactory, List<Class<?>> constructorArgTypes, List<Object> constructorArgs) {
      return EnhancedResultObjectProxyImpl.createProxy(target, lazyLoader, configuration, objectFactory, constructorArgTypes, constructorArgs);
    }

    private static class EnhancedResultObjectProxyImpl implements MethodInterceptor {
    
      private final Class<?> type;
      private final ResultLoaderMap lazyLoader;
      private final boolean aggressive;
      private final Set<String> lazyLoadTriggerMethods;
      private final ObjectFactory objectFactory;
      private final List<Class<?>> constructorArgTypes;
      private final List<Object> constructorArgs;
    
      private EnhancedResultObjectProxyImpl(Class<?> type, ResultLoaderMap lazyLoader, Configuration configuration, ObjectFactory objectFactory, List<Class<?>> constructorArgTypes, List<Object> constructorArgs) {
        this.type = type;
        this.lazyLoader = lazyLoader;
        this.aggressive = configuration.isAggressiveLazyLoading();
        this.lazyLoadTriggerMethods = configuration.getLazyLoadTriggerMethods();
        this.objectFactory = objectFactory;
        this.constructorArgTypes = constructorArgTypes;
        this.constructorArgs = constructorArgs;
      }
    
      public static Object createProxy(Object target, ResultLoaderMap lazyLoader, Configuration configuration, ObjectFactory objectFactory, List<Class<?>> constructorArgTypes, List<Object> constructorArgs) {
        final Class<?> type = target.getClass();
        EnhancedResultObjectProxyImpl callback = new EnhancedResultObjectProxyImpl(type, lazyLoader, configuration, objectFactory, constructorArgTypes, constructorArgs);
        Object enhanced = crateProxy(type, callback, constructorArgTypes, constructorArgs);
        PropertyCopier.copyBeanProperties(type, target, enhanced);
        return enhanced;
      }
    
      @Override
      public Object intercept(Object enhanced, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        final String methodName = method.getName();
        try {
          synchronized (lazyLoader) {
            if (WRITE_REPLACE_METHOD.equals(methodName)) {
              Object original;
              if (constructorArgTypes.isEmpty()) {
                original = objectFactory.create(type);
              } else {
                original = objectFactory.create(type, constructorArgTypes, constructorArgs);
              }
              PropertyCopier.copyBeanProperties(type, enhanced, original);
              if (lazyLoader.size() > 0) {
                return new CglibSerialStateHolder(original, lazyLoader.getProperties(), objectFactory, constructorArgTypes, constructorArgs);
              } else {
                return original;
              }
            } else {
              if (lazyLoader.size() > 0 && !FINALIZE_METHOD.equals(methodName)) {
                if (aggressive || lazyLoadTriggerMethods.contains(methodName)) {
                  lazyLoader.loadAll();
                } else if (PropertyNamer.isSetter(methodName)) {
                  final String property = PropertyNamer.methodToProperty(methodName);
                  lazyLoader.remove(property);
                } else if (PropertyNamer.isGetter(methodName)) {
                  final String property = PropertyNamer.methodToProperty(methodName);
                  if (lazyLoader.hasLoader(property)) {
                    lazyLoader.load(property);
                  }
                }
              }
            }
          }
          return methodProxy.invokeSuper(enhanced, args);
        } catch (Throwable t) {
          throw ExceptionUtil.unwrapThrowable(t);
        }
      }
    }

EnhancedResultObjectProxyImpl实现了MethodInterceptor接口，此接口是Cglib拦截目标对象方法的入口，对目标对象方法的调用都会通过此接口的intercept的方法。

此类的createProxy方法首先new了MethodInterceptor实例，然后调用CglibProxyFactory另一个crateProxy重载方法。此方法中创建Cglib的Enhancer对象设置回调接口实例以及父类。

    static Object crateProxy(Class<?> type, Callback callback, List<Class<?>> constructorArgTypes, List<Object> constructorArgs) {
      Enhancer enhancer = new Enhancer();
      enhancer.setCallback(callback);
      enhancer.setSuperclass(type);
      try {
        type.getDeclaredMethod(WRITE_REPLACE_METHOD);
        // ObjectOutputStream will call writeReplace of objects returned by writeReplace
        if (log.isDebugEnabled()) {
          log.debug(WRITE_REPLACE_METHOD + " method was found on bean " + type + ", make sure it returns this");
        }
      } catch (NoSuchMethodException e) {
        enhancer.setInterfaces(new Class[]{WriteReplaceInterface.class});
      } catch (SecurityException e) {
        // nothing to do here
      }
      Object enhanced;
      if (constructorArgTypes.isEmpty()) {
        enhanced = enhancer.create();
      } else {
        Class<?>[] typesArray = constructorArgTypes.toArray(new Class[constructorArgTypes.size()]);
        Object[] valuesArray = constructorArgs.toArray(new Object[constructorArgs.size()]);
        enhanced = enhancer.create(typesArray, valuesArray);
      }
      return enhanced;
    }

我们着重分析一下重要的intercept方法，首先判断如果调用了懒加载对象的writeReplace方法，则返回CglibSerialStateHolder对象，这个对象实现了writeExternal和readExternal用于支持对象的序列化，这不是我们分析的重点。

如果调用的是"equals", "clone", "hashCode", "toString"方法之一并且懒加载模式是aggressive=true，则调用 lazyLoader.loadAll()将所有的懒加载属性全部取出

如果调用了的是某属性的setter方法，则将该属性从lazyLoader中移除。

如果调用的是属性的getter方法且存在于lazyLoader，则调用lazyLoader.load方法，对单个属性完成加载。

最后调用目标对象的真实方法。