MyBatis源码解读之延迟加载

1. 目的

本文主要解读MyBatis 延迟加载实现原理

2. 延迟加载如何使用

Setting 参数配置

设置参数	描述	有效值	默认值
lazyLoadingEnabled	延迟加载的全局开关。当开启时，所有关联对象都会延迟加载。 特定关联关系中可通过设置fetchType属性来覆盖该项的开关状态。	true、false	false
aggressiveLazyLoading	当开启时，任何方法的调用都会加载该对象的所有属性。否则，每个属性会按需加载（参考lazyLoadTriggerMethods).	true、false	false (true in ≤3.4.1)
lazyLoadTriggerMethods	指定哪个对象的方法触发一次延迟加载。	用逗号分隔的方法列表。	equals,clone,hashCode,toString

配置

<code class="language-xml">&lt;configuration&gt;
    &lt;settings&gt;
        &lt;!-- 开启延迟加载 --&gt;
        &lt;setting name=&quot;lazyLoadingEnabled&quot; value=&quot;true&quot; /&gt;
        &lt;setting name=&quot;aggressiveLazyLoading&quot; value=&quot;false&quot; /&gt;
        &lt;setting name=&quot;lazyLoadTriggerMethods&quot; value=&quot;equals,clone,hashCode,toString&quot; /&gt;
      &lt;/settings&gt;
&lt;/configuration&gt;

Mapper 配置

<code class="language-xml">&lt;mapper namespace=&quot;org.apache.ibatis.submitted.lazy_properties.Mapper&quot;&gt;

  &lt;resultMap type=&quot;org.apache.ibatis.submitted.lazy_properties.User&quot;
    id=&quot;user&quot;&gt;
    &lt;id property=&quot;id&quot; column=&quot;id&quot; /&gt;
    &lt;result property=&quot;name&quot; column=&quot;name&quot; /&gt;
  &lt;/resultMap&gt;
  &lt;!-- 结果对象 --&gt;
  &lt;resultMap type=&quot;org.apache.ibatis.submitted.lazy_properties.User&quot; id=&quot;userWithLazyProperties&quot; extends=&quot;user&quot;&gt;
    &lt;!-- 延迟加载对象lazy1 --&gt;
    &lt;association property=&quot;lazy1&quot; column=&quot;id&quot; select=&quot;getLazy1&quot; fetchType=&quot;lazy&quot; /&gt;
    &lt;!-- 延迟加载对象lazy2 --&gt;
    &lt;association property=&quot;lazy2&quot; column=&quot;id&quot; select=&quot;getLazy2&quot; fetchType=&quot;lazy&quot; /&gt;
    &lt;!-- 延迟加载集合lazy3 --&gt;
    &lt;collection property=&quot;lazy3&quot; column=&quot;id&quot; select=&quot;getLazy3&quot; fetchType=&quot;lazy&quot; /&gt;
  &lt;/resultMap&gt;
  &lt;!-- 执行的查询 --&gt;
  &lt;select id=&quot;getUser&quot; resultMap=&quot;userWithLazyProperties&quot;&gt;
    select * from users where id = #{id}
  &lt;/select&gt;
&lt;/mapper&gt;

User 实体对象

<code class="language-Java">public class User implements Cloneable {
  private Integer id;
  private String name;
  private User lazy1;
  private User lazy2;
  private List&lt;User&gt; lazy3;
  public int setterCounter;

  省略...
 }

执行解析：

1. 调用getUser查询数据，从查询结果集解析数据到User对象，当数据解析到lazy1，lazy2，lazy3判断需要执行关联查询
2. lazyLoadingEnabled=true，将创建lazy1，lazy2，lazy3对应的Proxy延迟执行对象lazyLoader，并保存
3. 当逻辑触发lazyLoadTriggerMethods 对应的方法（equals,clone,hashCode,toString）则执行延迟加载
4. 如果aggressiveLazyLoading=true，只要触发到对象任何的方法，就会立即加载所有属性的加载

3. 延迟加载原理实现

延迟加载主要是通过动态代理的形式实现，通过代理拦截到指定方法，执行数据加载。

MyBatis延迟加载主要使用：Javassist，Cglib实现，类图展示：

4. 延迟加载源码解析

Setting 配置加载：

