MyBatis缓存机制-优快云博客

本文链接：https://blog.youkuaiyun.com/jason559/article/details/120363466

一、一级缓存

1、简单了解一级缓存

1）能用到一级缓存的例子：

@Test
public void test1(){
    // 根据 sqlSessionFactory 产生 session
    SqlSession sqlSession = sessionFactory.openSession(); 
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class); 
    // 第一次查询，发出sql语句，并将查询出来的结果放进缓存中
    User u1 = userMapper.selectUserByUserId(1); 
    System.out.println(u1); 
    // 第二次查询，由于是同一个sqlSession,会在缓存中查询结果 
    // 如果有，则直接从缓存中取出来，不和数据库进行交互
    User u2 = userMapper.selectUserByUserId(1); 
    System.out.println(u2);
    sqlSession.close();
}

2）不能用到一级缓存的例子

@Test
public void test2(){
    // 根据 sqlSessionFactory 产生 session
    SqlSession sqlSession = sessionFactory.openSession(); 
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class); 
    // 第一次查询，发出sql语句，并将查询的结果放入缓存中
    User u1 = userMapper.selectUserByUserId( 1 ); 
    System.out.println(u1); 
    // 第二步进行了一次更新操作，sqlSession.commit()
    u1.setSex("女");
    userMapper.updateUserByUserId(u1);
    sqlSession.commit(); 
    // 第二次查询，由于是同一个sqlSession.commit()，会清空缓存信息 
    // 则此次查询也会发出sql语句
    User u2 = userMapper.selectUserByUserId(1); 
    System.out.println(u2);
    sqlSession.close();
}

3）总结

第一次发起查询用户 id 为1的用户信息，先去找缓存中是否有 id 为1的用户信息，如果没有，从数据库查询用户信息。得到用户信息，将用户信息存储到一级缓存中。
如果中间 sqlSession 去执行 commit 操作(执行插入、更新、删除)，则会清空 SqlSession 中的一级缓存，这样做的目的为了让缓存中存储的是最新的信息，避免脏读。
第二次发起查询用户 id 为1的用户信息，先去找缓存中是否有 id 为1的用户信息，缓存中有，直接从缓存中获取用户信息。

图示：

sqlSession 过程图示

2、源码结构

想要研究源码，便跟踪 SqlSession 代码，跟踪相关类：DefaultSqlSession、Executor、BaseExecutor、PerpetualCache 等类，关系图如下：

3、源码追踪分析

1）缓存创建

对于一级缓存操作的核心接口，是 Executor，其中有方法 createCacheKey，BaseExecutor 的 createCacheKey 实现代码如下：

CacheKey cacheKey = new CacheKey(); 
// MappedStatement 的 id
// id就是Sql语句的所在位置包名+类名+ SQL名称 
cacheKey.update(ms.getId());
// offset 就是 0 
cacheKey.update(rowBounds.getOffset());
// limit 就是 Integer.MAXVALUE 
cacheKey.update(rowBounds.getLimit()); 
//具体的SQL语句 
cacheKey.update(boundSql.getSql()); 
//后面是update 了 sql中带的参数 
cacheKey.update(value);
...
if (configuration.getEnvironment() != null) {
    // issue #176
    cacheKey.update(configuration.getEnvironment().getId());
}

观察 cacheKey 中的值：

在这里插入图片描述

这里需要注意一下最后一个值， configuration.getEnvironment().getId()，这是什么，这其实就是定义在 mybatis-config.xml 中的标签，见如下：

<environments default="development">
  <environment id="development">
    <transactionManager type="JDBC"/>
    <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>

2）缓存运用

一级缓存更多是用于查询操作，一级缓存也叫做查询缓存。
其中 BaseExecutor 的 query 方法如下：

@Override
public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
  BoundSql boundSql = ms.getBoundSql(parameter);
  // 创建缓存
  CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);
  return query(ms, parameter, rowBounds, resultHandler, key, boundSql);
}

@SuppressWarnings("unchecked")
@Override
public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
  ··· ···
  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);
  }
  ··· ···
}

// queryFromDatabase方法
private <E> List<E> queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
  List<E> list;
  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;
}

如果查不到的话，就从数据库查，在 queryFromDatabase 中，会对 localcache 进行写入。 localcache 对象的 put 方法最终交给 Map 进行存放。

public class PerpetualCache implements Cache {
    private final Map<Object, Object> cache = new HashMap<>();
    
    @Override
    public void putObject(Object key, Object value) {
      cache.put(key, value);
    }
}

二、二级缓存

1、二级缓存含义

二级缓存的原理和一级缓存原理一样，第一次查询，会将数据放入缓存中，然后第二次查询则会直接去缓存中取。
但是一级缓存是基于 sqlSession 的，而二级缓存是基于 mapper 文件的 namespace 的，也就是说多个 sqlSession 可以共享一个 mapper 中的二级缓存区域。
如果两个 mapper 的 namespace 相同，即使是两个 mapper，那么这两个 mapper 中执行 sql 查询到的数据也将存在相同的二级缓存区域中。

