缓存就是内存中的数据，常常来自对数据库查询结果的保存，使用缓存，我们可以避免频繁的与数据库进行交互，进而提高响应速度
MyBatis提供了对缓存的支持，分为一级缓存和二级缓存，可以通过一下图解来理解：
一级缓存是SqlSession级别的缓存，默认开启，在操作数据库是要构造SqlSession对象，在对象中有一个数据结构(HashMap)用于存储缓存数据。不同的SqlSession之间的数据缓存区域是互相不影响的。
二级缓存是Mapper级别的缓存，多个SqlSession去操作通一个Mapper的SQL语句，多个SqlSession可以公用二级缓存，二级缓存是跨SqlSession的。
我们在一个SqlSession中，对User表查询所有用户进行两次查询，查看他们发出SQL语句的情况。
@Test
public void selectTest(){
SqlSession sqlSession = sessionFactory.openSession(true);
userMapper = sqlSession.getMapper(UserMapper.class);
List<User> users = userMapper.selectList();
users.forEach(user -> {
System.out.println(user);
});
List<User> users1 = userMapper.selectList();
users1.forEach(user -> {
System.out.println(user);
});
}
从上面的SQL语句执行结果打印可以看到，我们执行了两次的selectList方法，但是只打印了一次SQL语句的执行日志，可见第二次执行selectList时取得是缓存中的数据。当缓存中没有数据的时候，会执行SQL语句获取结果，然后将数据放到缓存中，当第二次执行同一个SQL语句时，就会取到缓存中的数据。
同样时对user表进行两次查询，只不过之间进行一次update操作
@Test
public void selectTest(){
SqlSession sqlSession = sessionFactory.openSession(true);
userMapper = sqlSession.getMapper(UserMapper.class);
List<User> users = userMapper.selectList();
users.forEach(user -> {
System.out.println(user);
});
User u1 = users.get(0);
u1.setUsername(u1.getUsername()+"-update");
userMapper.update(u1);
List<User> users1 = userMapper.selectList();
users1.forEach(user -> {
System.out.println(user);
});
}
可以看到，当我们执行了一次update方法后，再次执行selectList时，我们又执行了一次数据库查询，由此可见，更新数据库信息，会导致缓存失效
一级缓存是到底是什么？一级缓存何时备创建？一级缓存的工作流程是怎么样的？
我们知道一级缓存是SqlSession层次的缓存，所有我们可以从SqlSession中出发，看看有没有和缓存相关的属性或方法
从SqlSession的所有方法中看到，只有一个clearCache()方法和缓存有点关系，那我们就从这个方法开始，看下SqlSession的缓存是怎么回事。
从SqlSession开始，流程最后走到了PrepetualCahe#clear()方法中，在这里调用cache.clear()方法，翻阅PrepetualCache类可以看到，cache实际上就是一个Map对象，调用cache.clear()方法，其实就是调用的Map的clear()方法。
public class PerpetualCache implements Cache {
private final String id;
private Map<Object, Object> cache = new HashMap();
public PerpetualCache(String id) {
this.id = id;
}
public String getId() {
return this.id;
}
public int getSize() {
return this.cache.size();
}
public void putObject(Object key, Object value) {
this.cache.put(key, value);
}
public Object getObject(Object key) {
return this.cache.get(key);
}
public Object removeObject(Object key) {
return this.cache.remove(key);
}
public void clear() {
this.cache.clear();
}
public ReadWriteLock getReadWriteLock() {
return null;
}
public boolean equals(Object o) {
if (this.getId() == null) {
throw new CacheException("Cache instances require an ID.");
} else if (this == o) {
return true;
} else if (!(o instanceof Cache)) {
return false;
} else {
Cache otherCache = (Cache)o;
return this.getId().equals(otherCache.getId());
}
}
public int hashCode() {
if (this.getId() == null) {
throw new CacheException("Cache instances require an ID.");
} else {
return this.getId().hashCode();
}
}
}
那么一级缓存是何时创建的呢？
我们在使用SqlSession进行数据操作时，最终执行SQL请求的是Excutor接口中的query()方法，而在Excutor接口的抽象实现类BaseExector的query方法中，有如下一段代码
public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
BoundSql boundSql = ms.getBoundSql(parameter);
CacheKey key = this.createCacheKey(ms, parameter, rowBounds, boundSql);
return this.query(ms, parameter, rowBounds, resultHandler, key, boundSql);
}
从上面的代码中，我们看到，在query方法中，在执行具体实现类的query方法之前，创建了一个CacheKey对象，而cacheKey是通过参数MappedStatement参数，SQL参数，RowBounds参数和ResultHandler参数来创建的
public CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql) {
if (this.closed) {
throw new ExecutorException("Executor was closed.");
} else {
CacheKey cacheKey = new CacheKey();
cacheKey.update(ms.getId());
cacheKey.update(rowBounds.getOffset());
cacheKey.update(rowBounds.getLimit());
cacheKey.update(boundSql.getSql());
//****
return cacheKey;
}
}
再query方法中，CacheKey对象被当作参数向后传递，在quer方法的重载方法中，首先会根据这个key在本地缓存中获取一次数据，如果存在数据，则返回该数据，如果不存在则调用queryFromDatabase()方法，从数据库中获取数据
public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
...
List list;
try {
++this.queryStack;
list = resultHandler == null ? (List)this.localCache.getObject(key) : null;
if (list != null) {
this.handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
} else {
list = this.queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
}
} finally {
--this.queryStack;
}
...
return list;
}
}
而在queryFromDatabase方法中，将获取到的数据添加到了本地缓存中
private <E> List<E> queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
this.localCache.putObject(key, ExecutionPlaceholder.EXECUTION_PLACEHOLDER);
List list;
try {
list = this.doQuery(ms, parameter, rowBounds, resultHandler, boundSql);
} finally {
this.localCache.removeObject(key);
}
this.localCache.putObject(key, list);
if (ms.getStatementType() == StatementType.CALLABLE) {
this.localOutputParameterCache.putObject(key, parameter);
}
return list;
}
从上面的代码中可以看到，MyBatis的一级缓存，SqlSession缓存是在执行Sql语句之后，查询到结果集并完成封装之后创建的，同时也可以看出一级缓存的工作流程。
和一级缓存不同，二级缓存是需要我们手动开启的。但是二级缓存的原理和一级缓存一样，第一次查询，将数据放入缓存中，第二次查询则会直接从缓存中取。MyBatis的二级缓存是在Mapper层次，而一级缓存是SqlSession层次的，也就是说多个SqlSession可以共享一个mapper的二级缓存。同样的，当SqlSession执行插入、修改、删除等操作时，会清空Mapper二级缓存。
如何使用二级缓存：
开启二级缓存
首先我们需要在MyBatis的配置文件中开启二级缓存
<settings>
<!-- 1. 显示SQL语句 -->
<setting name="logImpl" value="STDOUT_LOGGING"/>
<!--2、开启二级缓存-->
<setting name="cacheEnabled" value="true"/>
</settings>
然后在Mapper.xml中开启缓存
<!--开启二级缓存-->
<cache></cache>
在mapper.xml中，我们只提供了一个空标签，但其实这里是可以配置的。在Mybatis中，PerpetualCache这个类是Mybatis的默认实现缓存功能的类。我们不写cache标签的type参数，就是使用默认的缓存。同时我们也可以实现Cache接口，来实现自定义的二级缓存。同时用于二级缓存的存储介质多样化，不一定是只存在内存中，也有可能存在硬盘中，所以我们从二级缓存再取数据的时候，可能需要反序列化操作，因此，mybatis中的所有数据实体类pojo需要实现Serializable接口。
测试二级缓存
测试二级缓存和SqlSession无关
@Test
public void mapperCacheTest() {
SqlSession sqlSession = sessionFactory.openSession(true);
SqlSession sqlSession2 = sessionFactory.openSession(true);
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
UserMapper userMapper2 = sqlSession2.getMapper(UserMapper.class);
List<User> users = userMapper.selectList();
users.forEach(user -> {
System.out.println(user);
});
System.out.println("=====================================");
sqlSession.close();
List<User> users1 = userMapper2.selectList();
users1.forEach(user -> {
System.out.println(user);
});
}
控制台打印结果：
从控制台打印结果中可以看到，即使我们已经关闭了sqlSession，但是sqlSession2执行查询时乃未打印SQL查询语句。
执行commit操作，验证二级缓存是否清空
@Test
public void mapperCacheTest() {
SqlSession sqlSession = sessionFactory.openSession(true);
SqlSession sqlSession2 = sessionFactory.openSession(true);
SqlSession sqlSession3 = sessionFactory.openSession(true);
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
UserMapper userMapper2 = sqlSession2.getMapper(UserMapper.class);
UserMapper userMapper3 = sqlSession3.getMapper(UserMapper.class);
List<User> users = userMapper.selectList();
users.forEach(user -> {
System.out.println(user);
});
System.out.println("=====================================");
sqlSession.close();
User u1 = users.get(0);
u1.setUsername(u1.getUsername().replace("-update",""));
userMapper3.update(u1);
List<User> users1 = userMapper2.selectList();
users1.forEach(user -> {
System.out.println(user);
});
}
控制台打印结果：
从打印结果中，我们看到，执行完update语句后，我们再次查询时，又执行了一次select语句，由此可见，当我们进行了commit()操作后，Mapper中的二级缓存会被清空
二级缓存整合redis
上面我们使用的是mybatis自带的二级缓存，但是这个缓存是单服务器工作的，无法实现分布式缓存，即不同服务器不能共享缓存。为了解决这个问题，就得找一个分布式缓存，专门来存储缓存数据，这样不同得服务器得缓存数据都存在该处，缓存也从该处取。
mybatis与redis整合
之前我们提到过，mybatis的默认缓存类是PrepetualCache，它实现了Cache接口，而我们如果要实现自己的缓存逻辑，我们也只需要实现Cache接口即可。PrepetualCache类的缓存逻辑，无法实现分布式缓存，因此，mybatis提供了一个针对Cache接口的redis实现类，该类存在于mybatis-redis包中
实现
引入jar包的坐标
<dependency>
<groupId>org.mybatis.caches</groupId>
<artifactId>mybatis-redis</artifactId>
<version>1.0.0-beta2</version>
</dependency>
在Mapper.xml中配置cache标签的type属性值
<!--开启二级缓存-->
<cache type="org.mybatis.caches.redis.RedisCache"></cache>
redis配置 redis.properties
注意，此处redis的配置文件的名称不能随意修改，固定未redis.properties
host=192.168.2.107
port=6379
connectionTimeout=5000
password=
database=0
测试
@Test
public void redisCacheTest() {
SqlSession sqlSession = sessionFactory.openSession(true);
SqlSession sqlSession2 = sessionFactory.openSession(true);
SqlSession sqlSession3 = sessionFactory.openSession(true);
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
UserMapper userMapper2 = sqlSession2.getMapper(UserMapper.class);
UserMapper userMapper3 = sqlSession3.getMapper(UserMapper.class);
List<User> users = userMapper.selectList();
users.forEach(user -> {
System.out.println(user);
});
System.out.println("=====================================");
sqlSession.close();
User u1 = users.get(0);
u1.setUsername(u1.getUsername().replace("-update", ""));
userMapper3.update(u1);
List<User> users1 = userMapper2.selectList();
users1.forEach(user -> {
System.out.println(user);
});
}
可以看到关闭了进行了commit()操作后，我们进行第二次查询未发送SQL语句，此时第二次查询从redis中进行了获取
RedisCache是mybatis-redis提供的实现了Cache接口的类，实现了redis分布式缓存的逻辑。从RedisCache的构造方法中，我们可以看到，传入了一个id参数，这个id参数就是我们Mapper.xml中对用的namespace的属性；然后调用了RedisConfigurationBuilder来创建RedisConfig配置对象，在RedisConfiguraitonBuilder中，我们可以看到一些常量信息，包括redis.properties，这也是为什么redis的配置文件不能随便修改的原因。获取了RedisConfig配置后，就是获取JedisPool，redis的操作都是通过JedisPool中的jedis来实现的
public RedisCache(String id) {
if (id == null) {
throw new IllegalArgumentException("Cache instances require an ID");
} else {
this.id = id;
RedisConfig redisConfig = RedisConfigurationBuilder.getInstance().parseConfiguration();
pool = new JedisPool(redisConfig, redisConfig.getHost(), redisConfig.getPort(), redisConfig.getConnectionTimeout(), redisConfig.getSoTimeout(), redisConfig.getPassword(), redisConfig.getDatabase(), redisConfig.getClientName());
}
}
private static final RedisConfigurationBuilder INSTANCE = new RedisConfigurationBuilder();
private static final String SYSTEM_PROPERTY_REDIS_PROPERTIES_FILENAME = "redis.properties.filename";
private static final String REDIS_RESOURCE = "redis.properties";
private final String redisPropertiesFilename = System.getProperty("redis.properties.filename", "redis.properties");
public void putObject(final Object key, final Object value) {
this.execute(new RedisCallback() {
public Object doWithRedis(Jedis jedis) {
jedis.hset(RedisCache.this.id.toString().getBytes(), key.toString().getBytes(), SerializeUtil.serialize(value));
return null;
}
});
}
public Object getObject(final Object key) {
return this.execute(new RedisCallback() {
public Object doWithRedis(Jedis jedis) {
return SerializeUtil.unserialize(jedis.hget(RedisCache.this.id.toString().getBytes(), key.toString().getBytes()));
}
});
}
然后我们可以看下，redisCache中的putObject()和getObject()方法，这两个方法中，详细的指出了，RedisCache的数据结构，就是哈希结构。
到这里，mybatis的缓存大概就学完了，若存在不正确的地方，麻烦各位大佬指正，谢谢~