得意犹堪夸世俗，诏黄新湿字如鸦。这篇文章主要讲述Mybatis 入门 第十一篇 之 缓存相关的知识，希望能为你提供帮助。
一、一级缓存一级缓存讲的是SqlSession的缓存，默认是开启的

文章图片

1.1 一级缓存的生命周期

1. Mybatis 每次会话开启一个Session 同时会创建一个缓存对象PerpetualCache，当会话结束、SqlSession被close()或者调用clearCache()方法时缓存都会失效。
   不同的是clearCache()只是清空PerpetualCache中的缓存数据，这个对象还是可以接着用的，其他两种是直接释放这个对象了，不可用了,伴随Sqlsession的消失而消失了。
2. 当SqlSession调用更新语句（update、delete、insert）后也会清空PerpetualCache中的数据(PerpetualCache依旧可以使用)

1.2 怎么判断是否是两个完全相同的查询

1. 同一个statementId (xml中的id)
   
   文章图片
   
2. 结果集结果范围相同
   这个指的是分页信息要一直，如果第一次是1到10，第二次是2到11 那可定不能走缓存
3. sql语句要一直
   指的是xml中的sql语句
   
   文章图片
   
4. 参数要一致
   这个指的是查询的时候传递的参数

1.3证明一下走缓存了想要证明是否走缓存，看一下两次查询出来的hashCode 如果一致那肯定是用了同一个对象（从缓存取出来的上次的查询结果）