在这里插入图片描述

2、开启二级缓存

和一级缓存默认开启不一样，二级缓存需要我们手动开启。
首先在全局配置文件 sqlMapConfig.xml 文件中加入如下代码：

<!--开启二级缓存--> 
<settings>
    <setting name="cacheEnabled" value="true"/>
</settings>

其次在 UserMapper.xml 文件中开启缓存：

<!--开启二级缓存-->
<cache></cache>

我们可以看到 mapper.xml 文件中就这么一个空标签，其实这里可以配置 type 属性。
PerpetualCache 这个类是 mybatis 默认实现缓存功能的类。
我们不写 type 就使用 mybatis 默认的缓存，也可以去实现 Cache 接口来自定义缓存。
源码分析则是在调用接口 Executor 时，用 CachingExecutor 替换成 SimpleExecutor。

3、注意：

开启了二级缓存后，还需要将要缓存的 pojo 实现 Serializable 接口。

4、测试

@Test
public void testTwoCache1() {
    //根据 sqlSessionFactory 产生 session
    SqlSession sqlSession1 = sessionFactory.openSession(); 
    SqlSession sqlSession2 = sessionFactory.openSession();
    UserMapper userMapper1 = sqlSession1.getMapper(UserMapper. class );
    UserMapper userMapper2 = sqlSession2.getMapper(UserMapper. class );
    
    //第一次查询，发出sql语句，并将查询的结果放入缓存中
    User u1 = userMapper1.selectUserByUserId(1); 
    System.out.println(u1);
    //第一次查询完后关闭 sqlSession
    sqlSession1.close(); 
    
    //第二次查询，即使sqlSession1已经关闭了，这次查询依然不发出sql语句 
    User u2 = userMapper2.selectUserByUserId(1); 
    System.out.println(u2);
    sqlSession2.close();
}

@Test
public void testTwoCache2(){
    //根据 sqlSessionFactory 产生 session
    SqlSession sqlSession1 = sessionFactory.openSession();
    SqlSession sqlSession2 = sessionFactory.openSession();
    SqlSession sqlSession3 = sessionFactory.openSession();
    String statement = "com.lagou.pojo.UserMapper.selectUserByUserld"; 
    UserMapper userMapper1 = sqlSession1.getMapper(UserMapper. class ); 
    UserMapper userMapper2 = sqlSession2.getMapper(UserMapper. class ); 
    UserMapper userMapper3 = sqlSession2.getMapper(UserMapper. class ); 
    
    //第一次查询，发出sql语句，并将查询的结果放入缓存中
    User u1 = userMapperl.selectUserByUserId( 1 );
    System.out.println(u1);
    sqlSessionl.close(); 
    //第一次查询完后关闭sqlSession
    
    //执行更新操作，commit() 
    u1.setUsername( "aaa" ); 
    userMapper3.updateUserByUserId(u1); 
    sqlSession3.commit();
    
    //第二次查询，由于上次更新操作，缓存数据已经清空(防止数据脏读)，这里必须再次发出sql语 
    User u2 = userMapper2.selectUserByUserId( 1 );
    System.out.println(u2);
    sqlSession2.close();
}

5、useCache 和 flushCache

1）useCache

userCache 是用来设置是否禁用二级缓存，默认为 true，使用二级缓存；设置为 false，禁用二级缓存，直接从数据库中获取。

<select id="selectUserByUserId" useCache="false"
        resultType="com.lagou.pojo.User" parameterType="int">
    select * from user where id=#{id}
</select>

2）flushCache

flushCache，表示在更改表格（insert、update、delete），commit 提交后。刷新缓存，默认情况下为 true，即刷新缓存，如果改成 false，表示就算表格 update 更改提交后，也不会刷新。

<select id="selectUserByUserId" flushCache="true" useCache="false"
        resultType="com.lagou.pojo.User" parameterType="int">
    select * from user where id=#{id}
</select>

三、二级缓存整合 redis

上面我们介绍了 mybatis 自带的二级缓存，但是这个缓存是单服务器工作，无法实现分布式缓存。
所以二级缓存可以整合分布式整合框架，比如 redis、memcached、ehcache。下面以 redis 为例。

1、导入依赖。

<dependency>
    <groupId>org.mybatis.caches</groupId>
    <artifactId>mybatis-redis</artifactId>
    <version>1.0.0-beta2</version>
</dependency>

2、mapper 配置文件，UserMapper.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="com.lagou.mapper.IUserMapper">
    
    <cache type="org.mybatis.caches.redis.RedisCache" />
    
    <select id="findAll" resultType="com.lagou.pojo.User" useCache="true">
        select * from user
    </select>
</mapper>

3、redis 配置，redis.properties

redis.host=localhost
redis.port=6379
redis.connectionTimeout=5000
redis.password=
redis.database=0

4、代码测试

