Mybatis工作机制源码分析—缓存机制及事务机制

最新推荐文章于 2023-04-20 13:56:04 发布
最新推荐文章于 2023-04-20 13:56:04 发布
阅读量977 收藏
点赞数
分类专栏： mybatis 文章标签： Mybatis 源码分析 workflow 事务 缓存机制
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Architect0719/article/details/54558145
版权

        本文主要以源码分析的角度分析Mybatis的缓存工作机制及事务机制。

缓存工作机制

整体设计图

         网上一张关于Mybatis的缓存工作机制示意图：


Cache类结构图


相关源码

         二级缓存处理主要体现在CachingExecutor；一级缓存处理主要体现在BaseExecutor，其带localCache、localOutputParameterCache本地缓存，它们都是PerpetualCache，而PerpetualCache本质上为包装的HashMap<Object, Object>版本。下面从update、select请求处理分别分析缓存的工作机制：

启用二级缓存（一级缓存直接使用）

/** Configuration.java */
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);
	}
	// 在Mybatis config配置文件中，配置<setting name="cacheEnabled" value="true"/>，打开二级缓存
	// 二级缓存可细粒度到mapper配置文件中的每条sql语句，useCache="true"则表示该sql语句使用二级缓存
	if (cacheEnabled) {
	  // 装饰CachingExecutor
	  executor = new CachingExecutor(executor);
	}
	executor = (Executor) interceptorChain.pluginAll(executor);
	return executor;
}

处理update请求过程中缓存工作机制

       update的二级缓存处理：sql语句设置flushCache="true"，则清空当前cache对应的TransactionalCache；update的一级缓存处理，清空本地缓存：

/** CachingExecutor.java */
// CachingExecutor update
// CachingExecutor用TransactionalCacheManager，进行TransactionalCache层的管理
public int update(MappedStatement ms, Object parameterObject) throws SQLException {
	// update的二级缓存处理
	flushCacheIfRequired(ms);
	return delegate.update(ms, parameterObject);
}

// flush MappedStatement cache
private void flushCacheIfRequired(MappedStatement ms) {
	Cache cache = ms.getCache();
	if (cache != null && ms.isFlushCacheRequired()) {   
	  // sql语句配置了flushCache="true"，则进行当前cache对应的TransactionalCache clear工作
	  tcm.clear(cache);
	}
}

/** TransactionalCacheManager.java */
public void clear(Cache cache) {
	getTransactionalCache(cache).clear();
}

private TransactionalCache getTransactionalCache(Cache cache) {
	TransactionalCache txCache = transactionalCaches.get(cache);
	if (txCache == null) {
	  txCache = new TransactionalCache(cache);
	  transactionalCaches.put(cache, txCache);
	}
	return txCache;
}

/** TransactionalCache.java */
// clearOnCommit标识设置为true
// entriesToAddOnCommit清空
public void clear() {
	clearOnCommit = true;
	entriesToAddOnCommit.clear();
}

/** BaseExecutor.java(SimpleExecutor) */
public 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.");
	}
	// update的一级缓存处理
	// 清空BaseExecutor下的localCache、localOutputParameterCache，其均为PerpetualCache
	// PerpetualCache实际缓存为HashMap<Object, Object>
	clearLocalCache();
	return doUpdate(ms, parameter);
}

public void clearLocalCache() {
	if (!closed) {
	  localCache.clear();
	  localOutputParameterCache.clear();
	}
}

处理select请求过程中缓存工作机制

       构建CacheKey，select二级缓存处理：从缓存中获取相关结果，一般select语句配置flushCache="false"，否则二级缓存返回null，如果一级缓存返回有结果，则将结果保存到二级缓存TransactionalCache；select一级缓存处理：从缓存中获取结果，有则缓存输出参数到localOutputParameterCache，否则，从database获取结果，进行一级缓存到localCache、localOutputParameterCache：

/** CachingExecutor.java */
public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
	// MappedStatement构建BoundSql，实际用DynamicSqlSource或StaticSqlSource构建BoundSql
	BoundSql boundSql = ms.getBoundSql(parameterObject);
	// 构建CacheKey（同一次缓存，二级缓存key与一级缓存key相同）
	CacheKey key = createCacheKey(ms, parameterObject, rowBounds, boundSql);
	return query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
}

