浅谈mybatis-Cache
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<Method>>中。
4、当代理接口类执行时，调用先获取method.getDeclaringClass()对于的声明类，然后取出拦截器的方法（Map<Method>>）
判断调用方法是否相同if (methods != null && methods.contains(method))，若相同，则执行拦截器
拦截器基本拦截方式：Parameterhandler、ResultSetHandler、StatementHandler、Executor
引用别人面试技术篇：https://www.cnblogs.com/qmillet/p/12523636.html