Mybatis实践笔记-一级缓存和二级缓存

最新推荐文章于 2024-06-04 15:46:09 发布

叶子的翅膀

最新推荐文章于 2024-06-04 15:46:09 发布

阅读量159

点赞数

分类专栏： Mybatis 文章标签： mybatis 一级缓存二级缓存源码分析

本文链接：https://blog.csdn.net/xiaoxiqinqinbaobao/article/details/108732803

版权

Mybatis 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

文章内容输出来源：拉勾教育Java高薪训练营

文章目录

缓存说明

Mybatis的缓存分为一级缓存、二级缓存

一级缓存

一级缓存介绍

SqlSession级别的缓存
采用了基于HashMap实现的PerpetualCache进行存储
不同SqlSession的缓存是互不影响
当同一个Session进行了commit或者close操作后，缓存就会失效
Mybatis默认开启一级缓存

二级缓存

二级缓存介绍

Mapper级别级别的缓存
默认也是基于HashMap实现的PerpetualCache进行存储，可以修改为Ehcache、Redis来进行存储
多个SqlSession可以共享同一个Mapper的二级缓存(如果不同Mapper的Namespace相同，不同Mapper也是共享的)
当同一个Mapper的创建、更新、删除操作执行后，缓存就会失效
Mybatis默认是不开启

参数配置

开启二级缓存
- 在mybatis的配置文件的setting添加上<setting name="cacheEnabled" value="true"/>
statement的缓存属性
- 在statement上设置useCache=false可以禁用当前select语句的二级缓存。默认是true。
- 在statement上设置flushCache=true可以刷新缓存，设置为false就不会刷新缓存，可能出现脏读。默认是true

示例

示例准备

创建用户实体UserEntity，还有相应的用户表

public class UserEntity {
    private Integer id;
    private String name;
    //ignore getter/setter
}

创建UserDao的Mapper接口，声明一个查询和更新的接口

public interface UserDao {

    void update(UserEntity user);

    UserEntity selectOne(Integer id);
}

创建UserMapp.xml的脚本文件，实现查询和更新的SQL

<mapper namespace="com.yyh.demo.dao.UserDao">
    <select id="selectOne" resultType="UserEntity">
      SELECT * FROM user WHERE id=#{id}
    </select>

    <update id="update" parameterType="UserEntity">
        UPDATE user SET name=#{name} WHERE id=#{id}
    </update>
</mapper>

配置上Mybatis的日志输出log4j.properties，方便观察缓存查询的效果

log4j.rootLogger=DEBUG,Console
log4j.appender.Console=org.apache.log4j.ConsoleAppender
log4j.appender.Console.layout=org.apache.log4j.PatternLayout
log4j.appender.Console.layout.ConversionPattern=%d [%t] %-5p [%c] - %m%n

引入单元测试junit

一级缓存示例

创建UserCache1Test的单元测试类

测试在同一个session中查询相同的数据，缓存是否生效

/**
   * 测试在同一个session中查询相同的数据，缓存是否生效
   */
  @Test
  public void testUserCache1() {
      SqlSession sqlSession = sqlSessionFactory.openSession(true);
      UserDao userDao = sqlSession.getMapper(UserDao.class);

      System.out.println("第一次查询用户ID为2的数据");
      UserEntity user = userDao.selectOne(2);

      System.out.println("第二次查询用户ID为2的数据");
      user = userDao.selectOne(2);

      sqlSession.close();
  }

观察日志，第一次有去数据库中查询，第二次没有去数据库中查询，说明是使用了一级缓存
在同一个session下，当进行同样数据的查询，会使用到一级缓存

测试在同一session中查询相同的数据，中间做了一更新操作后，缓存是否失效

/**
   * 测试在同一session中查询相同的数据，中间做了一更新操作后，缓存是否失效
   */
  @Test
  public void testUserCache2() {
      SqlSession sqlSession = sqlSessionFactory.openSession(true);
      UserDao userDao = sqlSession.getMapper(UserDao.class);

      System.out.println("第一次查询用户ID为2的数据");
      UserEntity user = userDao.selectOne(2);

      //对用户ID为2做了更新操作，并有进行了自动commit操作
      user.setName("TEST");
      userDao.update(user);

      System.out.println("第二次查询用户ID为2的数据");
      user = userDao.selectOne(2);
      sqlSession.close();
  }

观察日志，第一次有去数据库中查询。修改数据后，第二次也是要去数据库中查询
在同一个session下，当进行了commit操作后，就会清空缓存
如果中间执行了session的commit操作（添加、删除、修改），则会去清空一级缓存，以便获取到最新的信息，避免受脏读

测试在不同session中查询，是否使用到了缓存

