解析Mybatis延迟加载问题

延迟加载问题

MyBatis针对关联表中的数据支持延迟加载。延迟加载其实就是将数据加载时机推迟,比如推迟嵌套查询的执行时机。

延迟加载可以实现先查询主表,按需实时做关联查询,返回关联表结果集,一定程度上提高了效率。

<settings>
        <!-- 启用延迟加载特性,不配置默认关闭该特性-->
        <setting name="lazyLoadingEnabled" value="true" />
        <!-- 按需加载: false:使用关联属性时才进行加载; true加载对象,则加载所有属性 -->
        <setting name="aggressiveLazyLoading" value="false"/>
</settings> 

lazyLoadingEnabled:是否启用延迟加载,默认值为false,不启用延迟加载。lazyLoadingEnabled属性控制全局是否使用延迟加载,特殊关联关系也可以通过嵌套查询中fetchType属性单独配置(fetchType属性值可以是lazy或者eager)

aggressiveLazyLoading:是否按需加载属性,默认值false,lazyLoadingEnabled属性启用时只要加载对象,就会加载该对象的所有属性;关闭该属性则会按需加载,即使用到某关联属性时,实时执行嵌套查询加载该属性

对一

 <resultMap id="ExtResultMap" type="com.yan.entity.User" extends="BaseResultMap">
    <association property="role" select="com.yan.dao.RoleMapper.selectByPrimaryKey" column="role_id"/>
  </resultMap>

如果不访问role属性,则不会执行t_roles表的查询。当访问role属性时才会执行查询操作,而且如果session关闭,则自动新打开session执行查询

对多

 <resultMap id="ExtResultMap" type="com.yan.entity.Role" extends="BaseResultMap">
    <collection property="users" ofType="com.yan.entity.User" column="id" select="com.yan.dao.UserMapper.selectByRoleId"/>
  </resultMap>

缓存

MyBatis支持一二级缓存
Mybatis提供查询缓存,如果缓存中有数据就不用从数据库中获取,用于减轻数据压力,提高系统性能

缓存的重要性是不言而喻的。 使用缓存可以避免频繁的与数据库进行交互, 尤其是在查询越多、缓存命中率越高的情况下, 使用缓存对性能的提高更明显。

mybatis也提供了对缓存的支持, 分为一级缓存和二级缓存。 但是在默认的情况下, 只开启一级缓存(一级缓存是对同一个 SqlSession 而言的)

  • 默认情况下,只有一级缓存(SqlSession级别的缓存,也称为本地缓存)开启
  • 二级缓存需要手动开启和配置,是基于namespace级别的缓存
  • 为了提高扩展性。MyBatis定义了缓存接口Cache。可以通过实现Cache接口来自定义二级缓存
  • 一级缓存是SqlSession级别的缓存。在操作数据库时需要构造sqlSession对象,在对象中有一个数据结构HashMap用于存储缓存数据。不同的sqlSession之间的缓存数据区域HashMap是互相不影响的
  • 二级缓存是mapper级别的缓存,多个SqlSession去操作同一个Mapper的sql语句,多个SqlSession可以共用二级缓存,二级缓存是跨SqlSession的

一级缓存

一级缓存即local cache本地缓存,作用域默认为sqlSession。当Session flush或close后该Session中的所有Cache将被清空

RoleMapper rm= MybatisSessionFactory.getMapper(RoleMapper.class);
        Role role=rm.selectByPrimaryKey(1L);
        System.out.println(role.getId()+":"+role.getName());
        System.out.println("--------------------------------");
        MybatisSessionFactory.closeSession();
        rm= MybatisSessionFactory.getMapper(RoleMapper.class);
        role=rm.selectByPrimaryKey(1L);
        System.out.println(role.getId()+":"+role.getName());

两次查询操作,分别是2次sql语句,证明缓存是session级的。如果不关闭session,即使2次获取Mapper执行的查询仍旧只有一个sql语句

每个SqlSession中持有了Executor,每个Executor中有一个LocalCache。当用户发起查询时,MyBatis根据当前执行的语句生成MappedStatement,在Local Cache进行查询,如果缓存命中的话,直接返回结果给用户,如果缓存没有命中的话,查询数据库,结果写入Local Cache,最后返回结果给用户