@Test
public void SecondLevelCache(){
    
    SqlSession sqlSession1 = sqlSessionFactory.openSession(); 
    SqlSession sqlSession2 = sqlSessionFactory.openSession(); 
    SqlSession sqlSession3 = sqlSessionFactory.openSession(); 
    
    IUserMapper mapper1 = sqlSession1.getMapper(IUserMapper.class); 
    lUserMapper mapper2 = sqlSession2.getMapper(lUserMapper.class); 
    lUserMapper mapper3 = sqlSession3.getMapper(IUserMapper.class); 
    
    User user1 = mapper1.findUserById(1);
    //清空一级缓存
    sqlSession1.close(); 
    
    User user = new User();
    user.setId(1);
    user.setUsername("lisi");
    mapper3.updateUser(user);
    sqlSession3.commit();
    
    User user2 = mapper2.findUserById(1);
    System.out.println(user1==user2);
}

5、源码分析

RedisCache 和大家普遍实现 Mybatis 的缓存方案大同小异，无非是实现 Cache 接口，并使用 jedis 操作缓存。
RedisCache 在 mybatis 启动的时候，由 MyBatis 的 CacheBuilder 创建。
创建的方式很简单，就是调用 RedisCache 的带有 String 参数的构造方法，即 RedisCache(String id)。

public final class RedisCache implements Cache {

  private String id;
  private static JedisPool pool;

  public RedisCache(final String id) {
    if (id == null) {
      throw new IllegalArgumentException("Cache instances require an ID");
    }
    this.id = id;
    // 创建redis配置类对象 
    RedisConfig redisConfig = RedisConfigurationBuilder.getInstance().parseConfiguration();
    // 使用redis配置来创建 redis连接池 JedisPool
    pool = new JedisPool(redisConfig, redisConfig.getHost(), redisConfig.getPort(),
         redisConfig.getConnectionTimeout(), redisConfig.getSoTimeout(), redisConfig.getPassword(),
         redisConfig.getDatabase(), redisConfig.getClientName());
  }
}

RedisConfig 类继承了 JedisPoolConfig，并提供了 host,port 等属性的包装，简单看一下 RedisConfig 的属性：

public class RedisConfig extends JedisPoolConfig {

   private String host = Protocol.DEFAULT_HOST;
   private int port = Protocol.DEFAULT_PORT;
   private int connectionTimeout = Protocol.DEFAULT_TIMEOUT;
   private int soTimeout = Protocol.DEFAULT_TIMEOUT;
   private String password;
   private int database = Protocol.DEFAULT_DATABASE;
   private String clientName;
}

RedisConfig 对象是由 RedisConfigurationBuilder 创建的，简单看下这个类的主要方法：

public RedisConfig parseConfiguration(ClassLoader classLoader) {
   Properties config = new Properties();

   InputStream input = classLoader.getResourceAsStream(redisPropertiesFilename);
   if (input != null) {
      try {
         config.load(input);
      } catch (IOException e) {
         throw new RuntimeException(
               "An error occurred while reading classpath property '"
                     + redisPropertiesFilename
                     + "', see nested exceptions", e);
      } finally {
         try {
            input.close();
         } catch (IOException e) {
            // close quietly
         }
      }
   }

   RedisConfig jedisConfig = new RedisConfig();
   setConfigProperties(config, jedisConfig);
   return jedisConfig;
}

核心的方法就是 parseConfiguration 方法，该方法从 classpath 中读取一个 redis.properties 文件。
并将该配置文件中的内容设置到 RedisConfig 对象中，并返回；
接下来，就是 RedisCache 使用 RedisConfig 类创建完成 jedisPool；
在 RedisCache 中实现了一个简单的模板方法，用来操作 Redis：

private Object execute(RedisCallback callback) {
    Jedis jedis = pool.getResource();
    try {
        return callback.doWithRedis(jedis);
    } finally {
        jedis.close();
    }
}

模板接口为 RedisCallback，这个接口中就只需要实现了一个 doWithRedis 方法而已：

public interface RedisCallback {
    Object doWithRedis(Jedis jedis);
}

接下来看看 Cache 中最重要的两个方法：putObject 和 getObject，通过这两个方法来查看 mybatis-redis 储存数据的格式：

@Override
public void putObject(final Object key, final Object value) {
  execute(new RedisCallback() {
    @Override
    public Object doWithRedis(Jedis jedis) {
      jedis.hset(id.toString().getBytes(), key.toString().getBytes(), SerializeUtil.serialize(value));
      return null;
    }
  });
}

@Override
public Object getObject(final Object key) {
  return execute(new RedisCallback() {
    @Override
    public Object doWithRedis(Jedis jedis) {
      return SerializeUtil.unserialize(jedis.hget(id.toString().getBytes(), key.toString().getBytes()));
    }
  });
}

可以很清楚的看到，mybatis-redis 在存储数据的时候，是使用的 hash 结构，把 cache 的 id 作为这个 hash 的 key（cache 的 id 在 mybatis 中就是 mapper 的 namespace）。
这个 mapper 中的查询缓存数据作为 hash 的 field，需要缓存的内容直接使用 SerializeUtil 存储，SerializeUtil 和其他的序列化类差不多，负责对象的序列化和反序列化。