https://tech.meituan.com/mybatis_cache.html
MyBatis是常见的Java数据库访问层框架。在日常工作中,开发人员多数情况下是使用MyBatis的默认缓存配置,但是MyBatis缓存机制有一些不足之处,在使用中容易引起脏数据,形成一些潜在的隐患。个人在业务开发中也处理过一些由于MyBatis缓存引发的开发问题,带着个人的兴趣,希望从应用及源码的角度为读者梳理MyBatis缓存机制。本次分析中涉及到的代码和数据库表均放在GitHub上,地址:??。
本文按照以下顺序展开。
在应用运行过程中,我们有可能在一次数据库会话中,执行多次查询条件完全相同的SQL,MyBatis提供了一级缓存的方案优化这部分场景,如果是相同的SQL语句,会优先命中一级缓存,避免直接对数据库进行查询,提高性能。具体执行过程如下图所示。
我们来看看如何使用MyBatis一级缓存。开发者只需在MyBatis的配置文件中,添加如下语句,就可以使用一级缓存。共有两个选项,SESSION或者STATEMENT,默认是SESSION级别,即在一个MyBatis会话中执行的所有语句,都会共享这一个缓存。一种是STATEMENT级别,可以理解为缓存只对当前执行的这一个Statement有效。
接下来通过实验,了解MyBatis一级缓存的效果,每个单元测试后都请恢复被修改的数据。首先是创建示例表student,创建对应的POJO类和增改的方法,具体可以在entity包和mapper包中查看。
在以下实验中,id为1的学生名称是凯伦。
开启一级缓存,范围为会话级别,调用三次getStudentById,代码如下所示:
执行结果:
增加了对数据库的修改操作,验证在一次数据库会话中,如果对数据库发生了修改操作,一级缓存是否会失效。
开启两个SqlSession,在sqlSession1中查询数据,使一级缓存生效,在sqlSession2中更新数据库,验证一级缓存只在数据库会话内部共享。
StudentMapper studentMapper = sqlSession1.getMapper(StudentMapper.class); StudentMapper studentMapper2 = sqlSession2.getMapper(StudentMapper.class); System.out.println(<span class="string">"studentMapper读取数据: " + studentMapper.getStudentById(<span class="number">1)); System.out.println(<span class="string">"studentMapper读取数据: " + studentMapper.getStudentById(<span class="number">1)); System.out.println(<span class="string">"studentMapper2更新了" + studentMapper2.updateStudentName(<span class="string">"小岑",<span class="number">1) + <span class="string">"个学生的数据"); System.out.println(<span class="string">"studentMapper读取数据: " + studentMapper.getStudentById(<span class="number">1)); System.out.println(<span class="string">"studentMapper2读取数据: " + studentMapper2.getStudentById(<span class="number">1));
}
那么,一级缓存的工作流程是怎样的呢?我们从源码层面来学习一下。
一级缓存执行的时序图,如下图所示。
接下来将对MyBatis查询相关的核心类和一级缓存的源码进行走读。这对后面学习二级缓存也有帮助。SqlSession: 对外提供了用户和数据库之间交互需要的所有方法,隐藏了底层的细节。默认实现类是DefaultSqlSession。
Executor: SqlSession向用户提供操作数据库的方法,但和数据库操作有关的职责都会委托给Executor。
如下图所示,Executor有若干个实现类,为Executor赋予了不同的能力,大家可以根据类名,自行学习每个类的基本作用。
在一级缓存的源码分析中,主要学习BaseExecutor的内部实现。BaseExecutor: BaseExecutor是一个实现了Executor接口的抽象类,定义若干抽象方法,在执行的时候,把具体的操作委托给子类进行执行。
在一级缓存的介绍中提到对Local Cache的查询和写入是在Executor内部完成的。在阅读BaseExecutor的代码后发现Local Cache是BaseExecutor内部的一个成员变量,如下代码所示。
deferredLoads;
Cache: MyBatis中的Cache接口,提供了和缓存相关的最基本的操作,如下图所示。
cache = ();
在阅读相关核心类代码后,从源代码层面对一级缓存工作中涉及到的相关代码,出于篇幅的考虑,对源码做适当删减,读者朋友可以结合本文,后续进行更详细的学习。为执行和数据库的交互,首先需要初始化SqlSession,通过DefaultSqlSessionFactory开启SqlSession:
在初始化SqlSesion时,会使用Configuration类创建一个全新的Executor,作为DefaultSqlSession构造函数的参数,创建Executor代码如下所示:
SqlSession创建完毕后,根据Statment的不同类型,会进入SqlSession的不同方法中,如果是Select语句的话,最后会执行到SqlSession的selectList,代码如下所示:
SqlSession把具体的查询职责委托给了Executor。如果只开启了一级缓存的话,首先会进入BaseExecutor的query方法。代码如下所示:
在上述代码中,会先根据传入的参数生成CacheKey,进入该方法查看CacheKey是如何生成的,代码如下所示:
在上述的代码中,将MappedStatement的Id、sql的offset、Sql的limit、Sql本身以及Sql中的参数传入了CacheKey这个类,最终构成CacheKey。以下是这个类的内部结构:
<span class="keyword">private <span class="keyword">int multiplier; <span class="keyword">private <span class="keyword">int hashcode; <span class="keyword">private <span class="keyword">long checksum; <span class="keyword">private <span class="keyword">int count; <span class="keyword">private List updateList; <span class="function"><span class="keyword">public <span class="title">CacheKey<span class="params">() { <span class="keyword">this.hashcode = DEFAULT_HASHCODE; <span class="keyword">this.multiplier = DEFAULT_MULTIPLYER; <span class="keyword">this.count = <span class="number">0; <span class="keyword">this.updateList = <span class="keyword">new ArrayList(); } 首先是成员变量和构造函数,有一个初始的hachcode和乘数,同时维护了一个内部的updatelist。在CacheKey的update方法中,会进行一个hashcode和checksum的计算,同时把传入的参数添加进updatelist中。如下代码所示。 updateList.add(object); } 同时重写了CacheKey的equals方法,代码如下所示: 除去hashcode,checksum和count的比较外,只要updatelist中的元素一一对应相等,那么就可以认为是CacheKey相等。只要两条SQL的下列五个值相同,即可以认为是相同的SQL。 Statement Id + Offset + Limmit + Sql + Params BaseExecutor的query方法继续往下走,代码如下所示: ) localCache.getObject(key) : 如果查不到的话,就从数据库查,在queryFromDatabase中,会对localcache进行写入。在query方法执行的最后,会判断一级缓存级别是否是STATEMENT级别,如果是的话,就清空缓存,这也就是STATEMENT级别的一级缓存无法共享localCache的原因。代码如下所示: 在源码分析的最后,我们确认一下,如果是insert/delete/update方法,缓存就会刷新的原因。SqlSession的insert方法和delete方法,都会统一走update的流程,代码如下所示: update方法也是委托给了Executor执行。BaseExecutor的执行方法如下所示。 每次执行update前都会清空localCache。 至此,一级缓存的工作流程讲解以及源码分析完毕。 MyBatis一级缓存的生命周期和SqlSession一致。 MyBatis一级缓存内部设计简单,只是一个没有容量限定的HashMap,在缓存的功能性上有所欠缺。 MyBatis的一级缓存最大范围是SqlSession内部,有多个SqlSession或者分布式的环境下,数据库写操作会引起脏数据,建议设定缓存级别为Statement。 在上文中提到的一级缓存中,其最大的共享范围就是一个SqlSession内部,如果多个SqlSession之间需要共享缓存,则需要使用到二级缓存。开启二级缓存后,会使用CachingExecutor装饰Executor,进入一级缓存的查询流程前,先在CachingExecutor进行二级缓存的查询,具体的工作流程如下所示。 二级缓存开启后,同一个namespace下的所有操作语句,都影响着同一个Cache,即二级缓存被多个SqlSession共享,是一个全局的变量。当开启缓存后,数据的查询执行的流程就是 二级缓存 -> 一级缓存 -> 数据库。 要正确的使用二级缓存,需完成如下配置的。 在MyBatis的配置文件中开启二级缓存。 在MyBatis的映射XML中配置cache或者 cache-ref 。 cache标签用于声明这个namespace使用二级缓存,并且可以自定义配置。 type:cache使用的类型,默认是PerpetualCache,这在一级缓存中提到过。 eviction: 定义回收的策略,常见的有FIFO,LRU。 flushInterval: 配置一定时间自动刷新缓存,单位是毫秒。 size: 最多缓存对象的个数。 readOnly: 是否只读,若配置可读写,则需要对应的实体类能够序列化。 blocking: 若缓存中找不到对应的key,是否会一直blocking,直到有对应的数据进入缓存。 cache-ref代表引用别的命名空间的Cache配置,两个命名空间的操作使用的是同一个Cache。 接下来我们通过实验,了解MyBatis二级缓存在使用上的一些特点。在本实验中,id为1的学生名称初始化为点点。 测试二级缓存效果,不提交事务,sqlSession1查询完数据后,sqlSession2相同的查询是否会从缓存中获取数据。 StudentMapper studentMapper = sqlSession1.getMapper(StudentMapper.class); StudentMapper studentMapper2 = sqlSession2.getMapper(StudentMapper.class); System.out.println(<span class="string">"studentMapper读取数据: " + studentMapper.getStudentById(<span class="number">1)); System.out.println(<span class="string">"studentMapper2读取数据: " + studentMapper2.getStudentById(<span class="number">1)); } 执行结果: 测试二级缓存效果,当提交事务时,sqlSession1查询完数据后,sqlSession2相同的查询是否会从缓存中获取数据。 StudentMapper studentMapper = sqlSession1.getMapper(StudentMapper.class); StudentMapper studentMapper2 = sqlSession2.getMapper(StudentMapper.class); System.out.println(<span class="string">"studentMapper读取数据: " + studentMapper.getStudentById(<span class="number">1)); sqlSession1.commit(); System.out.println(<span class="string">"studentMapper2读取数据: " + studentMapper2.getStudentById(<span class="number">1)); } 测试update操作是否会刷新该namespace下的二级缓存。 StudentMapper studentMapper = sqlSession1.getMapper(StudentMapper.class); StudentMapper studentMapper2 = sqlSession2.getMapper(StudentMapper.class); StudentMapper studentMapper3 = sqlSession3.getMapper(StudentMapper.class); System.out.println(<span class="string">"studentMapper读取数据: " + studentMapper.getStudentById(<span class="number">1)); sqlSession1.commit(); System.out.println(<span class="string">"studentMapper2读取数据: " + studentMapper2.getStudentById(<span class="number">1)); studentMapper3.updateStudentName(<span class="string">"方方",<span class="number">1); sqlSession3.commit(); System.out.println(<span class="string">"studentMapper2读取数据: " + studentMapper2.getStudentById(<span class="number">1)); } 验证MyBatis的二级缓存不适应用于映射文件中存在多表查询的情况。通常我们会为每个单表创建单独的映射文件,由于MyBatis的二级缓存是基于namespace的,多表查询语句所在的namspace无法感应到其他namespace中的语句对多表查询中涉及的表进行的修改,引发脏数据问题。 StudentMapper studentMapper = sqlSession1.getMapper(StudentMapper.class); StudentMapper studentMapper2 = sqlSession2.getMapper(StudentMapper.class); ClassMapper classMapper = sqlSession3.getMapper(ClassMapper.class); System.out.println(<span class="string">"studentMapper读取数据: " + studentMapper.getStudentByIdWithClassInfo(<span class="number">1)); sqlSession1.close(); System.out.println(<span class="string">"studentMapper2读取数据: " + studentMapper2.getStudentByIdWithClassInfo(<span class="number">1)); classMapper.updateClassName(<span class="string">"特色一班",<span class="number">1); sqlSession3.commit(); System.out.println(<span class="string">"studentMapper2读取数据: " + studentMapper2.getStudentByIdWithClassInfo(<span class="number">1)); } 执行结果: 为了解决实验4的问题呢,可以使用Cache ref,让ClassMapper引用StudenMapper命名空间,这样两个映射文件对应的Sql操作都使用的是同一块缓存了。执行结果: MyBatis二级缓存的工作流程和前文提到的一级缓存类似,只是在一级缓存处理前,用CachingExecutor装饰了BaseExecutor的子类,在委托具体职责给delegate之前,实现了二级缓存的查询和写入功能,具体类关系图如下图所示。 源码分析从CachingExecutor的query方法展开,源代码走读过程中涉及到的知识点较多,不能一一详细讲解,读者朋友可以自行查询相关资料来学习。CachingExecutor的query方法,首先会从MappedStatement中获得在配置初始化时赋予的Cache。 本质上是装饰器模式的使用,具体的装饰链是 SynchronizedCache -> LoggingCache -> SerializedCache -> LruCache -> PerpetualCache。 以下是具体这些Cache实现类的介绍,他们的组合为Cache赋予了不同的能力。 SynchronizedCache: 同步Cache,实现比较简单,直接使用synchronized修饰方法。 LoggingCache: 日志功能,装饰类,用于记录缓存的命中率,如果开启了DEBUG模式,则会输出命中率日志。 SerializedCache: 序列化功能,将值序列化后存到缓存中。该功能用于缓存返回一份实例的Copy,用于保存线程安全。 LruCache: 采用了Lru算法的Cache实现,移除最近最少使用的key/value。 PerpetualCache: 作为为最基础的缓存类,底层实现比较简单,直接使用了HashMap。 然后是判断是否需要刷新缓存,代码如下所示: 在默认的设置中SELECT语句不会刷新缓存,insert/update/delte会刷新缓存。进入该方法。代码如下所示: MyBatis的CachingExecutor持有了TransactionalCacheManager,即上述代码中的tcm。TransactionalCacheManager中持有了一个Map,代码如下所示: transactionalCaches = (); 这个Map保存了Cache和用TransactionalCache包装后的Cache的映射关系。TransactionalCache实现了Cache接口,CachingExecutor会默认使用他包装初始生成的Cache,作用是如果事务提交,对缓存的操作才会生效,如果事务回滚或者不提交事务,则不对缓存产生影响。在TransactionalCache的clear,有以下两句。清空了需要在提交时加入缓存的列表,同时设定提交时清空缓存,代码如下所示: CachingExecutor继续往下走,ensureNoOutParams主要是用来处理存储过程的,暂时不用考虑。 之后会尝试从tcm中获取缓存的列表。 list = (List) tcm.getObject(cache,key); 在getObject方法中,会把获取值的职责一路传递,最终到PerpetualCache。如果没有查到,会把key加入Miss集合,这个主要是为了统计命中率。 CachingExecutor继续往下走,如果查询到数据,则调用tcm.putObject方法,往缓存中放入值。 query(ms,boundSql); tcm.putObject(cache,list); tcm的put方法也不是直接操作缓存,只是在把这次的数据和key放入待提交的Map中。 从以上的代码分析中,我们可以明白,如果不调用commit方法的话,由于TranscationalCache的作用,并不会对二级缓存造成直接的影响。因此我们看看Sqlsession的commit方法中做了什么。代码如下所示: 因为我们使用了CachingExecutor,首先会进入CachingExecutor实现的commit方法。 会把具体commit的职责委托给包装的Executor。主要是看下tcm.commit(),tcm最终又会调用到TrancationalCache。 看到这里的clearOnCommit就想起刚才TrancationalCache的clear方法设置的标志位,真正的清理Cache是放到这里来进行的。具体清理的职责委托给了包装的Cache类。之后进入flushPendingEntries方法。代码如下所示: entry : entriesToAddOnCommit.entrySet()) { delegate.putObject(entry.getKey(),entry.getValue()); } ................ } 在flushPendingEntries中,将待提交的Map进行循环处理,委托给包装的Cache类,进行putObject的操作。后续的查询操作会重复执行这套流程。如果是insert|update|delete的话,会统一进入CachingExecutor的update方法,其中调用了这个函数,代码如下所示: 在二级缓存执行流程后就会进入一级缓存的执行流程,因此不再赘述。 MyBatis的二级缓存相对于一级缓存来说,实现了SqlSession之间缓存数据的共享,同时粒度更加的细,能够到namespace级别,通过Cache接口实现类不同的组合,对Cache的可控性也更强。 MyBatis在多表查询时,极大可能会出现脏数据,有设计上的缺陷,安全使用二级缓存的条件比较苛刻。 在分布式环境下,由于默认的MyBatis Cache实现都是基于本地的,分布式环境下必然会出现读取到脏数据,需要使用集中式缓存将MyBatis的Cache接口实现,有一定的开发成本,直接使用Redis,Memcached等分布式缓存可能成本更低,安全性也更高。 本文对介绍了MyBatis一二级缓存的基本概念,并从应用及源码的角度对MyBatis的缓存机制进行了分析。最后对MyBatis缓存机制做了一定的总结,个人建议MyBatis缓存特性在生产环境中进行关闭,单纯作为一个ORM框架使用可能更为合适。 (编辑:李大同) 【声明】本站内容均来自网络,其相关言论仅代表作者个人观点,不代表本站立场。若无意侵犯到您的权利,请及时与联系站长删除相关内容!
<span class="function"><span class="keyword">public <span class="title">CacheKey<span class="params">() { <span class="keyword">this.hashcode = DEFAULT_HASHCODE; <span class="keyword">this.multiplier = DEFAULT_MULTIPLYER; <span class="keyword">this.count = <span class="number">0; <span class="keyword">this.updateList = <span class="keyword">new ArrayList(); } 首先是成员变量和构造函数,有一个初始的hachcode和乘数,同时维护了一个内部的updatelist。在CacheKey的update方法中,会进行一个hashcode和checksum的计算,同时把传入的参数添加进updatelist中。如下代码所示。 updateList.add(object); } 同时重写了CacheKey的equals方法,代码如下所示: 除去hashcode,checksum和count的比较外,只要updatelist中的元素一一对应相等,那么就可以认为是CacheKey相等。只要两条SQL的下列五个值相同,即可以认为是相同的SQL。 Statement Id + Offset + Limmit + Sql + Params BaseExecutor的query方法继续往下走,代码如下所示: ) localCache.getObject(key) : 如果查不到的话,就从数据库查,在queryFromDatabase中,会对localcache进行写入。在query方法执行的最后,会判断一级缓存级别是否是STATEMENT级别,如果是的话,就清空缓存,这也就是STATEMENT级别的一级缓存无法共享localCache的原因。代码如下所示: 在源码分析的最后,我们确认一下,如果是insert/delete/update方法,缓存就会刷新的原因。SqlSession的insert方法和delete方法,都会统一走update的流程,代码如下所示: update方法也是委托给了Executor执行。BaseExecutor的执行方法如下所示。 每次执行update前都会清空localCache。 至此,一级缓存的工作流程讲解以及源码分析完毕。 MyBatis一级缓存的生命周期和SqlSession一致。 MyBatis一级缓存内部设计简单,只是一个没有容量限定的HashMap,在缓存的功能性上有所欠缺。 MyBatis的一级缓存最大范围是SqlSession内部,有多个SqlSession或者分布式的环境下,数据库写操作会引起脏数据,建议设定缓存级别为Statement。 在上文中提到的一级缓存中,其最大的共享范围就是一个SqlSession内部,如果多个SqlSession之间需要共享缓存,则需要使用到二级缓存。开启二级缓存后,会使用CachingExecutor装饰Executor,进入一级缓存的查询流程前,先在CachingExecutor进行二级缓存的查询,具体的工作流程如下所示。 二级缓存开启后,同一个namespace下的所有操作语句,都影响着同一个Cache,即二级缓存被多个SqlSession共享,是一个全局的变量。当开启缓存后,数据的查询执行的流程就是 二级缓存 -> 一级缓存 -> 数据库。 要正确的使用二级缓存,需完成如下配置的。 在MyBatis的配置文件中开启二级缓存。 在MyBatis的映射XML中配置cache或者 cache-ref 。 cache标签用于声明这个namespace使用二级缓存,并且可以自定义配置。 type:cache使用的类型,默认是PerpetualCache,这在一级缓存中提到过。 eviction: 定义回收的策略,常见的有FIFO,LRU。 flushInterval: 配置一定时间自动刷新缓存,单位是毫秒。 size: 最多缓存对象的个数。 readOnly: 是否只读,若配置可读写,则需要对应的实体类能够序列化。 blocking: 若缓存中找不到对应的key,是否会一直blocking,直到有对应的数据进入缓存。 cache-ref代表引用别的命名空间的Cache配置,两个命名空间的操作使用的是同一个Cache。 接下来我们通过实验,了解MyBatis二级缓存在使用上的一些特点。在本实验中,id为1的学生名称初始化为点点。 测试二级缓存效果,不提交事务,sqlSession1查询完数据后,sqlSession2相同的查询是否会从缓存中获取数据。 StudentMapper studentMapper = sqlSession1.getMapper(StudentMapper.class); StudentMapper studentMapper2 = sqlSession2.getMapper(StudentMapper.class); System.out.println(<span class="string">"studentMapper读取数据: " + studentMapper.getStudentById(<span class="number">1)); System.out.println(<span class="string">"studentMapper2读取数据: " + studentMapper2.getStudentById(<span class="number">1)); } 执行结果: 测试二级缓存效果,当提交事务时,sqlSession1查询完数据后,sqlSession2相同的查询是否会从缓存中获取数据。 StudentMapper studentMapper = sqlSession1.getMapper(StudentMapper.class); StudentMapper studentMapper2 = sqlSession2.getMapper(StudentMapper.class); System.out.println(<span class="string">"studentMapper读取数据: " + studentMapper.getStudentById(<span class="number">1)); sqlSession1.commit(); System.out.println(<span class="string">"studentMapper2读取数据: " + studentMapper2.getStudentById(<span class="number">1)); } 测试update操作是否会刷新该namespace下的二级缓存。 StudentMapper studentMapper = sqlSession1.getMapper(StudentMapper.class); StudentMapper studentMapper2 = sqlSession2.getMapper(StudentMapper.class); StudentMapper studentMapper3 = sqlSession3.getMapper(StudentMapper.class); System.out.println(<span class="string">"studentMapper读取数据: " + studentMapper.getStudentById(<span class="number">1)); sqlSession1.commit(); System.out.println(<span class="string">"studentMapper2读取数据: " + studentMapper2.getStudentById(<span class="number">1)); studentMapper3.updateStudentName(<span class="string">"方方",<span class="number">1); sqlSession3.commit(); System.out.println(<span class="string">"studentMapper2读取数据: " + studentMapper2.getStudentById(<span class="number">1)); } 验证MyBatis的二级缓存不适应用于映射文件中存在多表查询的情况。通常我们会为每个单表创建单独的映射文件,由于MyBatis的二级缓存是基于namespace的,多表查询语句所在的namspace无法感应到其他namespace中的语句对多表查询中涉及的表进行的修改,引发脏数据问题。 StudentMapper studentMapper = sqlSession1.getMapper(StudentMapper.class); StudentMapper studentMapper2 = sqlSession2.getMapper(StudentMapper.class); ClassMapper classMapper = sqlSession3.getMapper(ClassMapper.class); System.out.println(<span class="string">"studentMapper读取数据: " + studentMapper.getStudentByIdWithClassInfo(<span class="number">1)); sqlSession1.close(); System.out.println(<span class="string">"studentMapper2读取数据: " + studentMapper2.getStudentByIdWithClassInfo(<span class="number">1)); classMapper.updateClassName(<span class="string">"特色一班",<span class="number">1); sqlSession3.commit(); System.out.println(<span class="string">"studentMapper2读取数据: " + studentMapper2.getStudentByIdWithClassInfo(<span class="number">1)); } 执行结果: 为了解决实验4的问题呢,可以使用Cache ref,让ClassMapper引用StudenMapper命名空间,这样两个映射文件对应的Sql操作都使用的是同一块缓存了。执行结果: MyBatis二级缓存的工作流程和前文提到的一级缓存类似,只是在一级缓存处理前,用CachingExecutor装饰了BaseExecutor的子类,在委托具体职责给delegate之前,实现了二级缓存的查询和写入功能,具体类关系图如下图所示。 源码分析从CachingExecutor的query方法展开,源代码走读过程中涉及到的知识点较多,不能一一详细讲解,读者朋友可以自行查询相关资料来学习。CachingExecutor的query方法,首先会从MappedStatement中获得在配置初始化时赋予的Cache。 本质上是装饰器模式的使用,具体的装饰链是 SynchronizedCache -> LoggingCache -> SerializedCache -> LruCache -> PerpetualCache。 以下是具体这些Cache实现类的介绍,他们的组合为Cache赋予了不同的能力。 SynchronizedCache: 同步Cache,实现比较简单,直接使用synchronized修饰方法。 LoggingCache: 日志功能,装饰类,用于记录缓存的命中率,如果开启了DEBUG模式,则会输出命中率日志。 SerializedCache: 序列化功能,将值序列化后存到缓存中。该功能用于缓存返回一份实例的Copy,用于保存线程安全。 LruCache: 采用了Lru算法的Cache实现,移除最近最少使用的key/value。 PerpetualCache: 作为为最基础的缓存类,底层实现比较简单,直接使用了HashMap。 然后是判断是否需要刷新缓存,代码如下所示: 在默认的设置中SELECT语句不会刷新缓存,insert/update/delte会刷新缓存。进入该方法。代码如下所示: MyBatis的CachingExecutor持有了TransactionalCacheManager,即上述代码中的tcm。TransactionalCacheManager中持有了一个Map,代码如下所示: transactionalCaches = (); 这个Map保存了Cache和用TransactionalCache包装后的Cache的映射关系。TransactionalCache实现了Cache接口,CachingExecutor会默认使用他包装初始生成的Cache,作用是如果事务提交,对缓存的操作才会生效,如果事务回滚或者不提交事务,则不对缓存产生影响。在TransactionalCache的clear,有以下两句。清空了需要在提交时加入缓存的列表,同时设定提交时清空缓存,代码如下所示: CachingExecutor继续往下走,ensureNoOutParams主要是用来处理存储过程的,暂时不用考虑。 之后会尝试从tcm中获取缓存的列表。 list = (List) tcm.getObject(cache,key); 在getObject方法中,会把获取值的职责一路传递,最终到PerpetualCache。如果没有查到,会把key加入Miss集合,这个主要是为了统计命中率。 CachingExecutor继续往下走,如果查询到数据,则调用tcm.putObject方法,往缓存中放入值。 query(ms,boundSql); tcm.putObject(cache,list); tcm的put方法也不是直接操作缓存,只是在把这次的数据和key放入待提交的Map中。 从以上的代码分析中,我们可以明白,如果不调用commit方法的话,由于TranscationalCache的作用,并不会对二级缓存造成直接的影响。因此我们看看Sqlsession的commit方法中做了什么。代码如下所示: 因为我们使用了CachingExecutor,首先会进入CachingExecutor实现的commit方法。 会把具体commit的职责委托给包装的Executor。主要是看下tcm.commit(),tcm最终又会调用到TrancationalCache。 看到这里的clearOnCommit就想起刚才TrancationalCache的clear方法设置的标志位,真正的清理Cache是放到这里来进行的。具体清理的职责委托给了包装的Cache类。之后进入flushPendingEntries方法。代码如下所示: entry : entriesToAddOnCommit.entrySet()) { delegate.putObject(entry.getKey(),entry.getValue()); } ................ } 在flushPendingEntries中,将待提交的Map进行循环处理,委托给包装的Cache类,进行putObject的操作。后续的查询操作会重复执行这套流程。如果是insert|update|delete的话,会统一进入CachingExecutor的update方法,其中调用了这个函数,代码如下所示: 在二级缓存执行流程后就会进入一级缓存的执行流程,因此不再赘述。 MyBatis的二级缓存相对于一级缓存来说,实现了SqlSession之间缓存数据的共享,同时粒度更加的细,能够到namespace级别,通过Cache接口实现类不同的组合,对Cache的可控性也更强。 MyBatis在多表查询时,极大可能会出现脏数据,有设计上的缺陷,安全使用二级缓存的条件比较苛刻。 在分布式环境下,由于默认的MyBatis Cache实现都是基于本地的,分布式环境下必然会出现读取到脏数据,需要使用集中式缓存将MyBatis的Cache接口实现,有一定的开发成本,直接使用Redis,Memcached等分布式缓存可能成本更低,安全性也更高。 本文对介绍了MyBatis一二级缓存的基本概念,并从应用及源码的角度对MyBatis的缓存机制进行了分析。最后对MyBatis缓存机制做了一定的总结,个人建议MyBatis缓存特性在生产环境中进行关闭,单纯作为一个ORM框架使用可能更为合适。 (编辑:李大同) 【声明】本站内容均来自网络,其相关言论仅代表作者个人观点,不代表本站立场。若无意侵犯到您的权利,请及时与联系站长删除相关内容!
首先是成员变量和构造函数,有一个初始的hachcode和乘数,同时维护了一个内部的updatelist。在CacheKey的update方法中,会进行一个hashcode和checksum的计算,同时把传入的参数添加进updatelist中。如下代码所示。
updateList.add(object);
同时重写了CacheKey的equals方法,代码如下所示:
除去hashcode,checksum和count的比较外,只要updatelist中的元素一一对应相等,那么就可以认为是CacheKey相等。只要两条SQL的下列五个值相同,即可以认为是相同的SQL。
Statement Id + Offset + Limmit + Sql + Params
BaseExecutor的query方法继续往下走,代码如下所示:
) localCache.getObject(key) :
如果查不到的话,就从数据库查,在queryFromDatabase中,会对localcache进行写入。在query方法执行的最后,会判断一级缓存级别是否是STATEMENT级别,如果是的话,就清空缓存,这也就是STATEMENT级别的一级缓存无法共享localCache的原因。代码如下所示:
在源码分析的最后,我们确认一下,如果是insert/delete/update方法,缓存就会刷新的原因。SqlSession的insert方法和delete方法,都会统一走update的流程,代码如下所示:
update方法也是委托给了Executor执行。BaseExecutor的执行方法如下所示。
每次执行update前都会清空localCache。
至此,一级缓存的工作流程讲解以及源码分析完毕。
在上文中提到的一级缓存中,其最大的共享范围就是一个SqlSession内部,如果多个SqlSession之间需要共享缓存,则需要使用到二级缓存。开启二级缓存后,会使用CachingExecutor装饰Executor,进入一级缓存的查询流程前,先在CachingExecutor进行二级缓存的查询,具体的工作流程如下所示。
二级缓存开启后,同一个namespace下的所有操作语句,都影响着同一个Cache,即二级缓存被多个SqlSession共享,是一个全局的变量。当开启缓存后,数据的查询执行的流程就是 二级缓存 -> 一级缓存 -> 数据库。
要正确的使用二级缓存,需完成如下配置的。
cache标签用于声明这个namespace使用二级缓存,并且可以自定义配置。
cache-ref代表引用别的命名空间的Cache配置,两个命名空间的操作使用的是同一个Cache。
接下来我们通过实验,了解MyBatis二级缓存在使用上的一些特点。在本实验中,id为1的学生名称初始化为点点。
测试二级缓存效果,不提交事务,sqlSession1查询完数据后,sqlSession2相同的查询是否会从缓存中获取数据。
StudentMapper studentMapper = sqlSession1.getMapper(StudentMapper.class); StudentMapper studentMapper2 = sqlSession2.getMapper(StudentMapper.class); System.out.println(<span class="string">"studentMapper读取数据: " + studentMapper.getStudentById(<span class="number">1)); System.out.println(<span class="string">"studentMapper2读取数据: " + studentMapper2.getStudentById(<span class="number">1));
测试二级缓存效果,当提交事务时,sqlSession1查询完数据后,sqlSession2相同的查询是否会从缓存中获取数据。
StudentMapper studentMapper = sqlSession1.getMapper(StudentMapper.class); StudentMapper studentMapper2 = sqlSession2.getMapper(StudentMapper.class); System.out.println(<span class="string">"studentMapper读取数据: " + studentMapper.getStudentById(<span class="number">1)); sqlSession1.commit(); System.out.println(<span class="string">"studentMapper2读取数据: " + studentMapper2.getStudentById(<span class="number">1));
测试update操作是否会刷新该namespace下的二级缓存。
StudentMapper studentMapper = sqlSession1.getMapper(StudentMapper.class); StudentMapper studentMapper2 = sqlSession2.getMapper(StudentMapper.class); StudentMapper studentMapper3 = sqlSession3.getMapper(StudentMapper.class); System.out.println(<span class="string">"studentMapper读取数据: " + studentMapper.getStudentById(<span class="number">1)); sqlSession1.commit(); System.out.println(<span class="string">"studentMapper2读取数据: " + studentMapper2.getStudentById(<span class="number">1)); studentMapper3.updateStudentName(<span class="string">"方方",<span class="number">1); sqlSession3.commit(); System.out.println(<span class="string">"studentMapper2读取数据: " + studentMapper2.getStudentById(<span class="number">1));
验证MyBatis的二级缓存不适应用于映射文件中存在多表查询的情况。通常我们会为每个单表创建单独的映射文件,由于MyBatis的二级缓存是基于namespace的,多表查询语句所在的namspace无法感应到其他namespace中的语句对多表查询中涉及的表进行的修改,引发脏数据问题。
StudentMapper studentMapper = sqlSession1.getMapper(StudentMapper.class); StudentMapper studentMapper2 = sqlSession2.getMapper(StudentMapper.class); ClassMapper classMapper = sqlSession3.getMapper(ClassMapper.class); System.out.println(<span class="string">"studentMapper读取数据: " + studentMapper.getStudentByIdWithClassInfo(<span class="number">1)); sqlSession1.close(); System.out.println(<span class="string">"studentMapper2读取数据: " + studentMapper2.getStudentByIdWithClassInfo(<span class="number">1)); classMapper.updateClassName(<span class="string">"特色一班",<span class="number">1); sqlSession3.commit(); System.out.println(<span class="string">"studentMapper2读取数据: " + studentMapper2.getStudentByIdWithClassInfo(<span class="number">1));
为了解决实验4的问题呢,可以使用Cache ref,让ClassMapper引用StudenMapper命名空间,这样两个映射文件对应的Sql操作都使用的是同一块缓存了。执行结果:
MyBatis二级缓存的工作流程和前文提到的一级缓存类似,只是在一级缓存处理前,用CachingExecutor装饰了BaseExecutor的子类,在委托具体职责给delegate之前,实现了二级缓存的查询和写入功能,具体类关系图如下图所示。
源码分析从CachingExecutor的query方法展开,源代码走读过程中涉及到的知识点较多,不能一一详细讲解,读者朋友可以自行查询相关资料来学习。CachingExecutor的query方法,首先会从MappedStatement中获得在配置初始化时赋予的Cache。
本质上是装饰器模式的使用,具体的装饰链是 SynchronizedCache -> LoggingCache -> SerializedCache -> LruCache -> PerpetualCache。 以下是具体这些Cache实现类的介绍,他们的组合为Cache赋予了不同的能力。 SynchronizedCache: 同步Cache,实现比较简单,直接使用synchronized修饰方法。 LoggingCache: 日志功能,装饰类,用于记录缓存的命中率,如果开启了DEBUG模式,则会输出命中率日志。 SerializedCache: 序列化功能,将值序列化后存到缓存中。该功能用于缓存返回一份实例的Copy,用于保存线程安全。 LruCache: 采用了Lru算法的Cache实现,移除最近最少使用的key/value。 PerpetualCache: 作为为最基础的缓存类,底层实现比较简单,直接使用了HashMap。 然后是判断是否需要刷新缓存,代码如下所示: 在默认的设置中SELECT语句不会刷新缓存,insert/update/delte会刷新缓存。进入该方法。代码如下所示: MyBatis的CachingExecutor持有了TransactionalCacheManager,即上述代码中的tcm。TransactionalCacheManager中持有了一个Map,代码如下所示: transactionalCaches = (); 这个Map保存了Cache和用TransactionalCache包装后的Cache的映射关系。TransactionalCache实现了Cache接口,CachingExecutor会默认使用他包装初始生成的Cache,作用是如果事务提交,对缓存的操作才会生效,如果事务回滚或者不提交事务,则不对缓存产生影响。在TransactionalCache的clear,有以下两句。清空了需要在提交时加入缓存的列表,同时设定提交时清空缓存,代码如下所示: CachingExecutor继续往下走,ensureNoOutParams主要是用来处理存储过程的,暂时不用考虑。 之后会尝试从tcm中获取缓存的列表。 list = (List) tcm.getObject(cache,key); 在getObject方法中,会把获取值的职责一路传递,最终到PerpetualCache。如果没有查到,会把key加入Miss集合,这个主要是为了统计命中率。 CachingExecutor继续往下走,如果查询到数据,则调用tcm.putObject方法,往缓存中放入值。 query(ms,boundSql); tcm.putObject(cache,list); tcm的put方法也不是直接操作缓存,只是在把这次的数据和key放入待提交的Map中。 从以上的代码分析中,我们可以明白,如果不调用commit方法的话,由于TranscationalCache的作用,并不会对二级缓存造成直接的影响。因此我们看看Sqlsession的commit方法中做了什么。代码如下所示: 因为我们使用了CachingExecutor,首先会进入CachingExecutor实现的commit方法。 会把具体commit的职责委托给包装的Executor。主要是看下tcm.commit(),tcm最终又会调用到TrancationalCache。 看到这里的clearOnCommit就想起刚才TrancationalCache的clear方法设置的标志位,真正的清理Cache是放到这里来进行的。具体清理的职责委托给了包装的Cache类。之后进入flushPendingEntries方法。代码如下所示: entry : entriesToAddOnCommit.entrySet()) { delegate.putObject(entry.getKey(),entry.getValue()); } ................ } 在flushPendingEntries中,将待提交的Map进行循环处理,委托给包装的Cache类,进行putObject的操作。后续的查询操作会重复执行这套流程。如果是insert|update|delete的话,会统一进入CachingExecutor的update方法,其中调用了这个函数,代码如下所示: 在二级缓存执行流程后就会进入一级缓存的执行流程,因此不再赘述。 MyBatis的二级缓存相对于一级缓存来说,实现了SqlSession之间缓存数据的共享,同时粒度更加的细,能够到namespace级别,通过Cache接口实现类不同的组合,对Cache的可控性也更强。 MyBatis在多表查询时,极大可能会出现脏数据,有设计上的缺陷,安全使用二级缓存的条件比较苛刻。 在分布式环境下,由于默认的MyBatis Cache实现都是基于本地的,分布式环境下必然会出现读取到脏数据,需要使用集中式缓存将MyBatis的Cache接口实现,有一定的开发成本,直接使用Redis,Memcached等分布式缓存可能成本更低,安全性也更高。 本文对介绍了MyBatis一二级缓存的基本概念,并从应用及源码的角度对MyBatis的缓存机制进行了分析。最后对MyBatis缓存机制做了一定的总结,个人建议MyBatis缓存特性在生产环境中进行关闭,单纯作为一个ORM框架使用可能更为合适。 (编辑:李大同) 【声明】本站内容均来自网络,其相关言论仅代表作者个人观点,不代表本站立场。若无意侵犯到您的权利,请及时与联系站长删除相关内容!
本质上是装饰器模式的使用,具体的装饰链是
SynchronizedCache -> LoggingCache -> SerializedCache -> LruCache -> PerpetualCache。
以下是具体这些Cache实现类的介绍,他们的组合为Cache赋予了不同的能力。
然后是判断是否需要刷新缓存,代码如下所示:
在默认的设置中SELECT语句不会刷新缓存,insert/update/delte会刷新缓存。进入该方法。代码如下所示: MyBatis的CachingExecutor持有了TransactionalCacheManager,即上述代码中的tcm。TransactionalCacheManager中持有了一个Map,代码如下所示: transactionalCaches = (); 这个Map保存了Cache和用TransactionalCache包装后的Cache的映射关系。TransactionalCache实现了Cache接口,CachingExecutor会默认使用他包装初始生成的Cache,作用是如果事务提交,对缓存的操作才会生效,如果事务回滚或者不提交事务,则不对缓存产生影响。在TransactionalCache的clear,有以下两句。清空了需要在提交时加入缓存的列表,同时设定提交时清空缓存,代码如下所示: CachingExecutor继续往下走,ensureNoOutParams主要是用来处理存储过程的,暂时不用考虑。 之后会尝试从tcm中获取缓存的列表。 list = (List) tcm.getObject(cache,key); 在getObject方法中,会把获取值的职责一路传递,最终到PerpetualCache。如果没有查到,会把key加入Miss集合,这个主要是为了统计命中率。 CachingExecutor继续往下走,如果查询到数据,则调用tcm.putObject方法,往缓存中放入值。 query(ms,boundSql); tcm.putObject(cache,list); tcm的put方法也不是直接操作缓存,只是在把这次的数据和key放入待提交的Map中。 从以上的代码分析中,我们可以明白,如果不调用commit方法的话,由于TranscationalCache的作用,并不会对二级缓存造成直接的影响。因此我们看看Sqlsession的commit方法中做了什么。代码如下所示: 因为我们使用了CachingExecutor,首先会进入CachingExecutor实现的commit方法。 会把具体commit的职责委托给包装的Executor。主要是看下tcm.commit(),tcm最终又会调用到TrancationalCache。 看到这里的clearOnCommit就想起刚才TrancationalCache的clear方法设置的标志位,真正的清理Cache是放到这里来进行的。具体清理的职责委托给了包装的Cache类。之后进入flushPendingEntries方法。代码如下所示: entry : entriesToAddOnCommit.entrySet()) { delegate.putObject(entry.getKey(),entry.getValue()); } ................ } 在flushPendingEntries中,将待提交的Map进行循环处理,委托给包装的Cache类,进行putObject的操作。后续的查询操作会重复执行这套流程。如果是insert|update|delete的话,会统一进入CachingExecutor的update方法,其中调用了这个函数,代码如下所示: 在二级缓存执行流程后就会进入一级缓存的执行流程,因此不再赘述。 MyBatis的二级缓存相对于一级缓存来说,实现了SqlSession之间缓存数据的共享,同时粒度更加的细,能够到namespace级别,通过Cache接口实现类不同的组合,对Cache的可控性也更强。 MyBatis在多表查询时,极大可能会出现脏数据,有设计上的缺陷,安全使用二级缓存的条件比较苛刻。 在分布式环境下,由于默认的MyBatis Cache实现都是基于本地的,分布式环境下必然会出现读取到脏数据,需要使用集中式缓存将MyBatis的Cache接口实现,有一定的开发成本,直接使用Redis,Memcached等分布式缓存可能成本更低,安全性也更高。 本文对介绍了MyBatis一二级缓存的基本概念,并从应用及源码的角度对MyBatis的缓存机制进行了分析。最后对MyBatis缓存机制做了一定的总结,个人建议MyBatis缓存特性在生产环境中进行关闭,单纯作为一个ORM框架使用可能更为合适。 (编辑:李大同) 【声明】本站内容均来自网络,其相关言论仅代表作者个人观点,不代表本站立场。若无意侵犯到您的权利,请及时与联系站长删除相关内容!
在默认的设置中SELECT语句不会刷新缓存,insert/update/delte会刷新缓存。进入该方法。代码如下所示:
MyBatis的CachingExecutor持有了TransactionalCacheManager,即上述代码中的tcm。TransactionalCacheManager中持有了一个Map,代码如下所示:
transactionalCaches = ();
这个Map保存了Cache和用TransactionalCache包装后的Cache的映射关系。TransactionalCache实现了Cache接口,CachingExecutor会默认使用他包装初始生成的Cache,作用是如果事务提交,对缓存的操作才会生效,如果事务回滚或者不提交事务,则不对缓存产生影响。在TransactionalCache的clear,有以下两句。清空了需要在提交时加入缓存的列表,同时设定提交时清空缓存,代码如下所示:
CachingExecutor继续往下走,ensureNoOutParams主要是用来处理存储过程的,暂时不用考虑。
之后会尝试从tcm中获取缓存的列表。
list = (List) tcm.getObject(cache,key);
在getObject方法中,会把获取值的职责一路传递,最终到PerpetualCache。如果没有查到,会把key加入Miss集合,这个主要是为了统计命中率。
CachingExecutor继续往下走,如果查询到数据,则调用tcm.putObject方法,往缓存中放入值。
query(ms,boundSql); tcm.putObject(cache,list);
tcm的put方法也不是直接操作缓存,只是在把这次的数据和key放入待提交的Map中。
从以上的代码分析中,我们可以明白,如果不调用commit方法的话,由于TranscationalCache的作用,并不会对二级缓存造成直接的影响。因此我们看看Sqlsession的commit方法中做了什么。代码如下所示:
因为我们使用了CachingExecutor,首先会进入CachingExecutor实现的commit方法。
会把具体commit的职责委托给包装的Executor。主要是看下tcm.commit(),tcm最终又会调用到TrancationalCache。
看到这里的clearOnCommit就想起刚才TrancationalCache的clear方法设置的标志位,真正的清理Cache是放到这里来进行的。具体清理的职责委托给了包装的Cache类。之后进入flushPendingEntries方法。代码如下所示:
entry : entriesToAddOnCommit.entrySet()) { delegate.putObject(entry.getKey(),entry.getValue()); } ................ }
在flushPendingEntries中,将待提交的Map进行循环处理,委托给包装的Cache类,进行putObject的操作。后续的查询操作会重复执行这套流程。如果是insert|update|delete的话,会统一进入CachingExecutor的update方法,其中调用了这个函数,代码如下所示:
在二级缓存执行流程后就会进入一级缓存的执行流程,因此不再赘述。
本文对介绍了MyBatis一二级缓存的基本概念,并从应用及源码的角度对MyBatis的缓存机制进行了分析。最后对MyBatis缓存机制做了一定的总结,个人建议MyBatis缓存特性在生产环境中进行关闭,单纯作为一个ORM框架使用可能更为合适。
(编辑:李大同)
【声明】本站内容均来自网络,其相关言论仅代表作者个人观点,不代表本站立场。若无意侵犯到您的权利,请及时与联系站长删除相关内容!