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

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