<code class="language-Java">public class Configuration {
/** aggressiveLazyLoading：
   * 当开启时，任何方法的调用都会加载该对象的所有属性。否则，每个属性会按需加载（参考lazyLoadTriggerMethods).
   * 默认为true
   * */
  protected boolean aggressiveLazyLoading;
  /**
   * 延迟加载触发方法
   */
  protected Set&lt;String&gt; lazyLoadTriggerMethods = new HashSet&lt;String&gt;(Arrays.asList(new String[] { &quot;equals&quot;, &quot;clone&quot;, &quot;hashCode&quot;, &quot;toString&quot; }));
  /** 是否开启延迟加载 */
  protected boolean lazyLoadingEnabled = false;

  /**
   * 默认使用Javassist代理工厂
   * @param proxyFactory
   */
  public void setProxyFactory(ProxyFactory proxyFactory) {
    if (proxyFactory == null) {
      proxyFactory = new JavassistProxyFactory();
    }
    this.proxyFactory = proxyFactory;
  }

  //省略...
}

延迟加载代理对象创建

DefaultResultSetHandler

<code class="language-Java">//#mark 创建结果对象
  private Object createResultObject(ResultSetWrapper rsw, ResultMap resultMap, ResultLoaderMap lazyLoader, String columnPrefix) throws SQLException {
    this.useConstructorMappings = false; // reset previous mapping result
    final List&lt;Class&lt;?&gt;&gt; constructorArgTypes = new ArrayList&lt;Class&lt;?&gt;&gt;();
    final List&lt;Object&gt; constructorArgs = new ArrayList&lt;Object&gt;();
    //#mark 创建返回的结果映射的真实对象
    Object resultObject = createResultObject(rsw, resultMap, constructorArgTypes, constructorArgs, columnPrefix);
    if (resultObject != null &amp;&amp; !hasTypeHandlerForResultObject(rsw, resultMap.getType())) {
      final List&lt;ResultMapping&gt; propertyMappings = resultMap.getPropertyResultMappings();
      for (ResultMapping propertyMapping : propertyMappings) {
        // issue gcode #109 &amp;&amp; issue #149 判断属性有没配置嵌套查询，如果有就创建代理对象
        if (propertyMapping.getNestedQueryId() != null &amp;&amp; propertyMapping.isLazy()) {
          //#mark 创建延迟加载代理对象
          resultObject = configuration.getProxyFactory().createProxy(resultObject, lazyLoader, configuration, objectFactory, constructorArgTypes, constructorArgs);
          break;
        }
      }
    }
    this.useConstructorMappings = resultObject != null &amp;&amp; !constructorArgTypes.isEmpty(); // set current mapping result
    return resultObject;
  }

代理功能实现

由于Javasisst和Cglib的代理实现基本相同，这里主要介绍Javasisst

ProxyFactory接口定义

<code class="language-Java">public interface ProxyFactory {

  void setProperties(Properties properties);

  /**
   * 创建代理
   * @param target 目标结果对象
   * @param lazyLoader 延迟加载对象
   * @param configuration 配置
   * @param objectFactory 对象工厂
   * @param constructorArgTypes 构造参数类型
   * @param constructorArgs 构造参数值
   * @return
   */
  Object createProxy(Object target, ResultLoaderMap lazyLoader, Configuration configuration, ObjectFactory objectFactory, List&lt;Class&lt;?&gt;&gt; constructorArgTypes, List&lt;Object&gt; constructorArgs);
}

JavasisstProxyFactory实现