一级缓存配置

开发者只需在MyBatis的配置文件localCacheScope中可以设置使用一级缓存。共有两个选项SESSION或者STATEMENT,默认是SESSION级别,即在一个MyBatis会话中执行的所有语句,都会共享这一个缓存。一种是STATEMENT级别,可以理解为缓存只对当前执行的这一个Statement有效。

 UserMapper userMapper = MyBatisSessionFactory.getMapper(UserMapper.class);
User user1=userMapper.loadById(1L);
System.out.println(user1);

SqlSession session = MyBatisSessionFactory.openSession();
session.clearCache();//清空缓存 ,后续查询会发送SQL语句
User user2=userMapper.loadById(1L);
System.out.println(user2);
System.out.println(user1==user2);

MyBatisSessionFactory.closeSession();

1、第一次发起查询用户id为1的用户信息,先去找缓存中是否有id为1的用户信息,如果没有,从数据库查询用户信息。得到用户信息,将用户信息存储到一级缓存中。

2、如果中间sqlSession去执行commit操作(执行插入、更新、删除),则会清空SqlSession中的一级缓存,这样做的目的为了让缓存中存储的是最新的信息,避免脏读。

3、第二次发起查询用户id为1的用户信息,先去找缓存中是否有id为1的用户信息,缓存中有,直接从缓存中获取用户信息。

##源码分析

SqlSession对外提供了用户和数据库之间交互需要的所有方法,隐藏了底层的细节。默认实现类是DefaultSqlSession

Executor: SqlSession向用户提供操作数据库的方法,但和数据库操作有关的职责都会委托给Executor。

BaseExecutor是一个实现了Executor接口的抽象类,定义若干抽象方法,在执行的时候,把具体的操作委托给子类进行执行。

Cache: MyBatis中的Cache接口,提供了和缓存相关的最基本的操作

BaseExecutor成员变量之一的PerpetualCache,是对Cache接口最基本的实现,其实现非常简单,内部持有HashMap,对一级缓存的操作实则是对HashMap的操作。

1、为执行和数据库的交互,首先需要初始化SqlSession,通过DefaultSqlSessionFactory开启SqlSession

2、在初始化SqlSesion时,会使用Configuration类创建一个全新的Executor,作为DefaultSqlSession构造函数的参数

3、SqlSession创建完毕后,根据Statment的不同类型,会进入SqlSession的不同方法中,如果是Select语句的话,最后会执行到SqlSession的selectList

4、SqlSession把具体的查询职责委托给了Executor。如果只开启了一级缓存的话,首先会进入BaseExecutor的query方法。

5、会先根据传入的参数生成CacheKey,默认将MappedStatement的Id、sql的offset、Sql的limit、Sql本身以及Sql中的参数传入了CacheKey这个类,最终构成CacheKey

6、如果查不到的话,就从数据库查,在queryFromDatabase中,会对localcache进行写入。 在query方法执行的最后,会判断一级缓存级别是否是STATEMENT级别,如果是的话,就清空缓存,这也就是STATEMENT级别的一级缓存无法共享localCache的原因。

##总结

MyBatis一级缓存的生命周期和SqlSession一致。MyBatis一级缓存内部设计简单,只是一个没有容量限定的HashMap,在缓存的功能性上有所欠缺。MyBatis的一级缓存最大范围是SqlSession内部,有多个SqlSession或者分布式的环境下,数据库写操作会引起脏数据,建议设定缓存级别为Statement。

##一级缓存的生命周期

MyBatis在开启一个数据库会话时,会 创建一个新的SqlSession对象,SqlSession对象中会有一个新的Executor对象,Executor对象中持有一个新的PerpetualCache对象;当会话结束时,SqlSession对象及其内部的Executor对象还有PerpetualCache对象也一并释放掉。如果SqlSession调用了close()方法,会释放掉一级缓存PerpetualCache对象,一级缓存将不可用;如果SqlSession调用了clearCache(),会清空PerpetualCache对象中的数据,但是该对象仍可使用;SqlSession中执行了任何一个update操作(update()、delete()、insert()) ,都会清空PerpetualCache对象的数据,但是该对象可以继续使用