/**
    * 测试在不同session中查询，是否使用到了缓存
    */
  @Test
  public void testUserCache3() {
      System.out.println("第一次查询用户ID为2的数据");

      SqlSession sqlSession1 = sqlSessionFactory.openSession(true);
      UserDao userDao1 = sqlSession1.getMapper(UserDao.class);
      UserEntity user = userDao1.selectOne(2);



      System.out.println("第二次查询用户ID为2的数据");
      //创建另一个sqlsession
      SqlSession sqlSession2 = sqlSessionFactory.openSession(true);
      UserDao userDao2 = sqlSession2.getMapper(UserDao.class);

      user = userDao2.selectOne(2);
  }

使用不同的sqlsession进行查询，发现都是要去查数据库
一级缓存是sqlsession级别，不同session的缓存互相不影响

二级缓存示例

创建UserCache2Test的单元测试类

在Mybatis配置文件中开启二级缓存

<settings>
  <setting name="cacheEnabled" value="true"/>
</settings>

在UserMapper.xml中添加上使用二级缓存的cache标签
- 有一个type属性，默认使用的是PerpetualCache作为二级缓存，这里可以不用设置type

<cache></cache>

为UserEntity实现序列化接口，不然二级缓存获取会报错NotSerializableException

public class UserEntity implements Serializable {
    private static final long serialVersionUID = 1L;
    //...
}

测试同一session下查询相同数据，是使用到了一级缓存还是二级缓存

/**
     * 测试同一session下查询相同数据，是使用到了一级缓存还是二级缓存
     */
    @Test
    public void testUserCache1() {

        SqlSession sqlSession1 = sqlSessionFactory.openSession(true);
        UserDao userDao1 = sqlSession1.getMapper(UserDao.class);


        System.out.println("第一次查询用户ID为2的数据");
        UserEntity user1 = userDao1.selectOne(2);

        System.out.println("第二次查询用户ID为2的数据");
        UserEntity user2 = userDao1.selectOne(2);


        //输出为true，即user1和user2是一样的
        System.out.println(user1 == user2);
        sqlSession1.close();

        //日志：Cache Hit Ratio [com.yyh.demo.dao.UserDao]: 0.0
        //没有命中二级缓存，说明此处使用到的是一级缓存
    }

同一个session下多次查询相同数据，先从一级缓存中获取数据

测试不同session下查询相同数据，是否使用到了二级缓存，从二级缓存中取出来的数据是不一样

  /**
    * 测试不同session下查询相同数据，是否使用到了二级缓存，从二级缓存中取出来的数据是不一样
    */
  @Test
  public void testUserCache2() {
      System.out.println("第一次查询用户ID为2的数据");
      SqlSession sqlSession1 = sqlSessionFactory.openSession(true);
      UserDao userDao1 = sqlSession1.getMapper(UserDao.class);
      UserEntity user1 = userDao1.selectOne(2);
      sqlSession1.close();


      System.out.println("第二次查询用户ID为2的数据");
      SqlSession sqlSession2 = sqlSessionFactory.openSession(true);
      UserDao userDao2 = sqlSession2.getMapper(UserDao.class);
      UserEntity user2 = userDao2.selectOne(2);
      sqlSession2.close();

      //输出false，user1和user2的引用地址不一样
      System.out.println(user1 == user2);
      //输出true，user1和user2所指向的实例对象是一样
      System.out.println(user1.equals(user2));

      //日志：Cache Hit Ratio [com.yyh.demo.dao.UserDao]: 0.5
      //命中二级缓存
  }

不同session下，查询相同数据，二级缓存生效

测试不同session下查询相同数据，中间做了修改操作，是否二级缓存会清空

/**
    * 测试不同session下查询相同数据，中间做了修改操作，是否二级缓存会清空
    */
  @Test
  public void testUserCache3() {
      System.out.println("第一次查询用户ID为2的数据");
      SqlSession sqlSession1 = sqlSessionFactory.openSession(true);
      UserDao userDao1 = sqlSession1.getMapper(UserDao.class);
      UserEntity user1 = userDao1.selectOne(2);
      sqlSession1.close();


      System.out.println("更新用户ID为3的操作");
      SqlSession sqlSession2 = sqlSessionFactory.openSession(false);
      UserDao userDao2 = sqlSession2.getMapper(UserDao.class);
      UserEntity user2 = new UserEntity();
      user2.setId(3);
      user2.setName("USER_TEST");
      userDao2.update(user2);
      sqlSession2.commit();
      sqlSession2.close();

      System.out.println("第二次查询用户ID为2的数据");
      SqlSession sqlSession3 = sqlSessionFactory.openSession(true);
      UserDao userDao3 = sqlSession3.getMapper(UserDao.class);
      UserEntity user3 = userDao3.selectOne(2);
      sqlSession3.close();

      //日志：Cache Hit Ratio [com.yyh.demo.dao.UserDao]: 0.0
      //清空了二级缓存，session3执行了SQL请求操作
  }

