【源码级】MyBatis缓存策略(mybatisplus缓存)

  本篇文章为你整理了【源码级】MyBatis缓存策略(mybatisplus缓存)的详细内容,包含有mybatis-plus缓存 mybatisplus缓存 mybaties缓存机制 mybatis缓存作用域 【源码级】MyBatis缓存策略,希望能帮助你了解 【源码级】MyBatis缓存策略。

  缓存就是内存中的数据,常常来自对数据库查询结果的保存。使用缓存,我们可以避免频繁的与数据库进行交互,进而提高响应速度MyBatis也提供了对缓存的支持,分为一级缓存和二级缓存,可以通过下图来理解:

  
 

  ①、一级缓存是SqlSession级别的缓存。在操作数据库时需要构造sqlSession对象,在对象中有一个数据结构(HashMap)用于存储缓存数据。不同的sqlSession之间的缓存数据区域(HashMap)是互相不影响的。

  ②、二级缓存是mapper级别的缓存,多个SqlSession去操作同一个Mapper的sql语句,多个SqlSession可以共用二级缓存,二级缓存是跨SqlSession的

  默认是开启的

  ①、我们使用同一个sqlSession,对User表根据相同id进行两次查询,查看他们发出sql语句的情况

  

 @Test

 

   public void firstLevelCacheTest() throws IOException {

   // 1. 通过类加载器对配置文件进行加载,加载成了字节输入流,存到内存中 注意:配置文件并没有被解析

   InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");

   // 2. (1)解析了配置文件,封装configuration对象 (2)创建了DefaultSqlSessionFactory工厂对象

   SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);

   // 3.问题:openSession()执行逻辑是什么?

   // 3. (1)创建事务对象 (2)创建了执行器对象cachingExecutor (3)创建了DefaultSqlSession对象

   SqlSession sqlSession = sqlSessionFactory.openSession();

   // 4. 委派给Executor来执行,Executor执行时又会调用很多其他组件(参数设置、解析sql的获取,sql的执行、结果集的封装)

   User user = sqlSession.selectOne("com.itheima.mapper.UserMapper.findByCondition", 1);

   User user2 = sqlSession.selectOne("com.itheima.mapper.UserMapper.findByCondition", 1);

   System.out.println(user == user2);

   sqlSession.close();

  

 

  查看控制台打印情况:

  ② 同样是对user表进行两次查询,只不过两次查询之间进行了一次update操作。

  

 @Test

 

   public void test3() throws IOException {

   // 1. 通过类加载器对配置文件进行加载,加载成了字节输入流,存到内存中 注意:配置文件并没有被解析

   InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");

   // 2. (1)解析了配置文件,封装configuration对象 (2)创建了DefaultSqlSessionFactory工厂对象

   SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);

   // 3.问题:openSession()执行逻辑是什么?

   // 3. (1)创建事务对象 (2)创建了执行器对象cachingExecutor (3)创建了DefaultSqlSession对象

   SqlSession sqlSession = sqlSessionFactory.openSession();

   // 4. 委派给Executor来执行,Executor执行时又会调用很多其他组件(参数设置、解析sql的获取,sql的执行、结果集的封装)

   User user = sqlSession.selectOne("com.itheima.mapper.UserMapper.findByCondition", 1);

   User user1 = new User();

   user1.setId(1);

   user1.setUsername("zimu");

   sqlSession.update("com.itheima.mapper.UserMapper.updateUser",user1);

   sqlSession.commit();

   User user2 = sqlSession.selectOne("com.itheima.mapper.UserMapper.findByCondition", 1);

   System.out.println(user == user2);

   System.out.println(user);

   System.out.println(user2);

   System.out.println("MyBatis源码环境搭建成功....");

   sqlSession.close();

  

 

  查看控制台打印情况:

  ③、总结

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

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

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

  一级缓存原理探究与源码分析

  问题1:一级缓存 底层数据结构到底是什么?

  问题2:一级缓存的工作流程是怎样的?

  一级缓存 底层数据结构到底是什么?

  之前说不同SqlSession的一级缓存互不影响,所以我从SqlSession这个类入手

  
 

  可以看到,org.apache.ibatis.session.SqlSession中有一个和缓存有关的方法——clearCache()刷新缓存的方法,点进去,找到它的实现类DefaultSqlSession

  

 @Override

 

   public void clearCache() {

   executor.clearLocalCache();

  

 

  再次点进去executor.clearLocalCache(),再次点进去并找到其实现类BaseExecutor,

  

 @Override

 

   public void clearLocalCache() {

   if (!closed) {

   localCache.clear();

   localOutputParameterCache.clear();

  

 

  进入localCache.clear()方法。进入到了org.apache.ibatis.cache.impl.PerpetualCache类中

  

package org.apache.ibatis.cache.impl;

 

  import java.util.HashMap;

  import java.util.Map;

  import java.util.concurrent.locks.ReadWriteLock;

  import org.apache.ibatis.cache.Cache;

  import org.apache.ibatis.cache.CacheException;

   * @author Clinton Begin

  public class PerpetualCache implements Cache {

   private final String id;

   private Map Object, Object cache = new HashMap Object, Object

   public PerpetualCache(String id) {

   this.id = id;

   //省略部分...

   @Override

   public void clear() {

   cache.clear();

   //省略部分...

  

 

  我们看到了PerpetualCache类中有一个属性private Map Object, Object cache = new HashMap Object, Object (),很明显它是一个HashMap,我们所调用的.clear()方法,实际上就是调用的Map的clear方法

  得出结论:

  一级缓存的数据结构确实是HashMap

  一级缓存的执行流程

  我们进入到org.apache.ibatis.executor.Executor中
 

  看到一个方法CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql) ,见名思意是一个创建CacheKey的方法
 

  找到它的实现类和方法org.apache.ibatis.executor.BaseExecuto.createCacheKey

  我们分析一下创建CacheKey的这块代码:

  

public CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql) {

 

   if (closed) {

   throw new ExecutorException("Executor was closed.");

   //初始化CacheKey

   CacheKey cacheKey = new CacheKey();

   //存入statementId

   cacheKey.update(ms.getId());

   //分别存入分页需要的Offset和Limit

   cacheKey.update(rowBounds.getOffset());

   cacheKey.update(rowBounds.getLimit());

   //把从BoundSql中封装的sql取出并存入到cacheKey对象中

   cacheKey.update(boundSql.getSql());

   //下面这一块就是封装参数

   List ParameterMapping parameterMappings = boundSql.getParameterMappings();

   TypeHandlerRegistry typeHandlerRegistry = ms.getConfiguration().getTypeHandlerRegistry();

   for (ParameterMapping parameterMapping : parameterMappings) {

   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.update(value);

   //从configuration对象中(也就是载入配置文件后存放的对象)把EnvironmentId存入

   * environments default="development"

   * environment id="development" //就是这个id

   * !--当前事务交由JDBC进行管理--

   * transactionManager type="JDBC" /transactionManager

   * !--当前使用mybatis提供的连接池--

   * dataSource type="POOLED"

   * property name="driver" value="${jdbc.driver}"/

   * property name="url" value="${jdbc.url}"/

   * property name="username" value="${jdbc.username}"/

   * property name="password" value="${jdbc.password}"/

   * /dataSource

   * /environment

   * /environments

   if (configuration.getEnvironment() != null) {

   // issue #176

   cacheKey.update(configuration.getEnvironment().getId());

   //返回

   return cacheKey;

  

 

  我们再点进去cacheKey.update()方法看一看

  

public class CacheKey implements Cloneable, Serializable {

 

   private static final long serialVersionUID = 1146682552656046210L;

   public static final CacheKey NULL_CACHE_KEY = new NullCacheKey();

   private static final int DEFAULT_MULTIPLYER = 37;

   private static final int DEFAULT_HASHCODE = 17;

   private final int multiplier;

   private int hashcode;

   private long checksum;

   private int count;

   //值存入的地方

   private transient List Object updateList;

   //省略部分方法......

   //省略部分方法......

   public void update(Object object) {

   int baseHashCode = object == null ? 1 : ArrayUtil.hashCode(object);

   count++;

   checksum += baseHashCode;

   baseHashCode *= count;

   hashcode = multiplier * hashcode + baseHashCode;

   //看到把值传入到了一个list中

   updateList.add(object);

   //省略部分方法......

  

 

  我们知道了那些数据是在CacheKey对象中如何存储的了。下面我们返回createCacheKey()方法。

  我们进入BaseExecutor,可以看到一个query()方法:

  
 

  这里我们很清楚的看到,在执行query()方法前,CacheKey方法被创建了

  我们可以看到,创建CacheKey后调用了query()方法,我们再次点进去:

  在执行SQL前如何在一级缓存中找不到Key,那么将会执行sql,我们来看一下执行sql前后会做些什么,进入list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);

  
 

  分析一下:

  

 private E List E queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {

 

   List E list;

   //1. 把key存入缓存,value放一个占位符

   localCache.putObject(key, EXECUTION_PLACEHOLDER);

   try {

   //2. 与数据库交互

   list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql);

   } finally {

   //3. 如果第2步出了什么异常,把第1步存入的key删除

   localCache.removeObject(key);

   //4. 把结果存入缓存

   localCache.putObject(key, list);

   if (ms.getStatementType() == StatementType.CALLABLE) {

   localOutputParameterCache.putObject(key, parameter);

   return list;

  

 

  一级缓存源码分析结论:

  一级缓存的数据结构是一个HashMap Object,Object ,它的value就是查询结果,它的key是CacheKey,CacheKey中有一个list属性,statementId,params,rowbounds,sql等参数都存入到了这个list中

  先创建CacheKey,会首先根据CacheKey查询缓存中有没有,如果有,就处理缓存中的参数,如果没有,就执行sql,执行sql后执行sql后把结果存入缓存

  注意:Mybatis的二级缓存不是默认开启的,是需要经过配置才能使用的

  启用二级缓存

  分为三步走:

  1)开启映射器配置文件中的缓存配置:

  

 settings 

 

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

   /settings

  

 

  在需要使用二级缓存的Mapper配置文件中配置标签

  

 !--type:cache使用的类型,默认是PerpetualCache,这在一级缓存中提到过。

 

   eviction: 定义回收的策略,常见的有FIFO,LRU。

   flushInterval: 配置一定时间自动刷新缓存,单位是毫秒。

   size: 最多缓存对象的个数。

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

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

   cache /cache

  

 

  3)在具体CURD标签上配置 useCache=true

  

 select id="findById" resultType="com.itheima.pojo.User" useCache="true" 

 

   select * from user where id = #{id}

   /select

  

 

  ** 注意:实体类要实现Serializable接口,因为二级缓存会将对象写进硬盘,就必须序列化,以及兼容对象在网络中的传输

  具体实现

  

 /**

 

   * 测试一级缓存

   @Test

   public void secondLevelCacheTest() throws IOException {

   InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");

   // 2. (1)解析了配置文件,封装configuration对象 (2)创建了DefaultSqlSessionFactory工厂对象

   SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);

   // 3.问题:openSession()执行逻辑是什么?

   // 3. (1)创建事务对象 (2)创建了执行器对象cachingExecutor (3)创建了DefaultSqlSession对象

   SqlSession sqlSession1 = sqlSessionFactory.openSession();

   // 发起第一次查询,查询ID为1的用户

   User user1 = sqlSession1.selectOne("com.itheima.mapper.UserMapper.findByCondition", 1);

   // ***必须调用sqlSession1.commit()或者close(),一级缓存中的内容才会刷新到二级缓存中

   sqlSession1.commit();// close();

   // 发起第二次查询,查询ID为1的用户

   SqlSession sqlSession2 = sqlSessionFactory.openSession();

   User user2 = sqlSession2.selectOne("com.itheima.mapper.UserMapper.findByCondition", 1);

   System.out.println(user1 == user2);

   System.out.println(user1);

   System.out.println(user2);

   sqlSession1.close();

   sqlSession2.close();

  
 

 

  二级缓存源码分析

  问题:

  ① cache标签如何被解析的(二级缓存的底层数据结构是什么?)?

  ② 同时开启一级缓存二级缓存,优先级?

  ③ 为什么只有执行sqlSession.commit或者sqlSession.close二级缓存才会生效

  ④ 更新方法为什么不会清空二级缓存?

  标签 cache/ 的解析

  二级缓存和具体的命名空间绑定,一个Mapper中有一个Cache, 相同Mapper中的MappedStatement共用同一个Cache

  根据之前的mybatis源码剖析,xml的解析工作主要交给XMLConfigBuilder.parse()方法来实现

  

 // XMLConfigBuilder.parse()

 

   public Configuration parse() {

   if (parsed) {

   throw new BuilderException("Each XMLConfigBuilder can only be used once.");

   parsed = true;

   parseConfiguration(parser.evalNode("/configuration"));// 在这里

   return configuration;

   // parseConfiguration()

   // 既然是在xml中添加的,那么我们就直接看关于mappers标签的解析

   private void parseConfiguration(XNode root) {

   try {

   Properties settings = settingsAsPropertiess(root.evalNode("settings"));

   propertiesElement(root.evalNode("properties"));

   loadCustomVfs(settings);

   typeAliasesElement(root.evalNode("typeAliases"));

   pluginElement(root.evalNode("plugins"));

   objectFactoryElement(root.evalNode("objectFactory"));

   objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));

   reflectionFactoryElement(root.evalNode("reflectionFactory"));

   settingsElement(settings);

   // read it after objectFactory and objectWrapperFactory issue #631

   environmentsElement(root.evalNode("environments"));

   databaseIdProviderElement(root.evalNode("databaseIdProvider"));

   typeHandlerElement(root.evalNode("typeHandlers"));

   // 就是这里

   mapperElement(root.evalNode("mappers"));

   } catch (Exception e) {

   throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);

  
if ("package".equals(child.getName())) {

   String mapperPackage = child.getStringAttribute("name");

   configuration.addMappers(mapperPackage);

   } else {

   String resource = child.getStringAttribute("resource");

   String url = child.getStringAttribute("url");

   String mapperClass = child.getStringAttribute("class");

   // 按照我们本例的配置,则直接走该if判断

   if (resource != null url == null mapperClass == null) {

   ErrorContext.instance().resource(resource);

   InputStream inputStream = Resources.getResourceAsStream(resource);

   XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());

   // 生成XMLMapperBuilder,并执行其parse方法

   mapperParser.parse();

   } else if (resource == null url != null mapperClass == null) {

   ErrorContext.instance().resource(url);

   InputStream inputStream = Resources.getUrlAsStream(url);

   XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, url, configuration.getSqlFragments());

   mapperParser.parse();

   } else if (resource == null url == null mapperClass != null) {

   Class ? mapperInterface = Resources.classForName(mapperClass);

   configuration.addMapper(mapperInterface);

   } else {

   throw new BuilderException("A mapper element may only specify a url, resource or class, but not more than one.");

  

 

  我们来看看解析Mapper.xml

  

// XMLMapperBuilder.parse()

 

  public void parse() {

   if (!configuration.isResourceLoaded(resource)) {

   // 解析mapper属性

   configurationElement(parser.evalNode("/mapper"));

   configuration.addLoadedResource(resource);

   bindMapperForNamespace();

   parsePendingResultMaps();

   parsePendingChacheRefs();

   parsePendingStatements();

  // configurationElement()

  private void configurationElement(XNode context) {

   try {

   String namespace = context.getStringAttribute("namespace");

   if (namespace == null namespace.equals("")) {

   throw new BuilderException("Mappers namespace cannot be empty");

   builderAssistant.setCurrentNamespace(namespace);

   cacheRefElement(context.evalNode("cache-ref"));

   // 最终在这里看到了关于cache属性的处理

   cacheElement(context.evalNode("cache"));

   parameterMapElement(context.evalNodes("/mapper/parameterMap"));

   resultMapElements(context.evalNodes("/mapper/resultMap"));

   sqlElement(context.evalNodes("/mapper/sql"));

   // 这里会将生成的Cache包装到对应的MappedStatement

   buildStatementFromContext(context.evalNodes("selectinsertupdatedelete"));

   } catch (Exception e) {

   throw new BuilderException("Error parsing Mapper XML. Cause: " + e, e);

  // cacheElement()

  private void cacheElement(XNode context) throws Exception {

   if (context != null) {

   //解析 cache/ 标签的type属性,这里我们可以自定义cache的实现类,比如redisCache,如果没有自定义,这里使用和一级缓存相同的PERPETUAL

   String type = context.getStringAttribute("type", "PERPETUAL");

   Class ? extends Cache typeClass = typeAliasRegistry.resolveAlias(type);

   String eviction = context.getStringAttribute("eviction", "LRU");

   Class ? extends Cache evictionClass = typeAliasRegistry.resolveAlias(eviction);

   Long flushInterval = context.getLongAttribute("flushInterval");

   Integer size = context.getIntAttribute("size");

   boolean readWrite = !context.getBooleanAttribute("readOnly", false);

   boolean blocking = context.getBooleanAttribute("blocking", false);

   Properties props = context.getChildrenAsProperties();

   // 构建Cache对象

   builderAssistant.useNewCache(typeClass, evictionClass, flushInterval, size, readWrite, blocking, props);

  

 

  先来看看是如何构建Cache对象的

  MapperBuilderAssistant.useNewCache()

  

public Cache useNewCache(Class ? extends Cache typeClass,

 

   Class ? extends Cache evictionClass,

   Long flushInterval,

   Integer size,

   boolean readWrite,

   boolean blocking,

   Properties props) {

   // 1.生成Cache对象

   Cache cache = new CacheBuilder(currentNamespace)

   //这里如果我们定义了 cache/ 中的type,就使用自定义的Cache,否则使用和一级缓存相同的PerpetualCache

   .implementation(valueOrDefault(typeClass, PerpetualCache.class))

   .addDecorator(valueOrDefault(evictionClass, LruCache.class))

   .clearInterval(flushInterval)

   .size(size)

   .readWrite(readWrite)

   .blocking(blocking)

   .properties(props)

   .build();

   // 2.添加到Configuration中

   configuration.addCache(cache);

   // 3.并将cache赋值给MapperBuilderAssistant.currentCache

   currentCache = cache;

   return cache;

  

 

  我们看到一个Mapper.xml只会解析一次标签,也就是只创建一次Cache对象,放进configuration中,并将cache赋值给MapperBuilderAssistant.currentCache

  buildStatementFromContext(context.evalNodes("selectinsertupdatedelete"));将Cache包装到MappedStatement

  

// buildStatementFromContext()

 

  private void buildStatementFromContext(List XNode list) {

   if (configuration.getDatabaseId() != null) {

   buildStatementFromContext(list, configuration.getDatabaseId());

   buildStatementFromContext(list, null);

  //buildStatementFromContext()

  private void buildStatementFromContext(List XNode list, String requiredDatabaseId) {

   for (XNode context : list) {

   final XMLStatementBuilder statementParser = new XMLStatementBuilder(configuration, builderAssistant, context, requiredDatabaseId);

   try {

   // 每一条执行语句转换成一个MappedStatement

   statementParser.parseStatementNode();

   } catch (IncompleteElementException e) {

   configuration.addIncompleteStatement(statementParser);

  // XMLStatementBuilder.parseStatementNode();

  public void parseStatementNode() {

   String id = context.getStringAttribute("id");

   String databaseId = context.getStringAttribute("databaseId");

   Integer fetchSize = context.getIntAttribute("fetchSize");

   Integer timeout = context.getIntAttribute("timeout");

   String parameterMap = context.getStringAttribute("parameterMap");

   String parameterType = context.getStringAttribute("parameterType");

   Class ? parameterTypeClass = resolveClass(parameterType);

   String resultMap = context.getStringAttribute("resultMap");

   String resultType = context.getStringAttribute("resultType");

   String lang = context.getStringAttribute("lang");

   LanguageDriver langDriver = getLanguageDriver(lang);

   // 创建MappedStatement对象

   builderAssistant.addMappedStatement(id, sqlSource, statementType, sqlCommandType,

   fetchSize, timeout, parameterMap, parameterTypeClass, resultMap, resultTypeClass,

   resultSetTypeEnum, flushCache, useCache, resultOrdered,

   keyGenerator, keyProperty, keyColumn, databaseId, langDriver, resultSets);

  // builderAssistant.addMappedStatement()

  public MappedStatement addMappedStatement(

   String id,

   ...) {

   if (unresolvedCacheRef) {

   throw new IncompleteElementException("Cache-ref not yet resolved");

   id = applyCurrentNamespace(id, false);

   boolean isSelect = sqlCommandType == SqlCommandType.SELECT;

   //创建MappedStatement对象

   MappedStatement.Builder statementBuilder = new MappedStatement.Builder(configuration, id, sqlSource, sqlCommandType)

   .flushCacheRequired(valueOrDefault(flushCache, !isSelect))

   .useCache(valueOrDefault(useCache, isSelect))

   .cache(currentCache);// 在这里将之前生成的Cache封装到MappedStatement

   ParameterMap statementParameterMap = getStatementParameterMap(parameterMap, parameterType, id);

   if (statementParameterMap != null) {

   statementBuilder.parameterMap(statementParameterMap);

   MappedStatement statement = statementBuilder.build();

   configuration.addMappedStatement(statement);

   return statement;

  

 

  我们看到将Mapper中创建的Cache对象,加入到了每个MappedStatement对象中,也就是同一个Mapper中所有的MappedStatement中的cache属性引用的是同一个

  有关于标签的解析就到这了。

  查询源码分析

  CachingExecutor

  

// CachingExecutor

 

  public E List E query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {

   BoundSql boundSql = ms.getBoundSql(parameterObject);

   // 创建 CacheKey

   CacheKey key = createCacheKey(ms, parameterObject, rowBounds, boundSql);

   return query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);

  public E List E query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)

   throws SQLException {

   // 从 MappedStatement 中获取 Cache,注意这里的 Cache 是从MappedStatement中获取的

   // 也就是我们上面解析Mapper中 cache/ 标签中创建的,它保存在Configration中

   // 我们在上面解析blog.xml时分析过每一个MappedStatement都有一个Cache对象,就是这里

   Cache cache = ms.getCache();

   // 如果配置文件中没有配置 cache ,则 cache 为空

   if (cache != null) {

   //如果需要刷新缓存的话就刷新:flushCache="true"

   flushCacheIfRequired(ms);

   if (ms.isUseCache() resultHandler == null) {

   ensureNoOutParams(ms, boundSql);

   // 访问二级缓存

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

   // 缓存未命中

   if (list == null) {

   // 如果没有值,则执行查询,这个查询实际也是先走一级缓存查询,一级缓存也没有的话,则进行DB查询

   list = delegate. E query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);

   // 缓存查询结果

   tcm.putObject(cache, key, list);

   return list;

   return delegate. E query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);

  

 

  如果设置了flushCache="true",则每次查询都会刷新缓存

  

 !-- 执行此语句清空缓存 -- 

 

   select id="findbyId" resultType="com.itheima.pojo.user" useCache="true" flushCache="true"

   select * from t_demo

   /select

  

 

  如上,注意二级缓存是从 MappedStatement 中获取的。由于 MappedStatement 存在于全局配置中,可以多个 CachingExecutor 获取到,这样就会出现线程安全问题。除此之外,若不加以控制,多个事务共用一个缓存实例,会导致脏读问题。至于脏读问题,需要借助其他类来处理,也就是上面代码中 tcm 变量对应的类型。下面分析一下。

  TransactionalCacheManager

  

/** 事务缓存管理器 */

 

  public class TransactionalCacheManager {

   // Cache 与 TransactionalCache 的映射关系表

   private final Map Cache, TransactionalCache transactionalCaches = new HashMap Cache, TransactionalCache

   public void clear(Cache cache) {

   // 获取 TransactionalCache 对象,并调用该对象的 clear 方法,下同

   getTransactionalCache(cache).clear();

   public Object getObject(Cache cache, CacheKey key) {

   // 直接从TransactionalCache中获取缓存

   return getTransactionalCache(cache).getObject(key);

   public void putObject(Cache cache, CacheKey key, Object value) {

   // 直接存入TransactionalCache的缓存中

   getTransactionalCache(cache).putObject(key, value);

   public void commit() {

   for (TransactionalCache txCache : transactionalCaches.values()) {

   txCache.commit();

   public void rollback() {

   for (TransactionalCache txCache : transactionalCaches.values()) {

   txCache.rollback();

   private TransactionalCache getTransactionalCache(Cache cache) {

   // 从映射表中获取 TransactionalCache

   TransactionalCache txCache = transactionalCaches.get(cache);

   if (txCache == null) {

   // TransactionalCache 也是一种装饰类,为 Cache 增加事务功能

   // 创建一个新的TransactionalCache,并将真正的Cache对象存进去

   txCache = new TransactionalCache(cache);

   transactionalCaches.put(cache, txCache);

   return txCache;

  

 

  TransactionalCacheManager 内部维护了 Cache 实例与 TransactionalCache 实例间的映射关系,该类也仅负责维护两者的映射关系,真正做事的还是 TransactionalCache。TransactionalCache 是一种缓存装饰器,可以为 Cache 实例增加事务功能。下面分析一下该类的逻辑。

  TransactionalCache

  

public class TransactionalCache implements Cache {

 

   //真正的缓存对象,和上面的Map Cache, TransactionalCache 中的Cache是同一个

   private final Cache delegate;

   private boolean clearOnCommit;

   // 在事务被提交前,所有从数据库中查询的结果将缓存在此集合中

   private final Map Object, Object entriesToAddOnCommit;

   // 在事务被提交前,当缓存未命中时,CacheKey 将会被存储在此集合中

   private final Set Object entriesMissedInCache;

  
public Object getObject(Object key) {

   // 查询的时候是直接从delegate中去查询的,也就是从真正的缓存对象中查询

   Object object = delegate.getObject(key);

   if (object == null) {

   // 缓存未命中,则将 key 存入到 entriesMissedInCache 中

   entriesMissedInCache.add(key);

   if (clearOnCommit) {

   return null;

   } else {

   return object;

   @Override

   public void putObject(Object key, Object object) {

   // 将键值对存入到 entriesToAddOnCommit 这个Map中中,而非真实的缓存对象 delegate 中

   entriesToAddOnCommit.put(key, object);

   @Override

   public Object removeObject(Object key) {

   return null;

   @Override

   public void clear() {

   clearOnCommit = true;

   // 清空 entriesToAddOnCommit,但不清空 delegate 缓存

   entriesToAddOnCommit.clear();

   public void commit() {

   // 根据 clearOnCommit 的值决定是否清空 delegate

   if (clearOnCommit) {

   delegate.clear();

   // 刷新未缓存的结果到 delegate 缓存中

   flushPendingEntries();

   // 重置 entriesToAddOnCommit 和 entriesMissedInCache

   reset();

   public void rollback() {

   unlockMissedEntries();

   reset();

   private void reset() {

   clearOnCommit = false;

   // 清空集合

   entriesToAddOnCommit.clear();

   entriesMissedInCache.clear();

   private void flushPendingEntries() {

   for (Map.Entry Object, Object entry : entriesToAddOnCommit.entrySet()) {

   // 将 entriesToAddOnCommit 中的内容转存到 delegate 中

   delegate.putObject(entry.getKey(), entry.getValue());

   for (Object entry : entriesMissedInCache) {

   if (!entriesToAddOnCommit.containsKey(entry)) {

   // 存入空值

   delegate.putObject(entry, null);

   private void unlockMissedEntries() {

   for (Object entry : entriesMissedInCache) {

   try {

   // 调用 removeObject 进行解锁

   delegate.removeObject(entry);

   } catch (Exception e) {

   log.warn("...");

  

 

  存储二级缓存对象的时候是放到了TransactionalCache.entriesToAddOnCommit这个map中,但是每次查询的时候是直接从TransactionalCache.delegate中去查询的,所以这个二级缓存查询数据库后,设置缓存值是没有立刻生效的,主要是因为直接存到 delegate 会导致脏数据问题

  为何只有SqlSession提交或关闭之后?

  那我们来看下SqlSession.commit()方法做了什么

  SqlSession

  

@Override

 

  public void commit(boolean force) {

   try {

   // 主要是这句

   executor.commit(isCommitOrRollbackRequired(force));

   dirty = false;

   } catch (Exception e) {

   throw ExceptionFactory.wrapException("Error committing transaction. Cause: " + e, e);

   } finally {

   ErrorContext.instance().reset();

  // CachingExecutor.commit()

  @Override

  public void commit(boolean required) throws SQLException {

   delegate.commit(required);

   tcm.commit();// 在这里

  // TransactionalCacheManager.commit()

  public void commit() {

   for (TransactionalCache txCache : transactionalCaches.values()) {

   txCache.commit();// 在这里

  // TransactionalCache.commit()

  public void commit() {

   if (clearOnCommit) {

   delegate.clear();

   flushPendingEntries();//这一句

   reset();

  // TransactionalCache.flushPendingEntries()

  private void flushPendingEntries() {

   for (Map.Entry Object, Object entry : entriesToAddOnCommit.entrySet()) {

   // 在这里真正的将entriesToAddOnCommit的对象逐个添加到delegate中,只有这。

郑重声明:本文由网友发布,不代表盛行IT的观点,版权归原作者所有,仅为传播更多信息之目的,如有侵权请联系,我们将第一时间修改或删除,多谢。

留言与评论(共有 条评论)
   
验证码: