文档章节

MyBatis源码解读之延迟加载

无忌
 无忌
发布于 07/16 20:46
字数 1724
阅读 2157
收藏 0

1. 目的

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

2. 延迟加载如何使用

Setting 参数配置

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

配置

<configuration>
    <settings>
        <!-- 开启延迟加载 -->
        <setting name="lazyLoadingEnabled" value="true" />
        <setting name="aggressiveLazyLoading" value="false" />
        <setting name="lazyLoadTriggerMethods" value="equals,clone,hashCode,toString" />
      </settings>
</configuration>

Mapper 配置

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

User 实体对象

public class User implements Cloneable {
  private Integer id;
  private String name;
  private User lazy1;
  private User lazy2;
  private List<User> 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 配置加载:

public class Configuration {
/** aggressiveLazyLoading:
   * 当开启时,任何方法的调用都会加载该对象的所有属性。否则,每个属性会按需加载(参考lazyLoadTriggerMethods).
   * 默认为true
   * */
  protected boolean aggressiveLazyLoading;
  /**
   * 延迟加载触发方法
   */
  protected Set<String> lazyLoadTriggerMethods = new HashSet<String>(Arrays.asList(new String[] { "equals", "clone", "hashCode", "toString" }));
  /** 是否开启延迟加载 */
  protected boolean lazyLoadingEnabled = false;
  
  /**
   * 默认使用Javassist代理工厂
   * @param proxyFactory
   */
  public void setProxyFactory(ProxyFactory proxyFactory) {
    if (proxyFactory == null) {
      proxyFactory = new JavassistProxyFactory();
    }
    this.proxyFactory = proxyFactory;
  }
  
  //省略...
}

延迟加载代理对象创建

DefaultResultSetHandler

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

代理功能实现

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

ProxyFactory接口定义

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<Class<?>> constructorArgTypes, List<Object> constructorArgs);
}