##一级缓存的不足

使用一级缓存的时候,因为缓存不能跨会话共享,不同的会话之间对于相同的数据可能有不一样的缓存。在有多个会话或者分布式环境下,会存在脏数据的问题。如果要解决这个问题,就要用到二级缓存。

MyBatis 一级缓存(MyBaits 称其为 Local Cache)无法关闭,但是有两种级别可选:

session级别的缓存,在同一个 sqlSession 内,对同样的查询将不再查询数据库,直接从缓存中。

statement级别的缓存,session级别缓存不能获取最新数据: 为了避免这个问题,可以将一级缓存的级别设为 statement 级别的,这样每次查询结束都会清掉一级缓存。

由于不同的sqlSession之间的缓存数据区域不共享,如果使用多个SqlSession对数据库进行操作时,就会出现脏数据

##二级缓存

一级缓存中,其最大的共享范围就是一个SqlSession内部,如果多个SqlSession之间需要共享缓存,则需要使用到二级缓存。开启二级缓存后,会使用CachingExecutor装饰Executor,进入一级缓存的查询流程前,先在CachingExecutor进行二级缓存的查询

二级缓存开启后,同一个namespace下的所有操作语句,都影响着同一个Cache,即二级缓存被多个SqlSession共享,是一个全局的变量。 当开启缓存后,数据的查询执行的流程就是 二级缓存 -> 一级缓存 -> 数据库。

二级缓存(全局缓存):基于namespace级别的缓存,一个namespace对应一个二级缓存

###二级缓存配置

1、在MyBatis的配置文件中开启二级缓存。

cacheEnabled 全局性地开启或关闭所有映射器配置文件中已配置的任何缓存。

2、在MyBatis的映射XML中配置cache或者 cache-ref

  • type:cache使用的类型,默认是PerpetualCache,这在一级缓存中提到过。
  • eviction: 定义回收的策略,常见的有FIFO,LRU。
  • flushInterval: 配置一定时间自动刷新缓存,单位是毫秒。
  • size: 最多缓存对象的个数。
  • readOnly: 是否只读,若配置可读写,则需要对应的实体类能够序列化。
  • blocking: 若缓存中找不到对应的key,是否会一直blocking,直到有对应的数据进入缓存。
<mapper namespace="com.yan.dao.RoleMapper">
  <cache/>

cache-ref代表引用别的命名空间的Cache配置,两个命名空间的操作使用的是同一个Cache。

二级缓存实验

1、测试二级缓存效果,不提交事务,sqlSession1查询完数据后,sqlSession2相同的查询是否会从缓存中获取数据。 可以看到,当sqlsession没有调用commit()方法时,二级缓存并没有起到作用。

SqlSession session1=MybatisSessionFactory.getFactory().openSession();
       SqlSession session2=MybatisSessionFactory.getSession();
       RoleMapper rm1=session1.getMapper(RoleMapper.class);
       RoleMapper rm2=session2.getMapper(RoleMapper.class);
       Role r1=rm1.selectByPrimaryKey(1L);
       session1.commit();  //如果不进行提交,则缓存无效
       Role r2=rm2.selectByPrimaryKey(1L);
        System.out.println(r1==r2);  //不是同一个对象,应该是对象的深克隆

2、测试二级缓存效果,当提交事务时,sqlSession1查询完数据后,sqlSession2相同的查询是否会从缓存中获取数据。 sqlsession2的查询,使用了缓存,缓存的命中率是0.5。

3、测试update操作是否会刷新该namespace下的二级缓存。 可以看到,在sqlSession3更新数据库,并提交事务后,sqlsession2的StudentMapper namespace下的查询走了数据库,没有走Cache。

4、验证MyBatis的二级缓存不适应用于映射文件中存在多表查询的情况。 通常我们会为每个单表创建单独的映射文件,由于MyBatis的二级缓存是基于namespace的,多表查询语句所在的namspace无法感应到其他namespace中的语句对多表查询中涉及的表进行的修改,引发脏数据问题。