public static void main(String[] args) throws Exception { String resource = "mybatis-config.xml"; InputStream inputStream = Resources.getResourceAsStream(resource); SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream); try (SqlSession session = sqlSessionFactory.openSession()) { // 通过sesson获取Mapper 这个Mapper会编程Mybatis的代理Mapper PersonMapper mapper = session.getMapper(PersonMapper.class); List< Person> list01 = mapper.list(); List< Person> list02 = mapper.list(); System.out.println("第一次查询hashCode:"+list01.hashCode()); System.out.println("第二次查询hashCode:"+list02.hashCode()); } }

我们看一下，完全一致

文章图片

1.4 不想用SqlSession一级缓存 ？用flushCache

< !--查询--> < select id="list" resultType="person" flushCache="true"> select a.* from person a < /select>

1.5 我怎么确认我说的这些对呢我们看一下SqlSession的close()、clearCache()、update()方法
close：

@Override public void close(boolean forceRollback) { try { try { rollback(forceRollback); } finally { if (transaction != null) { transaction.close(); } } } catch (SQLException e) { // Ignore.There\'s nothing that can be done at this point. log.warn("Unexpected exception on closing transaction.Cause: " + e); } finally { transaction = null; deferredLoads = null; // 直接把缓存对象置空了 localCache = null; localOutputParameterCache = null; closed = true; } }

clearLocalCache:

@Override public void clearLocalCache() { if (!closed) { // 这个是清空缓存数据 没有把缓存对象置空 localCache.clear(); localOutputParameterCache.clear(); } }

update:

@Override 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."); } // 先调用清空缓存数据的方法 clearLocalCache(); return doUpdate(ms, parameter); }

我们再看一下获取cacheKey的方法：

CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql); // 不用全部读懂 最起码能看出大概逻辑用到了那些值 @Override public CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql) { if (closed) { throw new ExecutorException("Executor was closed."); } CacheKey cacheKey = new CacheKey(); // statmentId cacheKey.update(ms.getId()); // 分页信息 cacheKey.update(rowBounds.getOffset()); cacheKey.update(rowBounds.getLimit()); // sql cacheKey.update(boundSql.getSql()); // 参数 参数是最复杂的 因为这个不确定性高 List< ParameterMapping> parameterMappings = boundSql.getParameterMappings(); TypeHandlerRegistry typeHandlerRegistry = ms.getConfiguration().getTypeHandlerRegistry(); // mimic DefaultParameterHandler logic for (ParameterMapping parameterMapping : parameterMappings) { if (parameterMapping.getMode() != ParameterMode.OUT) { Object value; String propertyName = parameterMapping.getProperty(); if (boundSql.hasAdditionalParameter(propertyName)) { value = https://www.songbingjia.com/android/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); } } if (configuration.getEnvironment() != null) { // issue #176 cacheKey.update(configuration.getEnvironment().getId()); } return cacheKey; }

cacheKey.update 就是更新缓存key的内容，每次update都会修改他的hashcode的值，具体用了什么算法怎么计有兴趣的可以去看看源码
看一下flushCache=" true" 为什么能不用缓存：

// 这就是查询方法 @Override 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()); // 如果执行过程中sqlSession被关闭了直接抛异常 if (closed) { throw new ExecutorException("Executor was closed."); } // 这就是用到了flushCache // queryStack == 0 先不考虑 这个应该是防止了一个并发查询情况下不能随意清空缓存 // isFlushCacheRequired 这个就用到了 flushCache if (queryStack == 0 & & ms.isFlushCacheRequired()) { clearLocalCache(); } List< E> list; try { queryStack++; // 这里看到了 如果有resultHandler也不走缓存什么是resultHandler 后边写文章说明 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(); if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) { // issue #482 clearLocalCache(); } } return list; }

什么时候放入缓存的呢 ？ queryFromDatabase：

private < E> List< E> queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException { List< E> list; // 这里会占位 我的理解是如果一个线程在查询 // 另外一个线程可以直接从缓存拿数据（是个占位符数据 不是真实数据） // 然后转换的时候就会报错 转换异常 // 这也是为什么sqlSession线程不安全的原因之一吧 // 官方不会让数据出错 会让你直接抛类型转换异常 高明呀！ // 自己项目中如果有类似场景 也可以考虑这样做 localCache.putObject(key, EXECUTION_PLACEHOLDER); try { list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql); } finally { // 删除占位 localCache.removeObject(key); } // 设置缓存数据 localCache.putObject(key, list); if (ms.getStatementType() == StatementType.CALLABLE) { localOutputParameterCache.putObject(key, parameter); } return list; }

其实SqlSession一级缓存的缓存结构很简单：
说白了就是用了一个Map来存储数据，用Map做缓存在很多框架中都用到了包括Spring，eruka
我之前项目也用到了，是临时存储了一个key-value对应关系的信息

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; }

二、 二级缓存二级缓存是应用级别的缓存，为啥叫二级缓存呢，很简单，因为已经有一级缓存了，这个时候出来个缓存可不就叫二级缓存了，哈哈 真有道理。
【Mybatis 入门 第十一篇 之 缓存】那为什么要二级缓存呢？大概是因为一级缓存是在同一个SqlSession中，sqlSession不存在的话缓存就么有啦，像我们再Spring中，都是一次请求创建一个SqlSession 这样缓存其实作用会很小的，我们的二级缓存超越了SqlSesion范围，把数据存储到比SqlSession更大的范围内，这样性能会更高

文章图片

二级缓存使用注意事项：

1. POJO类要可序列化 实现Serializeable接口
   
2. 二级缓存默认的作用域是整个namespace
   
3. 同一个namespace的所有select语句都会被缓存
   
4. 同一个namespace的所有insert\\update\\delete 语句都会刷新这个namespace的缓存
   
5. 缓存默认使用LRU（最近最少使用，也就是最长时间不被使用）算法回收
   其他算法：
   FIFO:先进先出，按对象进入缓存的顺序剔除
   SOFT:软引用 基于垃圾回收器状态和引用规则移除对象
   WEAK:弱引用 更积极的 基于垃圾回收器状态和引用规则移除对象
   
6. 默认缓存1024个对象 超出之后就会走淘汰策略
   
7. 默认缓存不会定时刷新，可以设置定时刷新时间
   
8. 默认缓存会被视为读/写缓存，意味着获取的对象并不是共享的，可以安全的被调用者修改。
   意思就是你获取的对象是从缓存中克隆出来的，而不是直接给了你一个引用
   可以设置只读（如果有写操作会抛异常）
   

2.1 使用一波Person可序列化

public class Person implements Serializable { private Long id; private String name; private String jobName; private BigDecimal salary; private Integer age; private String gender; private String address; private String hobby; }

分三个SqlSession测试：

public class TestMain { public static void main(String[] args) throws Exception { String resource = "mybatis-config.xml"; InputStream inputStream = Resources.getResourceAsStream(resource); SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream); // 第一次 try (SqlSession session = sqlSessionFactory.openSession()) { // 通过sesson获取Mapper 这个Mapper会编程Mybatis的代理Mapper PersonMapper mapper = session.getMapper(PersonMapper.class); List< Person> list = mapper.list(); System.out.println("第一次查询hashCode:"+list.hashCode()); } // 第二次 try (SqlSession session = sqlSessionFactory.openSession()) { // 通过sesson获取Mapper 这个Mapper会编程Mybatis的代理Mapper PersonMapper mapper = session.getMapper(PersonMapper.class); List< Person> list = mapper.list(); System.out.println("第二次查询hashCode:"+list.hashCode()); } // 第三次 try (SqlSession session = sqlSessionFactory.openSession()) { // 通过sesson获取Mapper 这个Mapper会编程Mybatis的代理Mapper PersonMapper mapper = session.getMapper(PersonMapper.class); List< Person> list = mapper.list(); System.out.println("第三次查询hashCode:"+list.hashCode()); } } }

输出结果：

文章图片

配置PersonMapper.xml

< ?xml version="1.0" encoding="UTF-8" ?> < !DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> < mapper namespace="dao.PersonMapper"> < !-- eviction:FIFO 淘汰策略先进先出flushInterval:60000 缓存60秒刷新一次 size:512 最多存储512个缓存对象 readOnly:true 设置为只读 返回同一个引用--> < cache eviction="FIFO" flushInterval="60000" size="512" readOnly="true"/> < !--查询--> < select id="list" resultType="person" > select a.* from person a < /select> < /mapper>

再次执行测试输出结果：

文章图片

2.2 一定要注意在同一个namespace缓存才会有用，我们测试一下不同namespace的效果mybatis-config.xml

< !--扫描--> < mappers> < mapper resource="PersonMapper.xml"/> < mapper resource="PersonMapper02.xml"/> < /mappers>

PersonMapper

public interface PersonMapper { List< Person> list(); }

PersonMapper.xml

< mapper namespace="dao.PersonMapper"> < !-- eviction:FIFO 淘汰策略先进先出flushInterval:60000 缓存60秒刷新一次 size:512 最多存储512个缓存对象 readOnly:true 设置为只读 返回结果如果进行修改就会报错--> < cache eviction="FIFO" flushInterval="60000" size="512" readOnly="true"/> < !--查询--> < select id="list" resultType="person" > select a.* from person a < /select> < /mapper>

PersonMapper02

public interface PersonMapper { List< Person> list(); }

PersonMapper02.xml

< mapper namespace="dao.PersonMapper02"> < !-- eviction:FIFO 淘汰策略先进先出flushInterval:60000 缓存60秒刷新一次 size:512 最多存储512个缓存对象 readOnly:true 设置为只读 返回结果如果进行修改就会报错--> < cache eviction="FIFO" flushInterval="60000" size="512" readOnly="true"/> < !--查询--> < select id="list" resultType="person" > select a.* from person a < /select> < /mapper>

测试TestMain：

public class TestMain { public static void main(String[] args) throws Exception { String resource = "mybatis-config.xml"; InputStream inputStream = Resources.getResourceAsStream(resource); SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream); // try (SqlSession session = sqlSessionFactory.openSession()) { // 通过sesson获取Mapper 这个Mapper会编程Mybatis的代理Mapper PersonMapper mapper = session.getMapper(PersonMapper.class); List< Person> list = mapper.list(); System.out.println("PersonMapper查询，hashCode:"+list.hashCode()); } // try (SqlSession session = sqlSessionFactory.openSession()) { // 通过sesson获取Mapper 这个Mapper会编程Mybatis的代理Mapper PersonMapper02 mapper = session.getMapper(PersonMapper02.class); List< Person> list = mapper.list(); System.out.println("PersonMapper02查询,hashCode:"+list.hashCode()); } } }

输出结果：

文章图片

2.3 注意了如果readOnly 设置为false 那么返回的对象就不是同一个引用，那么就不能用hashCode看是否使用了缓存，这个时候有一个很好的方式，就是源码打断点，或者输出查询日志或者第一次查询执行完后Thread.sleep一分钟，然后手动去数据库修改一下数据，手动修改数据Mybatis是无感知的，这时候他查出来的数据还是从缓存中获取的
三、 自定义缓存定义Cache类：

package cache; import org.apache.ibatis.cache.Cache; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.locks.ReadWriteLock; import java.util.concurrent.locks.ReentrantReadWriteLock; /** * @author 发现更多精彩关注公众号：木子的昼夜编程 * 一个生活在互联网底层，做着增删改查的码农,不谙世事的造作 * @create 2021-09-05 15:55 */ public class MyCache implements Cache { // 读写锁 private ReadWriteLock lock = new ReentrantReadWriteLock(); // 这里我们可以用ehcache redis MongoDB 等技术 Map< Object,Object> map = new ConcurrentHashMap< > (); // cache的ID private String id ; public MyCache(){ System.out.println("无参构造"); } public MyCache(String id){ this.id = id; System.out.println("构造函数id(namespace):"+id); }@Override public String getId() { System.out.println("获取id：" + id); return id; }@Override public void putObject(Object key, Object value) { map.put(key,value); }@Override public Object getObject(Object key) { Object value = https://www.songbingjia.com/android/map.get(key); System.out.println("获取对象：key="+key+", value="https://www.songbingjia.com/android/+value); return value; }@Override public Object removeObject(Object key) { return map.remove(key); }@Override public void clear() { map.clear(); }@Override public int getSize() { return map.size(); }@Override public ReadWriteLock getReadWriteLock() { return lock; } }

指定cache使用自定义类：

< ?xml version="1.0" encoding="UTF-8" ?> < !DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> < mapper namespace="dao.PersonMapper"> < cache type="cache.MyCache"> < /cache> < !--查询--> < select id="list" resultType="person" > select a.* from person a < /select> < /mapper>

测试：

public class TestMain { public static void main(String[] args) throws Exception { String resource = "mybatis-config.xml"; InputStream inputStream = Resources.getResourceAsStream(resource); SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream); // 第一次 try (SqlSession session = sqlSessionFactory.openSession()) { // 通过sesson获取Mapper 这个Mapper会编程Mybatis的代理Mapper PersonMapper mapper = session.getMapper(PersonMapper.class); List< Person> list = mapper.list(); System.out.println("第一次查询，hashCode:"+list.hashCode()); } // 第二次 try (SqlSession session = sqlSessionFactory.openSession()) { // 通过sesson获取Mapper 这个Mapper会编程Mybatis的代理Mapper PersonMapper mapper = session.getMapper(PersonMapper.class); List< Person> list = mapper.list(); System.out.println("第二次查询,hashCode:"+list.hashCode()); } } }

输出：

文章图片

四、不想被缓存影响总有一些人很特殊，也总有一些方法很特殊，由于缓存的特殊性，可能缓存有时候数据不是很及时（比如我手动修改数据库数据后 缓存是不刷新的），对于某些对数据库数据非常敏感的方法不需要缓存，但是二级缓存是作用在namespace上的，我们需要不让它受影响
这时候就用到了flushCache 、useCache
flushCache :执行操作前是否清空缓存
useCache: 是否使用缓存
例如：

< !--不使用缓存--> < select id="list" resultType="person" useCache="false"> select a.* from person a < /select>

< !--执行前会清空缓存--> < update id="updt" parameterType="entity.Person" flushCache="true"> update person set salary = #{salary} where id =#{id} < /update>

有事儿没事儿关注公众号： 木子的昼夜编程

文章图片

推荐阅读

• 

  你们认为诗仙李白最好的一首诗是哪一首？
• 

  一天喝多少牛奶合适？
• 

  青芒的热量高吗
• 

  花胶有什么营养价值
• 

  土大黄的功效与作用 土大黄的副作用
• 

  美国冲突升级!武装民兵冲进议会大厦,议员吓的穿防弹衣上班,州长命令被废,大乱了吗？
• 

  最新热门的12个最佳博客平台合集（以及如何选择一个）
• 

  买笔记本电脑,处理器是选择i5还是i7？
• 

  妒组词语 妒有哪些组词呢
• 

  熊童子简笔画
• 

  Photoshop制作沧桑颓废的城市海报
• 

  手机停机怎么连接网络，手机停机怎么连接网络电视
• 

  176升冰箱购买指南及故障维修解决方案
• 

  早晨八点半
• 

  升级换代，让您的打印更高效 epsonL3153变成2710
• 

  海带有味道了还能吃吗
• 

  照门是什么意思 照门的含义
• 

  获嘉天气30天 获嘉天气预报
• 

  核酸检测假阳性怎么处理
• 

  分享一首小诗（相信）

• 致同发布全球商业调查 全球中端市场重归良性发展
• Redis技术探索帮你从底层彻底吃透RDB技术原理（基础篇）
• 本图文详细教程教你win10开机黑屏时间长
• 本图文详细教程教你windows10开机变快
• win10激活工具最新推荐
• 从客户端隐藏一些WordPress仪表板选项
• 有关如何选择托管服务提供商(具有快速响应时间)的指南，将包含所有必需功能的WordPress主题
• 从WordPress主题中的Kirki定制器字段获取值
• 在发布上获取自定义post类型元