mybatis-cache

简介
源码解读
缓存使用
总结&反思

每次在编写文章之前自己都喜欢先来个感想，今天的话题是多读英文文档，好处多多！什么情况下要考虑缓存问题呢？一般微服务架构设计时，分布式应用可能导致脏数据，特别是在秒杀情况下需要特别注意（可以接入外部二级缓存）

简介

在这里插入图片描述文档中已经很明显说明了什么cashe，什么是一级缓存和二次缓存。个人就总结为：缓存即相同查询时，在没有发生更新、提交、回滚和关闭时，多次查询不会从数据库中返回，直接从Cashe的缓存实现类中返回。一级缓存居于sqlsesson缓存，二级缓存是居于mapper级别缓存,启用一级缓存的方式是通过设置localCacheScope=STATEMENT，启用二级缓存的方式是总配置cacheEnabled为true和mapper文件配置cache

源码解读

在构建sqlsessionFactory时，构建Executor,具体构建方法是DefaultSqlSessionFactory#openSessionFromConnection，我们更多关注里面的Configuration#newExecutor

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);
    }
    if (cacheEnabled) {
    
     // 这里默认启用CachingExecutor动态代理
      executor = new CachingExecutor(executor);
    }
    executor = (Executor) interceptorChain.pluginAll(executor); // 执行拦截器
    return executor;
  }

从上面可知我们更多关注的对象是CachingExecutor，下面我们看CachingExecutor来逆推到底如何实现二级缓存。

@Override
  public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)
      throws SQLException {
    
    
    Cache cache = ms.getCache(); // 这里是我们关注的二级缓存对象，此对象是从MappedStatement中获取
    if (cache != null) {
    
    
      flushCacheIfRequired(ms); // 这里判断是否有此缓存和是否需要清空缓存，若没有则存放在TransactionalCacheManager#transactionalCaches中
      if (ms.isUseCache() && resultHandler == null) {
    
     // 判断是否有Cache启动
        ensureNoOutParams(ms, boundSql); 
        @SuppressWarnings("unchecked")
        List<E> list = (List<E>) tcm.getObject(cache, key); // 缓存中获取
        if (list == null) {
    
     // 不存在则查询
          list = delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
          tcm.putObject(cache, key, list); // issue #578 and #116  // 查询完后存入缓存中
        }
        return list;
      }
    }
    return delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql); // 不启用缓存则查询本地缓存
  }

从上面缓存执行代码中，我们可以查看到外部缓存时从MappedStatement中获取，接下来我们看这个缓存如何构造，查看源码可知MappedStatement#cache加入了缓存，继续跟进，则MapperBuilderAssistant#addMappedStatement中加入，再往上一层则MapperBuilderAssistant#useNewCache构建。接下来我们看看构建方法

public Cache useNewCache(Class<? extends Cache> typeClass,
      Class<? extends Cache> evictionClass,
      Long flushInterval,
      Integer size,
      boolean readWrite,
      boolean blocking,
      Properties props) {
    
    
    Cache cache = new CacheBuilder(currentNamespace) // 命名空间来构建
        .implementation(valueOrDefault(typeClass, PerpetualCache.class)) // 默认PerpetualCache缓存，当然这里不支持分布式
        .addDecorator(valueOrDefault(evictionClass, LruCache.class))
        .clearInterval(flushInterval)
        .size(size)
        .readWrite(readWrite)
        .blocking(blocking)
        .properties(props)
        .build();
    configuration.addCache(cache);
    currentCache = cache;
    return cache;
  }

此时的Cache的属性Id为currentNamespace和MappedStatement同时构建，再往上一层发现XMLMapperBuilder#cacheElement方法，最后configurationElement中元素cach判断是否构建。最后真相大白，实际上二级缓存是居于mapper来构建的。XMLMapperBuilder解析xml文件 -》XMLMapperBuilder#cacheElement欲准备构建-》MapperBuilderAssistant#useNewCache构建cache -》MapperBuilderAssistant#addMappedStatement构建MappedStatement时传入Cache。其实最终发现解读mybatis源码并不难。
4. 我们发现cache是居于mappedStatement构建的，接下来回归CachingExecutor如何执行Cache。在讲解之前，我们可以看看CacheKey的组成（BaseExecutor#createCacheKey），这里不细谈，主要知道Cache的key通过namespace和sql以及查询条件组成即可。我们来谈谈如何获取Cache,我们返回上面步骤2中的tcm.getObject(cache, key)。下面我们详细看看里面方法.

private final Map<Cache, TransactionalCache> transactionalCaches = new HashMap<>();
private TransactionalCache getTransactionalCache(Cache cache) {
    
    
    return transactionalCaches.computeIfAbsent(cache, TransactionalCache::new);
  }

发现每次Cache还有重复利用哦，交给TransactionalCacheManager管理。
5. 当二级缓存查找不到时，执行executor,如上面2的delegate.query。
6. 执行查询时，执行BaseExecutor#query，我们来看看sql的查询方法：

@SuppressWarnings("unchecked")
  @Override
  public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
    
    
    // 省略
    List<E> list;
    try {
    
    
      queryStack++;
      // 发现这里是查询localCache类型，若查不到才去数据库中查询，new PerpetualCache("LocalOutputParameterCache")
      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);
      }
    } finally {
    
    
      queryStack--;
    }
    if (queryStack == 0) {
    
    
      for (DeferredLoad deferredLoad : deferredLoads) {
    
    
        deferredLoad.load();
      }
      // issue #601
      deferredLoads.clear();
      // 缓存对象，判断是否是STATEMENT，若是，则清空LocalCache
      if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
    
    
        // issue #482
        clearLocalCache();
      }
    }
    return list;
  }

