聊聊MyBatis缓存机制

转载自 聊聊MyBatis缓存机制

前言


MyBatis是常见的Java数据库访问层框架。在日常工作中，开发人员多数情况下是使用MyBatis的默认缓存配置，但是MyBatis缓存机制有一些不足之处，在使用中容易引起脏数据，形成一些潜在的隐患。


个人在业务开发中也处理过一些由于MyBatis缓存引发的开发问题，带着个人的兴趣，希望从应用及源码的角度为读者梳理MyBatis缓存机制。

本次分析中涉及到的代码和数据库表均放在GitHub上，地址： mybatis-cache-demo 。


目录


本文按照以下顺序展开。

  • 一级缓存介绍及相关配置。

  • 一级缓存工作流程及源码分析。

  • 一级缓存总结。

  • 二级缓存介绍及相关配置。

  • 二级缓存源码分析。

  • 二级缓存总结。

  • 全文总结。


一级缓存


一级缓存介绍


在应用运行过程中，我们有可能在一次数据库会话中，执行多次查询条件完全相同的SQL，MyBatis提供了一级缓存的方案优化这部分场景，如果是相同的SQL语句，会优先命中一级缓存，避免直接对数据库进行查询，提高性能。具体执行过程如下图所示。



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



一级缓存配置


我们来看看如何使用MyBatis一级缓存。开发者只需在MyBatis的配置文件中，添加如下语句，就可以使用一级缓存。共有两个选项，SESSION或者STATEMENT，默认是SESSION级别，即在一个MyBatis会话中执行的所有语句，都会共享这一个缓存。一种是STATEMENT级别，可以理解为缓存只对当前执行的这一个Statement有效。

<setting name="localCacheScope" value="SESSION"/>


一级缓存实验


接下来通过实验，了解MyBatis一级缓存的效果，每个单元测试后都请恢复被修改的数据。

首先是创建示例表student，创建对应的POJO类和增改的方法，具体可以在entity包和mapper包中查看。

CREATE TABLE `student` (  `id` int(11) unsigned NOT NULL AUTO_INCREMENT,  `name` varchar(200) COLLATE utf8_bin DEFAULT NULL,  `age` tinyint(3) unsigned DEFAULT NULL,PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8 COLLATE=utf8_bin;


在以下实验中，id为1的学生名称是凯伦。


实验1


开启一级缓存，范围为会话级别，调用三次getStudentById，代码如下所示：

public void getStudentById() throws Exception {SqlSession sqlSession = factory.openSession(true); // 自动提交事务StudentMapper studentMapper = sqlSession.getMapper(StudentMapper.class);System.out.println(studentMapper.getStudentById(1));System.out.println(studentMapper.getStudentById(1));System.out.println(studentMapper.getStudentById(1));}


执行结果：



我们可以看到，只有第一次真正查询了数据库，后续的查询使用了一级缓存。


实验2


增加了对数据库的修改操作，验证在一次数据库会话中，如果对数据库发生了修改操作，一级缓存是否会失效。

@Testpublic void addStudent() throws Exception {SqlSession sqlSession = factory.openSession(true); // 自动提交事务StudentMapper studentMapper = sqlSession.getMapper(StudentMapper.class);System.out.println(studentMapper.getStudentById(1));System.out.println("增加了" + studentMapper.addStudent(buildStudent()) + "个学生");System.out.println(studentMapper.getStudentById(1));sqlSession.close();
}


执行结果：



我们可以看到，在修改操作后执行的相同查询，查询了数据库，一级缓存失效。


实验3


开启两个SqlSession，在sqlSession1中查询数据，使一级缓存生效，在sqlSession2中更新数据库，验证一级缓存只在数据库会话内部共享。

@Testpublic void testLocalCacheScope() throws Exception {SqlSession sqlSession1 = factory.openSession(true); SqlSession sqlSession2 = factory.openSession(true); StudentMapper studentMapper = sqlSession1.getMapper(StudentMapper.class);StudentMapper studentMapper2 = sqlSession2.getMapper(StudentMapper.class);System.out.println("studentMapper读取数据: " + studentMapper.getStudentById(1));System.out.println("studentMapper读取数据: " + studentMapper.getStudentById(1));System.out.println("studentMapper2更新了" + studentMapper2.updateStudentName("小岑",1) + "个学生的数据");System.out.println("studentMapper读取数据: " + studentMapper.getStudentById(1));System.out.println("studentMapper2读取数据: " + studentMapper2.getStudentById(1));
}



sqlSession2更新了id为1的学生的姓名，从凯伦改为了小岑，但session1之后的查询中，id为1的学生的名字还是凯伦，出现了脏数据，也证明了之前的设想，一级缓存只在数据库会话内部共享。


一级缓存工作流程&源码分析


那么，一级缓存的工作流程是怎样的呢？我们从源码层面来学习一下。


工作流程


一级缓存执行的时序图，如下图所示。



源码分析


接下来将对MyBatis查询相关的核心类和一级缓存的源码进行走读。这对后面学

习二级缓存也有帮助。

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



Executor： SqlSession向用户提供操作数据库的方法，但和数据库操作有关的

职责都会委托给Executor。



如下图所示，Executor有若干个实现类，为Executor赋予了不同的能力，大家可以根据类名，自行学习每个类的基本作用。



在一级缓存的源码分析中，主要学习BaseExecutor的内部实现。

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

protected abstract int doUpdate(MappedStatement ms, Object parameter) throws SQLException;protected abstract List<BatchResult> doFlushStatements(boolean isRollback) throws SQLException;protected abstract <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException;protected abstract <E> Cursor<E> doQueryCursor(MappedStatement ms, Object parameter, RowBounds rowBounds, BoundSql boundSql) throws SQLException;


在一级缓存的介绍中提到对Local Cache的查询和写入是在Executor内部完成的。在阅读BaseExecutor的代码后发现Local Cache是BaseExecutor内部的一个成员变量，如下代码所示。

public abstract class BaseExecutor implements Executor {protected ConcurrentLinkedQueue<DeferredLoad> deferredLoads;protected PerpetualCache localCache;


Cache： MyBatis中的Cache接口，提供了和缓存相关的最基本的操作，如下图所示。



有若干个实现类，使用装饰器模式互相组装，提供丰富的操控缓存的能力，部分实现类如下图所示。



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

public class PerpetualCache implements Cache {  private String id;  private Map<Object, Object> cache = new HashMap<Object, Object>();


在阅读相关核心类代码后，从源代码层面对一级缓存工作中涉及到的相关代码，出于篇幅的考虑，对源码做适当删减，读者朋友可以结合本文，后续进行更详细的学习。

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

private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {............    final Executor executor = configuration.newExecutor(tx, execType);     return new DefaultSqlSession(configuration, executor, autoCommit);
}


在初始化SqlSesion时，会使用Configuration类创建一个全新的Executor，作为DefaultSqlSession构造函数的参数，创建Executor代码如下所示：

public Executor newExecutor(Transaction transaction, ExecutorType executorType) {executorType = executorType == null ? defaultExecutorType : executorType;executorType = executorType == null ? ExecutorType.SIMPLE : executorType;Executor executor;    if (ExecutorType.BATCH == executorType) {executor = new BatchExecutor(this, transaction);} else if (ExecutorType.REUSE == executorType) {executor = new ReuseExecutor(this, transaction);} else {executor = new SimpleExecutor(this, transaction);}    // 尤其可以注意这里，如果二级缓存开关开启的话，是使用CahingExecutor装饰BaseExecutor的子类if (cacheEnabled) {executor = new CachingExecutor(executor);                      }executor = (Executor) interceptorChain.pluginAll(executor);    return executor;
}


SqlSession创建完毕后，根据Statment的不同类型，会进入SqlSession的不同方法中，如果是Select语句的话，最后会执行到SqlSession的selectList，代码如下所示：

@Overridepublic <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {MappedStatement ms = configuration.getMappedStatement(statement);      return executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);
}


SqlSession把具体的查询职责委托给了Executor。如果只开启了一级缓存的话，首先会进入BaseExecutor的query方法。代码如下所示：

@Overridepublic <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {BoundSql boundSql = ms.getBoundSql(parameter);CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);    return query(ms, parameter, rowBounds, resultHandler, key, boundSql);
}


在上述代码中，会先根据传入的参数生成CacheKey，进入该方法查看CacheKey是如何生成的，代码如下所示：

CacheKey cacheKey = new CacheKey();
cacheKey.update(ms.getId());
cacheKey.update(rowBounds.getOffset());
cacheKey.update(rowBounds.getLimit());
cacheKey.update(boundSql.getSql());//后面是update了sql中带的参数cacheKey.update(value);


在上述的代码中，将MappedStatement的Id、sql的offset、Sql的limit、Sql本身以及Sql中的参数传入了CacheKey这个类，最终构成CacheKey。以下是这个类的内部结构：

private static final int DEFAULT_MULTIPLYER = 37;private static final int DEFAULT_HASHCODE = 17;private int multiplier;private int hashcode;private long checksum;private int count;private List<Object> updateList;public CacheKey() {    this.hashcode = DEFAULT_HASHCODE;    this.multiplier = DEFAULT_MULTIPLYER;    this.count = 0;    this.updateList = new ArrayList<Object>();
}


首先是成员变量和构造函数，有一个初始的hachcode和乘数，同时维护了一个内部的updatelist。在CacheKey的update方法中，会进行一个hashcode和checksum的计算，同时把传入的参数添加进updatelist中。如下代码所示。

public void update(Object object) {    int baseHashCode = object == null ? 1 : ArrayUtil.hashCode(object); count++;checksum += baseHashCode;baseHashCode *= count;hashcode = multiplier * hashcode + baseHashCode;updateList.add(object);
}


同时重写了CacheKey的equals方法，代码如下所示：

@Overridepublic boolean equals(Object object) {.............    for (int i = 0; i < updateList.size(); i++) {Object thisObject = updateList.get(i);Object thatObject = cacheKey.updateList.get(i);      if (!ArrayUtil.equals(thisObject, thatObject)) {        return false;}}    return true;
}


除去hashcode，checksum和count的比较外，只要updatelist中的元素一一对应相等，那么就可以认为是CacheKey相等。只要两条SQL的下列五个值相同，即可以认为是相同的SQL。


Statement Id + Offset + Limmit + Sql + Params


BaseExecutor的query方法继续往下走，代码如下所示：

list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;if (list != null) {    // 这个主要是处理存储过程用的。handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);} else {list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
}


如果查不到的话，就从数据库查，在queryFromDatabase中，会对localcache进行写入。

在query方法执行的最后，会判断一级缓存级别是否是STATEMENT级别，如果是的话，就清空缓存，这也就是STATEMENT级别的一级缓存无法共享localCache的原因。代码如下所示：

if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {clearLocalCache();
}


在源码分析的最后，我们确认一下，如果是insert/delete/update方法，缓存就会刷新的原因。

SqlSession的insert方法和delete方法，都会统一走update的流程，代码如下所示：

@Overridepublic int insert(String statement, Object parameter) {    return update(statement, parameter);}   @Overridepublic int delete(String statement) {    return update(statement, null);
}


update方法也是委托给了Executor执行。BaseExecutor的执行方法如下所示。

@Overridepublic int update(MappedStatement ms, Object parameter) throws SQLException {ErrorContext.instance().resource(ms.getResource()).activity("executing an update").object(ms.getId());    if (closed) {      throw new ExecutorException("Executor was closed.");}clearLocalCache();    return doUpdate(ms, parameter);
}


每次执行update前都会清空localCache。


至此，一级缓存的工作流程讲解以及源码分析完毕。


小结


  1. MyBatis一级缓存的生命周期和SqlSession一致。

  2. MyBatis一级缓存内部设计简单，只是一个没有容量限定的HashMap，在缓存的功能性上有所欠缺。

  3. MyBatis的一级缓存最大范围是SqlSession内部，有多个SqlSession或者分布式的环境下，数据库写操作会引起脏数据，建议设定缓存级别为Statement。

    

二级缓存


二级缓存介绍


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



二级缓存开启后，同一个namespace下的所有操作语句，都影响着同一个Cache，即二级缓存被多个SqlSession共享，是一个全局的变量。

当开启缓存后，数据的查询执行的流程就是 二级缓存 -> 一级缓存 -> 数据库。


二级缓存配置


要正确的使用二级缓存，需完成如下配置的。

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

    <setting name="cacheEnabled" value="true"/>

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

cache标签用于声明这个namespace使用二级缓存，并且可以自定义配置。

<cache/>

  • type：cache使用的类型，默认是PerpetualCache，这在一级缓存中提到过。

  • eviction： 定义回收的策略，常见的有FIFO，LRU。

  • flushInterval： 配置一定时间自动刷新缓存，单位是毫秒。

  • size： 最多缓存对象的个数。

  • readOnly： 是否只读，若配置可读写，则需要对应的实体类能够序列化。

  • blocking： 若缓存中找不到对应的key，是否会一直blocking，直到有对应的数据进入缓存。


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

<cache-ref namespace="mapper.StudentMapper"/>


二级缓存实验


接下来我们通过实验，了解MyBatis二级缓存在使用上的一些特点。

在本实验中，id为1的学生名称初始化为点点。


实验1


测试二级缓存效果，不提交事务，sqlSession1查询完数据后，sqlSession2相同的查询是否会从缓存中获取数据。

@Testpublic void testCacheWithoutCommitOrClose() throws Exception {SqlSession sqlSession1 = factory.openSession(true); SqlSession sqlSession2 = factory.openSession(true); StudentMapper studentMapper = sqlSession1.getMapper(StudentMapper.class);StudentMapper studentMapper2 = sqlSession2.getMapper(StudentMapper.class);System.out.println("studentMapper读取数据: " + studentMapper.getStudentById(1));System.out.println("studentMapper2读取数据: " + studentMapper2.getStudentById(1));
}


执行结果：


我们可以看到，当sqlsession没有调用commit()方法时，二级缓存并没有起到作用。


实验2


测试二级缓存效果，当提交事务时，sqlSession1查询完数据后，sqlSession2相同的查询是否会从缓存中获取数据。

@Testpublic void testCacheWithCommitOrClose() throws Exception {SqlSession sqlSession1 = factory.openSession(true); SqlSession sqlSession2 = factory.openSession(true); StudentMapper studentMapper = sqlSession1.getMapper(StudentMapper.class);StudentMapper studentMapper2 = sqlSession2.getMapper(StudentMapper.class);System.out.println("studentMapper读取数据: " + studentMapper.getStudentById(1));sqlSession1.commit();System.out.println("studentMapper2读取数据: " + studentMapper2.getStudentById(1));
}


从图上可知，sqlsession2的查询，使用了缓存，缓存的命中率是0.5。


实验3


测试update操作是否会刷新该namespace下的二级缓存。

@Testpublic void testCacheWithUpdate() throws Exception {SqlSession sqlSession1 = factory.openSession(true); SqlSession sqlSession2 = factory.openSession(true); SqlSession sqlSession3 = factory.openSession(true); StudentMapper studentMapper = sqlSession1.getMapper(StudentMapper.class);StudentMapper studentMapper2 = sqlSession2.getMapper(StudentMapper.class);StudentMapper studentMapper3 = sqlSession3.getMapper(StudentMapper.class);System.out.println("studentMapper读取数据: " + studentMapper.getStudentById(1));sqlSession1.commit();System.out.println("studentMapper2读取数据: " + studentMapper2.getStudentById(1));studentMapper3.updateStudentName("方方",1);sqlSession3.commit();System.out.println("studentMapper2读取数据: " + studentMapper2.getStudentById(1));
}



我们可以看到，在sqlSession3更新数据库，并提交事务后，sqlsession2的StudentMapper namespace下的查询走了数据库，没有走Cache。


实验4


验证MyBatis的二级缓存不适应用于映射文件中存在多表查询的情况。

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

@Testpublic void testCacheWithDiffererntNamespace() throws Exception {SqlSession sqlSession1 = factory.openSession(true); SqlSession sqlSession2 = factory.openSession(true); SqlSession sqlSession3 = factory.openSession(true); StudentMapper studentMapper = sqlSession1.getMapper(StudentMapper.class);StudentMapper studentMapper2 = sqlSession2.getMapper(StudentMapper.class);ClassMapper classMapper = sqlSession3.getMapper(ClassMapper.class);System.out.println("studentMapper读取数据: " + studentMapper.getStudentByIdWithClassInfo(1));sqlSession1.close();System.out.println("studentMapper2读取数据: " + studentMapper2.getStudentByIdWithClassInfo(1));classMapper.updateClassName("特色一班",1);sqlSession3.commit();System.out.println("studentMapper2读取数据: " + studentMapper2.getStudentByIdWithClassInfo(1));
}


执行结果：



在这个实验中，我们引入了两张新的表，一张class，一张classroom。class中保存了班级的id和班级名，classroom中保存了班级id和学生id。我们在StudentMapper中增加了一个查询方法getStudentByIdWithClassInfo，用于查询学生所在的班级，涉及到多表查询。在ClassMapper中添加了updateClassName，根据班级id更新班级名的操作。

当sqlsession1的studentmapper查询数据后，二级缓存生效。保存在StudentMapper的namespace下的cache中。当sqlSession3的classMapper的updateClassName方法对class表进行更新时，updateClassName不属于StudentMapper的namespace，所以StudentMapper下的cache没有感应到变化，没有刷新缓存。当StudentMapper中同样的查询再次发起时，从缓存中读取了脏数据。


实验5


为了解决实验4的问题呢，可以使用Cache ref，让ClassMapper引用StudenMapper命名空间，这样两个映射文件对应的Sql操作都使用的是同一块缓存了。

执行结果：



不过这样做的后果是，缓存的粒度变粗了，多个Mapper namespace下的所有操作都会对缓存使用造成影响。


二级缓存源码分析


MyBatis二级缓存的工作流程和前文提到的一级缓存类似，只是在一级缓存处理前，用CachingExecutor装饰了BaseExecutor的子类，在委托具体职责给delegate之前，实现了二级缓存的查询和写入功能，具体类关系图如下图所示。



源码分析


源码分析从CachingExecutor的query方法展开，源代码走读过程中涉及到的知识点较多，不能一一详细讲解，读者朋友可以自行查询相关资料来学习。

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

Cache cache = ms.getCache();


本质上是装饰器模式的使用，具体的装饰链是


SynchronizedCache -> LoggingCache -> SerializedCache -> LruCache -> PerpetualCache。



以下是具体这些Cache实现类的介绍，他们的组合为Cache赋予了不同的能力。

  • SynchronizedCache： 同步Cache，实现比较简单，直接使用synchronized修饰方法。

  • LoggingCache： 日志功能，装饰类，用于记录缓存的命中率，如果开启了DEBUG模式，则会输出命中率日志。

  • SerializedCache： 序列化功能，将值序列化后存到缓存中。该功能用于缓存返回一份实例的Copy，用于保存线程安全。

  • LruCache： 采用了Lru算法的Cache实现，移除最近最少使用的key/value。

  • PerpetualCache： 作为为最基础的缓存类，底层实现比较简单，直接使用了HashMap。


然后是判断是否需要刷新缓存，代码如下所示：

flushCacheIfRequired(ms);


在默认的设置中SELECT语句不会刷新缓存，insert/update/delte会刷新缓存。进入该方法。代码如下所示：

private void flushCacheIfRequired(MappedStatement ms) {Cache cache = ms.getCache();    if (cache != null && ms.isFlushCacheRequired()) {      tcm.clear(cache);}
}


MyBatis的CachingExecutor持有了TransactionalCacheManager，即上述代码中的tcm。

TransactionalCacheManager中持有了一个Map，代码如下所示：

private Map<Cache, TransactionalCache> transactionalCaches = new HashMap<Cache, TransactionalCache>();


这个Map保存了Cache和用TransactionalCache包装后的Cache的映射关系。

TransactionalCache实现了Cache接口，CachingExecutor会默认使用他包装初始生成的Cache，作用是如果事务提交，对缓存的操作才会生效，如果事务回滚或者不提交事务，则不对缓存产生影响。

在TransactionalCache的clear，有以下两句。清空了需要在提交时加入缓存的列表，同时设定提交时清空缓存，代码如下所示：

@Overridepublic void clear() {clearOnCommit = true;entriesToAddOnCommit.clear();
}


CachingExecutor继续往下走，ensureNoOutParams主要是用来处理存储过程的，暂时不用考虑。

if (ms.isUseCache() && resultHandler == null) {ensureNoOutParams(ms, parameterObject, boundSql);


之后会尝试从tcm中获取缓存的列表。

List<E> list = (List<E>) tcm.getObject(cache, key);


在getObject方法中，会把获取值的职责一路传递，最终到PerpetualCache。如果没有查到，会把key加入Miss集合，这个主要是为了统计命中率。

Object object = delegate.getObject(key);if (object == null) {entriesMissedInCache.add(key);
}


CachingExecutor继续往下走，如果查询到数据，则调用tcm.putObject方法，往缓存中放入值。

if (list == null) {list = delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);tcm.putObject(cache, key, list); // issue #578 and #116}


tcm的put方法也不是直接操作缓存，只是在把这次的数据和key放入待提交的Map中。

@Overridepublic void putObject(Object key, Object object) {entriesToAddOnCommit.put(key, object);
}


从以上的代码分析中，我们可以明白，如果不调用commit方法的话，由于TranscationalCache的作用，并不会对二级缓存造成直接的影响。因此我们看看Sqlsession的commit方法中做了什么。代码如下所示：

@Overridepublic void commit(boolean force) {    try {executor.commit(isCommitOrRollbackRequired(force));


因为我们使用了CachingExecutor，首先会进入CachingExecutor实现的commit方法。

@Overridepublic void commit(boolean required) throws SQLException {delegate.commit(required);tcm.commit();
}


会把具体commit的职责委托给包装的Executor。主要是看下tcm.commit()，tcm最终又会调用到TrancationalCache。

public void commit() {    if (clearOnCommit) {delegate.clear();}flushPendingEntries();reset();
}


看到这里的clearOnCommit就想起刚才TrancationalCache的clear方法设置的标志位，真正的清理Cache是放到这里来进行的。具体清理的职责委托给了包装的Cache类。之后进入flushPendingEntries方法。代码如下所示：

private void flushPendingEntries() {    for (Map.Entry<Object, Object> entry : entriesToAddOnCommit.entrySet()) {delegate.putObject(entry.getKey(), entry.getValue());}................
}


在flushPendingEntries中，将待提交的Map进行循环处理，委托给包装的Cache类，进行putObject的操作。

后续的查询操作会重复执行这套流程。如果是insert|update|delete的话，会统一进入CachingExecutor的update方法，其中调用了这个函数，代码如下所示：

private void flushCacheIfRequired(MappedStatement ms)


在二级缓存执行流程后就会进入一级缓存的执行流程，因此不再赘述。


小结


  1. MyBatis的二级缓存相对于一级缓存来说，实现了SqlSession之间缓存数据的共享，同时粒度更加的细，能够到namespace级别，通过Cache接口实现类不同的组合，对Cache的可控性也更强。

  2. MyBatis在多表查询时，极大可能会出现脏数据，有设计上的缺陷，安全使用二级缓存的条件比较苛刻。

  3. 在分布式环境下，由于默认的MyBatis Cache实现都是基于本地的，分布式环境下必然会出现读取到脏数据，需要使用集中式缓存将MyBatis的Cache接口实现，有一定的开发成本，直接使用Redis,Memcached等分布式缓存可能成本更低，安全性也更高。


全文总结


本文对介绍了MyBatis一二级缓存的基本概念，并从应用及源码的角度对MyBatis的缓存机制进行了分析。最后对MyBatis缓存机制做了一定的总结，个人建议MyBatis缓存特性在生产环境中进行关闭，单纯作为一个ORM框架使用可能更为合适。



本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/331088.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

maven(6)仓库

maven(6)仓库

【0】README1&#xff09;本文部分文字转自 “maven实战”&#xff0c;旨在 review “maven(6)仓库” 的相关知识&#xff1b; 【1】何为 Maven仓库1&#xff09;intro to 构件&#xff1a;在maven中&#xff0c;任何一个依赖&#xff0c;插件或者项目构建的输出&#xff0c;都…
阅读更多...
防止用户重复提交表单数据，session方式，js方式

防止用户重复提交表单数据，session方式，js方式

1. 使用session的方式创建Token令牌解决 创建一个生成令牌的工具类&#xff0c;在该类中有返回类的对象&#xff0c;生成token的方法public class TokenUtil {/**单例设计模式&#xff08;保证类的对象在内存中只有一个&#xff09;*1、把类的构造函数私有*2、自己创建一个类的…
阅读更多...
mybatis_user_guide(3)XML配置

mybatis_user_guide(3)XML配置

【-1】README1&#xff09;本文全文总结于 http://www.mybatis.org/mybatis-3/zh/configuration.html#environments【0】MyBatis 的配置文件包含了影响 MyBatis 行为甚深的设置&#xff08;settings&#xff09;和属性&#xff08;properties&#xff09;信息。文档的顶层结构如…
阅读更多...
easyUI 运用窗口和form表单制作导出功能

easyUI 运用窗口和form表单制作导出功能

这里运用到easyUI的窗口模式和form表单的提交制作一个有条件的导出excel数据统计的功能&#xff0c;主要是知道了怎么运用easyUI的窗口和表单 jsp中&#xff1a;<!-- 导出数据来源条件窗口 --><div id"exportSign" ><form id"condition" me…
阅读更多...
分布式一致性算法：可能比你想象得更复杂

分布式一致性算法：可能比你想象得更复杂

转载自 分布式一致性算法&#xff1a;可能比你想象得更复杂分布式系统的难题张大胖遇到了一个难题。他们公司的有个服务器&#xff0c;上面保存着宝贵的数据&#xff0c;领导Bill 为了防止它挂掉&#xff0c; 要求张大胖想想办法把数据做备份。张大胖发挥了抽象的能力&#xff…
阅读更多...
mybatis_user_guide(4) Mapper XML 文件

mybatis_user_guide(4) Mapper XML 文件

【-1】README 1&#xff09;本文全文总结于 http://www.mybatis.org/mybatis-3/zh/sqlmap-xml.html【0】SQL 映射文件有很少的几个顶级元素&#xff08;按照它们应该被定义的顺序&#xff09;&#xff1a; cache – 给定命名空间的缓存配置。cache-ref – 其他命名空间缓存配置…
阅读更多...
Hibernate关联关系配置(一对多、一对一和多对多)

Hibernate关联关系配置(一对多、一对一和多对多)

第一种关联关系&#xff1a;一对多&#xff08;多对一&#xff09; “一对多”是最普遍的映射关系&#xff0c;简单来讲就如消费者与订单的关系。 一对多&#xff1a;从消费者角的度来说一个消费者可以有多个订单&#xff0c;即为一对多。 多对一&#xff1a;从订单的角度来…
阅读更多...
3分钟了解“关联规则”推荐

3分钟了解“关联规则”推荐

转载自 3分钟了解“关联规则”推荐 “把啤酒放在尿布旁&#xff0c;有助于提升啤酒销售量”是关联规则推荐的经典案例&#xff0c;今天&#xff0c;和大家聊聊“关联规则推荐”&#xff0c;正文不含任何公式&#xff0c;保证PM弄懂。一、概念 什么是关联规则&#xff08;Associ…
阅读更多...
mybatis_user_guide(5) 动态 SQL

mybatis_user_guide(5) 动态 SQL

【-1】README 1&#xff09;本文全文总结于 http://www.mybatis.org/mybatis-3/zh/dynamic-sql.html 【0】动态 SQL 元素和使用 JSTL 或其他类似基于 XML 的文本处理器相似。在 MyBatis 之前的版本中,有很多的元素需要来了解。MyBatis 3 大大提升了它们,现在用不到原先一半的元…
阅读更多...
sqlserver还原差异备份

sqlserver还原差异备份

因为之前遇到还原差异备份&#xff0c;最开始遇到SQLServer报错&#xff1a;”无法还原日志备份或差异备份&#xff0c;因为没有文件可用于前滚“。查阅很多资料后&#xff0c;终于得到解决。收集整理成这篇随笔。　　 问题原因&#xff1a;出现这种错误绝大多数是因为还原完整…
阅读更多...
1分钟了解相似性推荐

1分钟了解相似性推荐

转载自 1分钟了解相似性推荐前几天聊的“协同过滤&#xff08;Collaborative Filtering&#xff09;”和“基于内容的推荐&#xff08;Content-based Recommendation&#xff09;”&#xff0c;都必须分析用户的历史行为数据&#xff08;例如电影点击数据&#xff0c;职位查看数…
阅读更多...
mybatis_user_guide(6) Java API

mybatis_user_guide(6) Java API

【0】README1&#xff09;本文全文总结于 http://www.mybatis.org/mybatis-3/zh/java-api.html【1】SqlSessions1)intro&#xff1a;　我们知道&#xff0c; SqlSessionFactoryBuilder 创建 SqlSessionFactory &#xff0c; SqlSessionFactory 创建 SqlSession&#xff0c;然后…
阅读更多...
hibernate左连接查询时在easyUI的dataGrid中有些行取值为空的解决办法

hibernate左连接查询时在easyUI的dataGrid中有些行取值为空的解决办法

1 当使用left join左连连接&#xff0c;sql语句为 select t from SecondPage t left join t.rightNavbar n where 11 页面中出现了部分空行的情况&#xff0c;上述语句返回的list集合为 DataGrid dataGrid new DataGrid(); List<SecondPage> listsecondPageDao.find(…
阅读更多...
1分钟了解基于内容的推荐，pm又懂了

1分钟了解基于内容的推荐，pm又懂了

转载自 1分钟了解基于内容的推荐&#xff0c;pm又懂了什么是基于内容的推荐&#xff08;Content-based Recommendation&#xff09;&#xff1f; 答&#xff1a;通过用户历史感兴趣的信息&#xff0c;抽象信息内容共性&#xff0c;根据内容共性推荐其他信息。比如&#xff0c;如…
阅读更多...
mybatis_user_guide(7) SQL语句构建器类

mybatis_user_guide(7) SQL语句构建器类

【0】README1&#xff09;本文全文总结于 http://www.mybatis.org/mybatis-3/zh/statement-builders.html【1】在Java代码中来动态生成SQL代码就是一场噩梦1&#xff09;problemsolutions&#xff1a;1.1&#xff09;problem&#xff1a;Java程序员面对的最痛苦的事情之一就是…
阅读更多...
datagrid获取页面总记录数的方法,datagrid获取页面总记录数为0的解决方法

datagrid获取页面总记录数的方法,datagrid获取页面总记录数为0的解决方法

1 在网上查了一大堆博客&#xff0c;都只有下面这一段&#xff0c;也不知道这些人有没有测试 var data$(#tt).datagrid(getData); alert(总数据量:data.total)//注意你的数据源一定要定义了total&#xff0c;要不会为undefined&#xff0c;datagrid分页就是靠这个total定义 al…
阅读更多...
1分钟了解协同过滤，pm都懂了

1分钟了解协同过滤，pm都懂了

转载自 1分钟了解协同过滤&#xff0c;pm都懂了工程架构方向的程序员&#xff0c;看到推荐/搜索/广告等和算法相关的技术&#xff0c;心中或多或少有一丝胆怯。但认真研究之后&#xff0c;发现其实没有这么难。今天的1分钟系列&#xff0c;给大家介绍下推荐系统中的“协同过滤”…
阅读更多...
mybatis_user_guide(8) 日志

mybatis_user_guide(8) 日志

【0】README 1&#xff09;本文全文总结于 http://www.mybatis.org/mybatis-3/zh/logging.html 2&#xff09;Mybatis内置的日志工厂提供日志功能&#xff0c;具体的日志实现有以下几种工具&#xff1a; SLF4JApache Commons LoggingLog4j 2Log4jJDK logging 3&#xff09;具体…
阅读更多...
hibernate在saveOrUpdate时，update报错：a different object with the same identifier value was already assoc

hibernate在saveOrUpdate时，update报错：a different object with the same identifier value was already assoc

1 原因&#xff1a;网上说是&#xff0c;在hibernate中同一个session里面有了两个相同标识但是是不同实体。 2 我找出的解决方法是&#xff1a; getSession().clear(); //在dao层把session清理一下 3 网上查找出还有其他解决方法&#xff0c;其中 getSession().merge(arg0…
阅读更多...
1分钟了解区块链的本质

1分钟了解区块链的本质

转载自 1分钟了解区块链的本质区块链&#xff0c;比特币这些概念最近都很火&#xff0c;但很多人搞不清楚它究竟是啥&#xff0c;准备从技术的角度&#xff0c;从架构的角度&#xff0c;用通俗的语言谈谈楼主的理解。究竟啥是区块链&#xff1f;答&#xff1a;一句话&#xff0…
阅读更多...
最新文章

Copyright @ 2022~2023