JavasisstProxyFactory实现

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<Class<?>> constructorArgTypes, List<Object> 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<?> type, MethodHandler callback, List<Class<?>> constructorArgTypes, List<Object> 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 + " 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;
    Class<?>[] 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("Error creating lazy proxy.  Cause: " + 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() > 0) {
              return new JavassistSerialStateHolder(original, lazyLoader.getProperties(), objectFactory, constructorArgTypes, constructorArgs);
            } else {
              return original;
            }
          } else {
              //延迟加载数量大于0
            if (lazyLoader.size() > 0 && !FINALIZE_METHOD.equals(methodName)) {
                //aggressive 一次加载性所有需要要延迟加载属性或者包含触发延迟加载方法
              if (aggressive || lazyLoadTriggerMethods.contains(methodName)) {
                log.debug("==> laze lod trigger method:" + methodName + ",proxy method:" + methodProxy.getName() + " class:" + 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("load one :" + 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


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

© 著作权归作者所有

共有 人打赏支持
无忌
粉丝 31
博文 32
码字总数 35038
作品 0
深圳
私信 提问
加载中

评论(8)

lifes77
lifes77
无忌
无忌

引用来自“loubobooo”的评论

使用延迟加载的好处或者说优势是什么?

引用来自“无忌”的评论

延迟加载可以数据库的查询性能,不重要的数据可以使用延迟加载,只有需要的时候才去加载。
MyBatis可以设置在触发指定方法调用才去执行查询。

引用来自“蓝水晶飞机”的评论

不对不对吧,延迟加载只是为了解决关联查询(OO编程)带来便利性的同时的另一个问题(按需加载),对吧?
MyBatis的联合查询与延迟加载没有关系,设置fetchType="lazy"只是让关联的查询延迟加载(默认是立即加载)。
蓝水晶飞机
蓝水晶飞机

引用来自“loubobooo”的评论

使用延迟加载的好处或者说优势是什么?

引用来自“无忌”的评论

延迟加载可以数据库的查询性能,不重要的数据可以使用延迟加载,只有需要的时候才去加载。
MyBatis可以设置在触发指定方法调用才去执行查询。
不对不对吧,延迟加载只是为了解决关联查询(OO编程)带来便利性的同时的另一个问题(按需加载),对吧?
无忌
无忌

引用来自“蓝水晶飞机”的评论

如果使用延迟加载,那就不能开启MyBatis的二级缓存,否则就会脏读。
其实开启缓存,就有可能会产生脏读的现象,主要还是要缓存处理好。
无忌
无忌

引用来自“loubobooo”的评论

使用延迟加载的好处或者说优势是什么?
延迟加载可以数据库的查询性能,不重要的数据可以使用延迟加载,只有需要的时候才去加载。
MyBatis可以设置在触发指定方法调用才去执行查询。
loubobooo
loubobooo
使用延迟加载的好处或者说优势是什么?
蓝水晶飞机
蓝水晶飞机
如果使用延迟加载,那就不能开启MyBatis的二级缓存,否则就会脏读。
Mybatis Laz-Load功能实现代码赏析(原创)

对于Mybatis 拥有的Lazy Load(有中文翻译成延迟加载)功能,应该很同学都有听说过,今天主要与大家一起来解读一下Mybatis在Lazy Load功能的实现的代码。Lazy Load实现的功能很好理解,就是在数...

三毛々
2013/04/23
0
0
mybatis-spring.jar对SQLErrorCodes的扩展点

1、mybatis-spring.jar作用 mybatis-spring.jar可以让mybatis代码无缝地整合到Spring中。使用这个类库中的类,Spring将会加载必要的MyBatis工厂类和session 类,同时也提供了一个简单的方式来...

still5656
11/29
0
0
redis+mybatis+spring

redis的安装http://liuyieyer.iteye.com/blog/2078093 redis的主从高可用 http://liuyieyer.iteye.com/blog/2078095 Mybatis 的使用不多说。 Mybatis为了方便我们扩展缓存定义了一个Cache接口...

凯文加内特
2016/01/21
480
0
Mybatis3.4.x技术内幕(二十一):参数设置、结果封装、级联查询、延迟加载原理分析

Mybatis在执行查询时,其参数设置、结果封装、级联查询、延迟加载,是最基本的功能和用法,我们有必要了解其工作原理,重点阐述级联查询和延迟加载。 1、MetaObject MetaObject用于反射创建对...

祖大俊
2016/09/16
788
0
mybatis学习笔记(13)-延迟加载

mybatis学习笔记(13)-延迟加载 标签: mybatis [TOC] resultMap可以实现高级映射(使用、实现一对一及一对多映射),、具备延迟加载功能。 延迟加载:先从单表查询、需要时再从关联表去关联查...

brianway
2016/03/02
938
3

没有更多内容

加载失败,请刷新页面

加载更多

node.js学习笔记之koa框架和简单爬虫练习

Koa -- 基于 Node.js 平台的下一代 web 开发框架 koa是由 Express 原班人马打造的,致力于成为一个更小、更富有表现力、更健壮的 Web 框架。 使用 koa 编写 web 应用,可以免除重复繁琐的回调...

前端小攻略
4分钟前
0
0
JavaScript中的继承及实现代码

JS虽然不像是JAVA那种强类型的语言,但也有着与JAVA类型的继承属性,那么JS中的继承是如何实现的呢? 一、构造函数继承 在构造函数中,同样属于两个新创建的函数,也是不相等的 function Fn...

peakedness丶
26分钟前
1
0
记一次面试最常见的10个Redis"刁难"问题

导读:在程序员面试过程中Redis相关的知识是常被问到的话题。作为一名在互联网技术行业打击过成百上千名的资深技术面试官,本文作者总结了面试过程中经常问到的问题。十分值得一读。 Redis在...

小刀爱编程
39分钟前
14
0
TiDB Lab 诞生记 | TiDB Hackathon 优秀项目分享

本文由红凤凰粉凤凰粉红凤凰队的成员主笔,他们的项目 TiDB Lab 在本届 TiDB Hackathon 2018 中获得了二等奖。TiDB Lab 为 TiDB 培训体系增加了一个可以动态观测 TiDB / TiKV / PD 细节的动画...

TiDB
52分钟前
4
0
当区块链遇到零知识证明

本文由云+社区发表 当区块链遇到零知识证明 什么是零知识证明 零知识证明的官方定义是能够在不向验证者任何有用的信息的情况下,使验证者相信某个论断是正确的。这个定义有点抽象,下面笔者举...

腾讯云加社区
今天
5
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部