<code class="language-Java">public class JavassistProxyFactory implements org.apache.ibatis.executor.loader.ProxyFactory {

    /**
   * 接口实现
   * @param target 目标结果对象
   * @param lazyLoader 延迟加载对象
   * @param configuration 配置
   * @param objectFactory 对象工厂
   * @param constructorArgTypes 构造参数类型
   * @param constructorArgs 构造参数值
   * @return
   */
  @Override
  public Object createProxy(Object target, ResultLoaderMap lazyLoader, Configuration configuration, ObjectFactory objectFactory, List&lt;Class&lt;?&gt;&gt; constructorArgTypes, List&lt;Object&gt; constructorArgs) {
    return EnhancedResultObjectProxyImpl.createProxy(target, lazyLoader, configuration, objectFactory, constructorArgTypes, constructorArgs);
  }

    //省略...

  /**
   * 代理对象实现，核心逻辑执行
   */
  private static class EnhancedResultObjectProxyImpl implements MethodHandler {

    /**
   * 创建代理对象
   * @param type
   * @param callback
   * @param constructorArgTypes
   * @param constructorArgs
   * @return
   */
  static Object crateProxy(Class&lt;?&gt; type, MethodHandler callback, List&lt;Class&lt;?&gt;&gt; constructorArgTypes, List&lt;Object&gt; constructorArgs) {

    ProxyFactory enhancer = new ProxyFactory();
    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 + &quot; method was found on bean &quot; + type + &quot;, make sure it returns this&quot;);
      }
    } catch (NoSuchMethodException e) {
      //没找到该方法，实现接口
      enhancer.setInterfaces(new Class[]{WriteReplaceInterface.class});
    } catch (SecurityException e) {
      // nothing to do here
    }

    Object enhanced;
    Class&lt;?&gt;[] typesArray = constructorArgTypes.toArray(new Class[constructorArgTypes.size()]);
    Object[] valuesArray = constructorArgs.toArray(new Object[constructorArgs.size()]);
    try {
      //创建新的代理对象
      enhanced = enhancer.create(typesArray, valuesArray);
    } catch (Exception e) {
      throw new ExecutorException(&quot;Error creating lazy proxy.  Cause: &quot; + e, e);
    }
    //设置代理执行器
    ((Proxy) enhanced).setHandler(callback);
    return enhanced;
  }

     /**
     * 代理对象执行
     * @param enhanced 原对象
     * @param method 原对象方法
     * @param methodProxy 代理方法
     * @param args 方法参数
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(Object enhanced, Method method, Method methodProxy, Object[] args) 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() &gt; 0) {
              return new JavassistSerialStateHolder(original, lazyLoader.getProperties(), objectFactory, constructorArgTypes, constructorArgs);
            } else {
              return original;
            }
          } else {
              //延迟加载数量大于0
            if (lazyLoader.size() &gt; 0 &amp;&amp; !FINALIZE_METHOD.equals(methodName)) {
                //aggressive 一次加载性所有需要要延迟加载属性或者包含触发延迟加载方法
              if (aggressive || lazyLoadTriggerMethods.contains(methodName)) {
                log.debug(&quot;==&gt; laze lod trigger method:&quot; + methodName + &quot;,proxy method:&quot; + methodProxy.getName() + &quot; class:&quot; + enhanced.getClass());
                //一次全部加载
                lazyLoader.loadAll();
              } else if (PropertyNamer.isSetter(methodName)) {
                //判断是否为set方法，set方法不需要延迟加载
                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);
                  log.debug(&quot;load one :&quot; + methodName);
                }
              }
            }
          }
        }
        return methodProxy.invoke(enhanced, args);
      } catch (Throwable t) {
        throw ExceptionUtil.unwrapThrowable(t);
      }
    }
  }

5. 注意事项

1. IDEA调试问题
   当配置aggressiveLazyLoading=true，在使用IDEA进行调试的时候，如果断点打到代理执行逻辑当中，你会发现延迟加载的代码永远都不能进入，总是会被提前执行。
   主要产生的原因在aggressiveLazyLoading，因为在调试的时候，IDEA的Debuger窗体中已经触发了延迟加载对象的方法。

如图：调试还未进入lazyLoader.loadAll(); 实际日志已经显示延迟加载已经完成，代码与日志通过颜色区分。

6. 参考资料

本博客MyBatis源码地址： - https://gitee.com/rainwen/mybatis
Java动态代理机制详解（JDK 和CGLIB，Javassist，ASM） - http://blog.csdn.net/luanlouis/article/details/24589193
从类加载到动态编译 - http://zhaoyw.cn/2017/07/classloader-dynamic
MyBatis 记录二: lazy loading - http://yoncise.com/2016/11/05/MyBatis-%E8%AE%B0%E5%BD%95%E4%BA%8C-lazy-loading/
MyBatis官方文档 - http://www.mybatis.org/mybatis-3/zh/index.html
MyBatis-Spring官方文档 - http://www.mybatis.org/spring/zh/index.html
MyBatis-Spring源码 - https://github.com/rainwen/spring

利用Redis锁解决高并发问题

---

关于MyBatis源码解读之延迟加载就介绍到这里。如有疑问，欢迎留言，谢谢。

原文链接：https://my.oschina.net/wenjinglian/blog/1857581