5、为了解决实验4的问题呢,可以使用Cache ref,让ClassMapper引用StudenMapper命名空间,这样两个映射文件对应的Sql操作都使用的是同一块缓存了。 不过这样做的后果是,缓存的粒度变粗了,多个Mapper namespace下的所有操作都会对缓存使用造成影响。

<mapper namespace="com.yan.dao.UserMapper">
   <cache-ref namespace="com.yan.dao.RoleMapper"/>

###二级缓存源码

在一级缓存处理前,用CachingExecutor装饰了BaseExecutor的子类,在委托具体职责给delegate之前,实现了二级缓存的查询和写入功能

CachingExecutor的query方法,首先会从MappedStatement中获得在配置初始化时赋予的Cache。

本质上是装饰器模式的使用,具体的装饰链是SynchronizedCache -> LoggingCache -> SerializedCache -> LruCache -> PerpetualCache。

  • SynchronizedCache: 同步Cache,实现比较简单,直接使用synchronized修饰方法。
  • LoggingCache: 日志功能,装饰类,用于记录缓存的命中率,如果开启了DEBUG模式,则会输出命中率日志。SerializedCache: 序列化功能,将值序列化后存到缓存中。该功能用于缓存返回一份实例的Copy,用于保存线程安全。LruCache: 采用了Lru算法的Cache实现,移除最近最少使用的key/value。
  • PerpetualCache: 作为为最基础的缓存类,底层实现比较简单,直接使用了HashMap。

总结

  • MyBatis的二级缓存相对于一级缓存来说,实现了SqlSession之间缓存数据的共享,同时粒度更加的细,能够到namespace级别,通过Cache接口实现类不同的组合,对Cache的可控性也更强。
  • MyBatis在多表查询时,极大可能会出现脏数据,有设计上的缺陷,安全使用二级缓存的条件比较苛刻。一般在具体开发中不使用MyBatis的二级缓存,而是通过Spring框架引入业务层缓存
  • 在分布式环境下,由于默认的MyBatis Cache实现都是基于本地的,分布式环境下必然会出现读取到脏数据,需要使用集中式缓存将MyBatis的Cache接口实现,有一定的开发成本,直接使用Redis,Memcached等分布式缓存可能成本更低,安全性也更高。