接下来真相大白所谓的二级缓存就是额外增加的外部缓存，实际一级缓存也存在；先判断是否开启二级缓存，若没有开启则查询localCache，若开启则查询二级缓存并维护，没有查到时则查询一级缓存，若一级缓存也查不到则查询数据库。

缓存使用

1、默认二级缓存不开启。若想禁用一级缓存，则可以设置localCacheScope=STATEMENT，如下：

<settings>
   <setting name="localCacheScope" value="STATEMENT"/>
</settings>

2、若想指定sql语句清空缓存，则通过mapper中设置useCache="false"和flushCache=“true”（线程不安全，这里不详细讲解），如下：

<select id="selectTest" resultMap="userTable" useCache="false" flushCache="true" >
        select * from user
    </select>

具体原理实现代码flushCache如CachingExecutor#query会刷新缓存
3、调用EhcacheCache缓存
< cache type=“org.mybatis.caches.ehcache.EhcacheCache”/>

总结&反思

缓存的概念和一级缓存以及二级缓存的概念
缓存的使用场景和考虑的问题
解读源码的思路，若有更好的方式，请多多指教
几个关键类和接口了解：DefaultSqlSessionFactory、Configuration、CachingExecutor、MappedStatement、MapperBuilderAssistant、XMLMapperBuilder、Cache、CacheKey

结合上一篇讲解mybatis-plugin，是否觉得mybatis是个很简单的框架呢？哈哈哈，个人感觉方法只有一个，如何使用方法就是难点，巧妙和熟练使用方法，在遇到相应技术点时就考虑这种类似的问题，其实mybatis是半ORM框架，因为依然存在sql，mybatis强大之处在于强大的动态sql和动态代理模式的设计理念。接下来一篇个人来探讨如何搭建一个分布式架构的理念！请稍等！已完结

零散关注背诵点记录：

数据库特点：
1、数据结构化 2、数据的共享性高，冗余低，易扩展 3、数据独立性高 4、统一管理和控制
事务的特性：原子性（Atomicity）、一致性(Consistency)、隔离性(Isolation)、持久性(Durability)
概念性理解：脏读、不可重复读、幻读

top指令：rownum和rowid、limit


NOT NULL
UNIQUE
PRIMARY KEY
FOREIGN KEY
CHECK
DEFAULT

-- 创建唯一索引
CREATE UNIQUE INDEX uk_users_name ON t_users(name); 
-- 删除唯一索引
drop index uk_users_name;
-- 创建唯一键约束
ALTER TABLE t_users ADD CONSTRAINT uk_users_name1 UNIQUE (NAME);
ALTER TABLE Orders ADD CONSTRAINT fk_PerOrders FOREIGN KEY (Id_P) REFERENCES Persons(Id_P)

alter table dept2 add primary key(dname);
drop index index_name;


 -- 创建序列  Student_stuId_Seq --
create sequence mySeq    ：序列名
start with 1 　　　　　　   ：序列开始值
increment by 1                   ：序列每次自增1
maxvalue 3                        ：序列最大值
minvalue 1                         ：序列最小值
cache 2                              ：每次缓存的数值个数
cycle;                                 ：是否循环[cycle:循环   |   nocycle: 不循环]


JdbcTransactionFactory   TransactionIsolationLevel(NONE，Read_uncommit,Read_commit,Reapeatable_read,serializable)
BaseExecutor事务管理JdbcTransaction实现Proxy动态代理(InvocationHandler)

1、扫描xml或者注解文件，
properties
settings(defaultExecutorType，logImpl)
typeAliases
Plugins(interceptor并实力话)
objectFactory
objectWrapperFactory
reflectorFactory
environments（创建TransactionFactory,datasource）
databaseIdProvider
typeHandlers
mappers
2、创建SqlSessionFactory
3、openSession打开sql缓存执行器时 DefaultSqlSessionFactory
	1、创建事务工厂（TransationFactory）
	2、ManagedTransaction获取事务管理器，datasource和connection
	3、获取数据库执行类ExecutorType判断，SimpleExecutor、ReuseExecutor、BatchExecutor还是
	CachingExecutor（cacheEnabled）这里默认开启一级缓存，同一个sqlSession多次时只执行一次。
	4、创建DefaultSqlSession
DefaultSqlSession-》CachingExecutor-》BaseExecutor-》 flushCacheIfRequired(ms)

4、创建statementMap，查看是否有sql一样，如果有看是否关闭，若关闭,则jdbcTransaction中通过datasource获取连接
这里jdbcTransation管理事务

typeAlias 类型声明，简写之类
TypeHandler类型转换，jdbc里类型转换成java类型数据。
defaultObjectFactory主要构造bean，返回结果集反射之类的和xml解析

Plugin是居于代理模式启动interceptors,具体流程如下：
	1、configuration#addInterceptor解析文件存放所有拦截器，configuration#newExecutor调用代理
	2、interceptorChain.pluginAll启动代理，返回Executor
	3、interceptor.plugin调用Plugin.wrap，plugin创建InvocationHandler代理对象，封装的所有方法拦截器
	在对于执行类的所有方法Map<Class,Set<Method>>中。
	4、当代理接口类执行时，调用先获取method.getDeclaringClass()对于的声明类，然后取出拦截器的方法（Map<Class,Set<Method>>）
	判断调用方法是否相同if (methods != null && methods.contains(method))，若相同，则执行拦截器
拦截器基本拦截方式：Parameterhandler、ResultSetHandler、StatementHandler、Executor


引用别人面试技术篇：https://www.cnblogs.com/qmillet/p/12523636.html

浅谈mybatis-Cache

mybatis-cache

简介

源码解读

缓存使用

总结&反思

猜你喜欢