/** CachingExecutor.java */
public CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql) {
	return delegate.createCacheKey(ms, parameterObject, rowBounds, boundSql);
}

/** BaseExecutor.java */
// 创建CacheKey，用MappedStatement、parameterObject、rowBounds、boundSql影响CacheKey的hashCode
public CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql) {
	if (closed) {
		throw new ExecutorException("Executor was closed.");
	}
	CacheKey cacheKey = new CacheKey();
	// cacheKey关联MappedStatement id
	cacheKey.update(ms.getId());
	// cacheKey关联rowBounds offset
	cacheKey.update(Integer.valueOf(rowBounds.getOffset()));
	// cacheKey关联Offset limit
	cacheKey.update(Integer.valueOf(rowBounds.getLimit()));
	// cacheKey关联boundSql sql
	cacheKey.update(boundSql.getSql());
	List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
	TypeHandlerRegistry typeHandlerRegistry = ms.getConfiguration().getTypeHandlerRegistry();
	// mimic DefaultParameterHandler logic
	for (int i = 0; i < parameterMappings.size(); i++) {
		ParameterMapping parameterMapping = parameterMappings.get(i);
		if (parameterMapping.getMode() != ParameterMode.OUT) {
			Object value;
			String propertyName = parameterMapping.getProperty();
			if (boundSql.hasAdditionalParameter(propertyName)) {
				value = boundSql.getAdditionalParameter(propertyName);
			} else if (parameterObject == null) {
				value = null;
			} else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
				value = parameterObject;
			} else {
				MetaObject metaObject = configuration.newMetaObject(parameterObject);
				value = metaObject.getValue(propertyName);
			}
			// cacheKey关联parameterMapping value
			cacheKey.update(value);
		}
	}
	if (configuration.getEnvironment() != null) {
		// cacheKey关联environment id
		cacheKey.update(configuration.getEnvironment().getId());
	}
	return cacheKey;
}    

/** CachingExecutor.java */
public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)
  throws SQLException {
	Cache cache = ms.getCache();
	if (cache != null) {
		// select二级缓存处理，同update二级缓存处理
		flushCacheIfRequired(ms);
		if (ms.isUseCache() && resultHandler == null) {
			ensureNoOutParams(ms, parameterObject, boundSql);
			@SuppressWarnings("unchecked")
			// 从二级缓存cache中获取，如果sql语句配置了flushCache="true"，则获取为null
			// 因为flushCacheIfRequired已经将clearOnCommit设置为true
			// 所以一般select语句配置flushCache="false"
			List<E> list = (List<E>) tcm.getObject(cache, key);
			if (list == null) {
				list = delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
				// 获取结果保存到二级缓存TransactionalCache
				tcm.putObject(cache, key, list); // issue #578 and #116
			}
			return list;
		}
	}
	return delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
}

/** BaseExecutor.java */
public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
	ErrorContext.instance().resource(ms.getResource()).activity("executing a query").object(ms.getId());
	if (closed) {
		throw new ExecutorException("Executor was closed.");
	}
	if (queryStack == 0 && ms.isFlushCacheRequired()) {
		clearLocalCache();
	}
	List<E> list;
	try {
		queryStack++;
		// select一级缓存处理
		// 查看本地缓存，有则直接返回
		list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;
		if (list != null) {
			// 处理本地缓存的输出参数
			handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
		} else {
			// 没有则继续从Database查询
			list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
		}
	} finally {
		queryStack--;
	}
	if (queryStack == 0) {
		for (DeferredLoad deferredLoad : deferredLoads) {
			deferredLoad.load();
		}
		// issue #601
		deferredLoads.clear();
		if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
			// MappedStatement级别的缓存，则清空本地缓存
			clearLocalCache();
		}
	}
	return list;
}