不同session获取相同数据，中间进行了更新操作，就会清空二级缓存
这里要注意的点是，即使更新的用户ID跟查询的用户ID不一样，同样会去清空二级缓存

整合Redis缓存
（1）引入redis依赖

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

（2）添加上redis.properties配置文件

host=localhost
port=6379
password=
database=5
connectionTimeout=5000

（3）在UserMapper.xml中指定使用redis缓存

  <cache type="org.mybatis.caches.redis.RedisCache"/>

源码跟踪

一级缓存源码分析

定位到SqlSession接口，找到其中有一个清除缓存的相关方法

    void clearCache();

定位到SqlSession的实现类DefaultSqlSession，查看clearCache方法的实现，发现是执行器executor调用了清除缓存方法

@Override
  public void clearCache() {
    executor.clearLocalCache();
  }

定位到Executor接口的实现类BaseExecutor，查看clearLocalCache方法的实现。可以看到最终是在一个PerpetualCache类型的属性localCache中执行清除操作。

 protected PerpetualCache localCache;

 @Override
  public void clearLocalCache() {
    if (!closed) {
      localCache.clear();
      localOutputParameterCache.clear();
    }
  }

定位到PerpetualCache，发现其中有一个cache属性，是一个HashMap。也就是说一级缓存就是本地存储的Map对象。每一个SqlSession都会创建一个Map对象的缓存。

private Map<Object, Object> cache = new HashMap<Object, Object>();

那么，缓存在什么时候创建的？在执行器Executor创建的时候。因为Executor负责执行SQL请求，可以在执行之前判断下是否有缓存数据，直接返回。
定位到BaseExecutor的构造函数，可以看到。一创建了执行器就会去创建一个缓存对象。

protected BaseExecutor(Configuration configuration, Transaction transaction) {
    //...
    this.localCache = new PerpetualCache("LocalCache");
    this.localOutputParameterCache = new PerpetualCache("LocalOutputParameterCache");
    //...
  }

继续看BaseExecutor，其中有一个创建缓存Key的方法createCacheKey。了解到缓存Map对象的key是由5方面因素组合而成。

@Override
public CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql) {
    // 创建 CacheKey 对象
    CacheKey cacheKey = new CacheKey();

    //组合因素1：id是指SQL语句的所在位置：包名+类名+SQL名称
    cacheKey.update(ms.getId());
    //组合因素2：分页的偏移值、数量条件
    cacheKey.update(rowBounds.getOffset());
    cacheKey.update(rowBounds.getLimit());
    //组合因素3：SQL语句
    cacheKey.update(boundSql.getSql());

    //组合因素4：参数值
    List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
    TypeHandlerRegistry typeHandlerRegistry = ms.getConfiguration().getTypeHandlerRegistry();
    for (ParameterMapping parameterMapping : parameterMappings) {
        if (parameterMapping.getMode() != ParameterMode.OUT) {
            Object value;
            String propertyName = parameterMapping.getProperty();
            if (boundSql.hasAdditionalParameter(propertyName)) {
                value = 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);
        }
    }
    //组合因素5：环境变量的ID值
    if (configuration.getEnvironment() != null) {
        // issue #176
        cacheKey.update(configuration.getEnvironment().getId());
    }
    return cacheKey;
}

因为是查询缓存，直接定位到BaseExecutor的查询方法query进行分析。在这里就有判断从缓存中拿数据。如果没有缓存就会继续执行queryFromDatabase方法。

public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
    //...
    if (queryStack == 0 && ms.isFlushCacheRequired()) {
      clearLocalCache();
    }
    List<E> list;
    try {
      queryStack++;
      //从缓存中拿数据
      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;
  }

定位到BaseExecutor的queryFromDatabase方法。可以看到从数据库中获取到数据后，就会将数据putObject放到缓存中。

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

可以看到一级缓存实际是一个本地存储的HashMap对象。缓存的创建、清除以及缓存的设置、使用都是在执行器Executor中

项目代码

Mybatis缓存示例的代码

叶子的翅膀

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Mybatis实践笔记-一级缓存和二级缓存

文章内容输出来源：拉勾教育Java高薪训练营文章目录缓存说明一级缓存一级缓存介绍二级缓存二级缓存介绍参数配置示例示例准备一级缓存示例二级缓存示例源码跟踪一级缓存源码分析项目代码缓存说明Mybatis的缓存分为一级缓存、二级缓存一级缓存一级缓存介绍SqlSession级别的缓存采用了基于HashMap实现的PerpetualCache进行存储不同SqlSession的缓存是互不影响当同一个Session进行了commit或者close操作后，缓存就会失效Mybatis默认开启一级缓存.
复制链接

扫一扫