【Mybatis源码分析】10-CglibProxyFactory

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方法，对单个属性完成加载。

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