到此这篇关于Mybatis的延迟加载问题的文章就介绍到这了,更多相关Mybatis延迟加载内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • Mybatis查询延迟加载详解及实例

    Mybatis查询延迟加载详解及实例 1.1     启用延迟加载 Mybatis的延迟加载是针对嵌套查询而言的,是指在进行查询的时候先只查询最外层的SQL,对于内层SQL将在需要使用的时候才查询出来.Mybatis的延迟加载默认是关闭的,即默认是一次就将所有的嵌套SQL一并查了将对象所有的信息都查询出来.开启延迟加载有两种方式. 第一种是在对应的<collection>或<association>标签上指定fetchType属性值为"lazy".如下示例中我们

  • Mybatis一对多延迟加载实现代码解析

    需求:一个用户可以有多个账户,查询用户时实现账户的延迟加载 1.用户实体类 package com.yl.bean; import java.io.Serializable; import java.sql.Date; import java.util.List; /** * 用户实体类 */ public class User implements Serializable { private Integer id;//id private String username;//用户名 priv

  • Mybatis延迟加载的实现方式

    1.概念: MyBatis中的延迟加载,也称为懒加载,是指在进行表的关联查询时,按照设置延迟规则推迟对关联对象的select查询.例如在进行一对多查询的时候,只查询出一方,当程序中需要多方的数据时,mybatis再发出sql语句进行查询,这样子延迟加载就可以的减少数据库压力.MyBatis 的延迟加载只是对关联对象的查询有迟延设置,对于主加载对象都是直接执行查询语句的. 2.加载时机: 直接加载:执行完对主加载对象的 select 语句,马上执行对关联对象的 select 查询.侵入式延迟: 执

  • Mybatis如何实现延迟加载及缓存

    一.延迟加载 1.在mybatis.xml配置文件中,开启延迟加载 <settings> <!--开启延迟加载--> <setting name="lazyLoadingEnabled" value="true"></setting> <setting name="aggressiveLazyLoading" value="false"></setting>

  • mybatis 延迟加载的深入理解

    什么是延迟加载 延迟加载又叫懒加载,也叫按需加载,也就是说先加载主信息,需要的时候,再去加载从信息.代码中有查询语句,当执行到查询语句时,并不是马上去DB中查询,而是根据设置的延迟策略将查询向后推迟. 什么时候会执行延迟加载 配置之后在对关联对象进行查询时使用延迟加载. 延迟加载策略 直接加载 遇到代码中查询语句,马上到DB中执行select语句进行查询.(这种只能用于多表单独查询) 侵入式延迟加载 将关联对象的详情(具体数据,如id.name)侵入到主加载对象,作为主加载对象的详情的一部分出现

  • Mybatis一对一延迟加载实现过程解析

    需求:用户和账户一对一关系,查询账户时实现用户的延迟加载 思路:根据id查询,需要延迟加载的一方 1.用户实体类 package com.yl.bean; import java.io.Serializable; import java.sql.Date; import java.util.List; /** * 用户实体类 */ public class User implements Serializable { private Integer id;//id private String

  • Mybatis延迟加载和缓存深入讲解

    一.Mybatis中的延迟加载 1.延迟加载背景:Mybatis中Mapper配置文件中的resultMap可以实现高级映射(使用association.collection实现一对一及一对多(多对多)映射),同样的association.collection具备延迟加载功能.所谓延迟加载,就是先单表查询,需要时再从关联表去关联查询(同样也可能只是是单表查询),大大单表查询速度更快,所以可以间接的提高数据库性能 2.在mybatis核心配置文件中配置,其中lazyLoadingEnabled表示

  • Mybatis中的延迟加载案例解析

    一.延迟加载 resultMap可以实现高级映射(使用association.collection实现一对一及一对多映射),association.collection具备延迟加载功能. 延迟加载:先从单表查询,需要时再从关联表去关联查询,大大提高数据库性能,因为查询单表要比关联查询多张表速度要快. 在mybatis核心配置文件中配置: lazyLoadingEnabled.aggressiveLazyLoading 设置项 描述 允许值 默认值 lazyLoadingEnabled 全局性设置

  • MyBatis 延迟加载、一级缓存、二级缓存(详解)

    使用ORM框架我们更多的是使用其查询功能,那么查询海量数据则又离不开性能,那么这篇中我们就看下mybatis高级应用之延迟加载.一级缓存.二级缓存.使用时需要注意延迟加载必须使用resultMap,resultType不具有延迟加载功能. 一.延迟加载 延迟加载已经是老生常谈的问题,什么最大化利用数据库性能之类之类的,也懒的列举了,总是我一提到延迟加载脑子里就会想起来了Hibernate get和load的区别.OK,废话少说,直接看代码. 先来修改配置项xml. 注意,编写mybatis.xm

  • mybatis中延迟加载Lazy策略的方法

    lazy策略原理:只有在使用查询sql返回的数据是才真正发出sql语句到数据库,否则不发出(主要用在多表的联合查询) 1.一对一延迟加载: 假设数据库中有person表和card表:其中person表中有字段pid,pname,page,psex,cid,card表中有字段cid,cnum; 假设要查询某个人的姓名和身份证号码: 原理:在查询姓名时,实际本没有查询出身份证号码的信息,只有当前台使用身份证号时才发出对card的查询,需要查询出身份证号码是采取查询的一种策略: 实现实例: 实现步骤:

  • mybatis教程之延迟加载详解

    延迟加载 1 使用延迟加载意义 在进行数据查询时,为了提高数据库查询性能,尽量使用单表查询,因为单表查询比多表关联查询速度要快. 如果查询单表就可以满足需求,一开始先查询单表,当需要关联信息时,再关联查询,当需要关联信息再查询这个叫延迟加载. mybatis中resultMap提供延迟加载功能,通过resultMap配置延迟加载. 2 配置mybatis支持延迟加载 在 SqlMapConfig.xml中配置全局参数: <!-- 全局配置参数 --> <settings> <

随机推荐