private void handleLocallyCachedOutputParameters(MappedStatement ms, CacheKey key, Object parameter, BoundSql boundSql) {
	if (ms.getStatementType() == StatementType.CALLABLE) {
		final Object cachedParameter = localOutputParameterCache.getObject(key);
		if (cachedParameter != null && parameter != null) {
			final MetaObject metaCachedParameter = configuration.newMetaObject(cachedParameter);
			final MetaObject metaParameter = configuration.newMetaObject(parameter);
			for (ParameterMapping parameterMapping : boundSql.getParameterMappings()) {
				if (parameterMapping.getMode() != ParameterMode.IN) {
					final String parameterName = parameterMapping.getProperty();
					final Object cachedValue = metaCachedParameter.getValue(parameterName);
					metaParameter.setValue(parameterName, cachedValue);
				}
			}
		}
	}
}

private <E> List<E> queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
	List<E> list;
	localCache.putObject(key, EXECUTION_PLACEHOLDER);
	try {
		// 从Database查询
		list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql);
	} finally {
		// 清空本地之前CacheKey对应的缓存
		localCache.removeObject(key);
	}
	// 将查询结果key——list缓存到localCache
	localCache.putObject(key, list);
	if (ms.getStatementType() == StatementType.CALLABLE) {
		// 将key——parameter缓存到localOutputParameterCache
		localOutputParameterCache.putObject(key, parameter);
	}
	return list;
}

事务工作机制

      一般Mybatis与Spring集成使用，这样Mybatis的事务管理工作交给Spring，事务管理工作对Mybatis是透明的。

Spring事务管理相关了解

        事务隔离级别：

隔离级别是指若干个并发的事务之间的隔离程度。TransactionDefinition 接口中定义了五个表示隔离级别的常量：

TransactionDefinition.ISOLATION_DEFAULT：这是默认值，表示使用底层数据库的默认隔离级别。对大部分数据库而言，通常这值就是TransactionDefinition.ISOLATION_READ_COMMITTED。

TransactionDefinition.ISOLATION_READ_UNCOMMITTED：该隔离级别表示一个事务可以读取另一个事务修改但还没有提交的数据。该级别不能防止脏读，不可重复读和幻读，因此很少使用该隔离级别。比如PostgreSQL实际上并没有此级别。

TransactionDefinition.ISOLATION_READ_COMMITTED：该隔离级别表示一个事务只能读取另一个事务已经提交的数据。该级别可以防止脏读，这也是大多数情况下的推荐值。

TransactionDefinition.ISOLATION_REPEATABLE_READ：该隔离级别表示一个事务在整个过程中可以多次重复执行某个查询，并且每次返回的记录都相同。该级别可以防止脏读和不可重复读。

TransactionDefinition.ISOLATION_SERIALIZABLE：所有的事务依次逐个执行，这样事务之间就完全不可能产生干扰，也就是说，该级别可以防止脏读、不可重复读以及幻读。但是这将严重影响程序的性能。通常情况下也不会用到该级别。

        事务传播行为：

所谓事务的传播行为是指，如果在开始当前事务之前，一个事务上下文已经存在，此时有若干选项可以指定一个事务性方法的执行行为。在TransactionDefinition定义中包括了如下几个表示传播行为的常量：

TransactionDefinition.PROPAGATION_REQUIRED：如果当前存在事务，则加入该事务；如果当前没有事务，则创建一个新的事务。这是默认值。

TransactionDefinition.PROPAGATION_REQUIRES_NEW：创建一个新的事务，如果当前存在事务，则把当前事务挂起。

TransactionDefinition.PROPAGATION_SUPPORTS：如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务的方式继续运行。

TransactionDefinition.PROPAGATION_NOT_SUPPORTED：以非事务方式运行，如果当前存在事务，则把当前事务挂起。

TransactionDefinition.PROPAGATION_NEVER：以非事务方式运行，如果当前存在事务，则抛出异常。

TransactionDefinition.PROPAGATION_MANDATORY：如果当前存在事务，则加入该事务；如果当前没有事务，则抛出异常。

TransactionDefinition.PROPAGATION_NESTED：如果当前存在事务，则创建一个事务作为当前事务的嵌套事务来运行；如果当前没有事务，则该取值等价于TransactionDefinition.PROPAGATION_REQUIRED。

@Transactional注解


Architect0719
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
MyBatis缓存Cache源码分析
finalcola的博客
07-23 2452
一、缓存接口介绍 MyBatis的一级缓存和二级缓存都是使用的Cache接口实现类，它的方法定义如下： public interface Cache { String getId(); void putObject(Object key, Object value); Object getObject(Object key); Object removeObject...
Mybatis源码细节探究：MappedStatement和Cache对象对照关系研究
热门推荐
七叔的博客
05-30 1万+
Mybatis源码细节探究：MappedStatement和Cache对象对照关系研究
Mybatis——Mybatis表之间的关联关系和事务、缓存机制以及ORM
weixin_44606952的博客
08-31 925
1. 表之间的关联关系 1.1 一对多的关联 1.2 多对一的关联 1.3 多对多的关联 1.4 一对一的关联 2. Mybatis知识点小结 2.1 事务 2.2 缓存机制 2.2.1 缓存执行机制 2.2.2 一级缓存 2.3 ORM
踩坑引出Mybatis的缓存机制
AcStudio的博客
11-29 214
问题引出 今天在做数据库的增删改查的时候，突然发现删除的数据行，子啊select之后还是会存在 找了找百度 发现罪魁祸首就是Mybatis的缓存机制搞的事情 什么是Mybatis缓存机制 缓存是一般的ORM 框架都会提供的功能，目的就是提升查询的效率和减少数据库的压力。跟Hibernate 一样，MyBatis 也有一级缓存和二级缓存，并且预留了集成第三方缓存的接口。 mybatis的缓存机制分为两个等级 一级缓存 一级缓存也叫本地缓存，MyBatis 的一级缓存是在会话（SqlSession
Mybatis 的工作流程及原理
m0_69804655的博客
04-20 739
MyBatis 是一款优秀的持久层框架，它支持定制化 SQL、存储过程及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数及获取结果集。MyBatis 可以使用简单的 XML 或注解来配置和映射原生信息，将接口和 Java 的 POJOs(普通的 Java 对象)映射成数据库中的记录。
Mybatis源码分析.pdf
08-30
总结起来，MyBatis源码分析涵盖了从配置加载到数据库操作的全过程，涉及到了配置解析、SQL执行、结果映射等多个关键环节，以及Executor、StatementHandler等核心组件。通过深入学习MyBatis的源码，开发者不仅可以...
mybatis源码分析视频
02-19
本资源“mybatis源码分析视频”是针对MyBatis框架进行深入剖析的教程，通过视频和文档的形式帮助学习者理解其内部工作机制。 1. **MyBatis简介** MyBatis消除了几乎所有的JDBC代码和手动设置参数以及获取结果集。...
mybatis:mybatis源码分析
03-24
通过对MyBatis源码的深入分析，我们可以更清晰地理解其实现原理，更好地利用其特性，甚至定制自己的持久层解决方案。在阅读源码的过程中，还可以学习到设计模式、反射、AOP等Java编程技术，提升我们的编程能力。
Mybatis源码分析.docx
05-23
Mybatis源码分析 Mybatis是一款流行的持久层框架，它提供了一个强大的机制来简化Java应用程序中的数据库交互。Mybatis的核心概念包括Configuration、SqlSessionFactory、Session、Executor、MappedStatement、...
【mybatis原理工作原理】
qq_33700648的博客
04-26 1297
文章目录mybatis原理： mybatis原理： mybatis的工作原理就是：先封装sql，接着调用jdbc操作数据库，最后把数据库返回的表结果封装成java类。 通过代码实现jdbc查询操作： mybatis-config.xml类 <?xml version="1.0" encoding="utf-8"?> <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://myba
MyBatis 工作原理和详解
09-29
MyBatis是一个持久层框架,是apache下的顶级项目。 Mybatis托管到goolecode下，后来又托管到GitHub。 MyBatis让程序员主要精力都集中到sql上，通过mybatis提供的映射方式，自由灵活生成（半自动化，大部分需要程序员编写sql语句）满足需要的sql语句。 MyBatis可以将查询结果集灵活映射成java对象。
MyBatis源码学习（七）——从源码看MyBatis如何使用缓存
lkforce
12-27 1141
目录 前言和总纲 一，创建SqlSession 二，创建CacheKey 三，执行sql 四，sqlSession的提交 先上总结： 1，创建sqlSession阶段。创建Executor执行器，其中有两个参数，localCache和localOutputParameterCache，localCache是一级缓存，localOutputParameterCache用于缓存存储过程的OUT和INOUT参数。Executor执行器首先会被CachingExecutor装饰，然后又被插件列表.
Mybatis搞五下（分页、缓存）
Nicer_feng's blog
09-28 696
上篇博客我们讲了动态SQL，一一多多和延迟加载问题，这篇我们讲点轻松的东西，关于分页插件pageHelper和Mybatis面试常问的缓存问题。
Mybatis缓存(三)-一级缓存实现原理
星光之子的博客
09-07 330
一级缓存实现原理BaseExecutor类 MyBatis的一级缓存是SqlSession级别的缓存，SqlSession提供了面向用户的API，但是真正执行SQL操作的是Executor组件 Executor采用模板方法设计模式，BaseExecutor类用于处理一些通用的逻辑，其中一级缓存相关的逻辑就是在BaseExecutor类中完成的 一级缓存使用PerpetualCache来实现 BaseExecutor类 在BaseExecutor类中维护了两个PerpetualCache属性 protec
Mybatis源码解析之缓存机制（一）：一级缓存
翻身已碰头的博客
03-16 684
Mybatis源码解析之核心类分析 Mybatis源码解析之初始化分析 Mybatis源码解析之执行流程解析 Mybatis源码解析之数据库连接和连接池 Mybatis源码解析之事务管理 一、CacheKey CacheKey是每次查询操作的特征值抽象而成的类，用于区别查询是否相同，从而从cache中找到对应的结果。 当下列元素相同时，我们认为是相同的查询。 （1）statementId （2）要...
Mybatis一级缓存介绍（LocalCache）
weixin_42243889的博客
12-01 816
Mybatis一级缓存介绍（LocalCache） 1缓存的创建 1.1 createCacheKey创建的执行流程 1.2源码分析 在执行BaseExecutor.query的方法中首先判断ResultHandler是否为空，ResultHandler对返回的结果处理，无返回接口为空；当第一次进行查询缓存值为空执行2处方法，在4处需要先进行占位，主要是解决嵌套查询。当标记操作sql的操作对象为CALLABLE是会创建出参缓存localOutputParameterCache 1.3 LocalCac
MyBatis工作原理
ThinkWon的博客
09-24 8164
在学习 MyBatis 程序之前，需要了解一下 MyBatis 工作原理，以便于理解程序。MyBatis 的工作原理如下图 1）读取 MyBatis 配置文件：mybatis-config.xml 为 MyBatis 的全局配置文件，配置了 MyBatis 的运行环境等信息，例如数据库连接信息。 2）加载映射文件。映射文件即 SQL 映射文件，该文件中配置了操作数据库的 SQL 语句，需要在 M...
python字典均值_Python中Redis的服务器辅助客户端缓存
weixin_39968309的博客
11-18 126
众所周知，计算机科学中只有两个难题：缓存失效和命名。这篇文章，正如你从它的名字中猜到的，是关于第一个问题：缓存失效问题。我写这篇文章是因为Redis 6中的一个新特性使客户端更容易管理本地缓存。这个小项目的源文件可以在rsacsc-py库中找到。前言我不打算强调缓存本身的重要性。实际上，我们在计算机工程的各个方面都在缓存数据，以减少随后访问数据所需的时间。我们使用多级缓存，并将继续这样做，直到有人...
Mybatis源码分析之Cache一级缓存原理（四）
weixin_34144848的博客
01-13 74
之前的文章我已经基本讲解到了SqlSessionFactory、SqlSession、Excutor以及Mpper执行SQL过程，下面我来了解下myabtis的缓存，它的缓存分为一级缓存和二级缓存，本文我们主要分析下一级缓存。先看一个例子，代码还是之前（第一篇）的的demo    public static void main(String[] args) throws Exception {  ...
mybatis-plus 缓存(二)
最新发布
07-22
Mybatis-Plus 缓存机制详解 Mybatis-Plus 缓存机制是 Mybatis 的一个重要组件，它可以大幅度提高系统的查询效率，解决高并发系统的性能问题。在本文中，我们将详细介绍 Mybatis-Plus 缓存机制的原理、配置和使用。 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值