MyBatis二级缓存

本是古典 何须时尚 2023-10-09 22:02 185阅读 0赞

Mybatis中一级缓存 和 二级缓存的区别

两者区别：一级缓存的作用域是在SqlSession中，二级缓存的作用域是针对mapper做缓存。

一级缓存(本地缓存)

一级缓存是框架默认为我们开启的，我们不需要做任何配置。
例如我们首次查询id为1的用户，mybatis会将该用户的对象存储在一级缓存中；
如果在此中间 sqlSession 执行了commit操作(增删改) ，则mybatis会清空一级缓存的数据 ，这样就能让我们的数据是最新的，避免产生脏读。
当我们再次查 id 为 1 的用户时，mybatis就会去缓存中查找，就不需要再从数据库中去查询。

mybatis一级缓存是默认开启的，是SqlSession级别的缓存，在操作数据库的时候需要创建一个SqlSession，其中有一个HashMap，用于存储缓存数据。不同的SqlSession之间，其缓存数据的HashMap是不同的；

所以当我们多次调用同一个Mapper和同一个方法的同一个参数，只会进行一次数据库查询，然后把数据缓存到缓冲中，以后直接先从缓存中取出数据，不会直接去查数据库。但是不同的SqlSession对象，因为不同的SqlSession都是相互隔离的，所以相同的Mapper、参数和方法，他还是会再次发送到SQL到数据库去执行，返回结果。所以我们需要根据需求开启二级缓存

二级缓存(全局缓存)

二级缓存是 mapper 级别的缓存，多个sqlSession去操作同一个Mapper的sql，不管Sqlsession 是否相同，只要 mapper 的 namespace相同就能共享数据。也可以称之为 namespace 级别的缓存 。

sqlSession 关闭后(close) ，一级缓存的数据会保存到二级缓存中，新的相同的查询语句就会去二级缓存中去查询。

二级缓存是Mapper级别的缓存，多个SqlSession去操作同一个Mapper中的SQL语句，则这些SqlSession可以共享二级缓存，即二级缓存是跨SqlSession的。

二级缓存开启

1，xml 配置中开启 二级缓存

  1. <settings>
  2.     <!-- 开启二级缓存（默认是开的，这里写出来是为了方便代码维护） -->
  3.     <setting name="cacheEnabled" value="true" />
  4. </settings>

2，去mapper映射文件中使用二级缓存

  1. <!-- 开启本mapper所在namespace的二级缓存 -->
  2. <cache />

3，需要将要存储数据的 pojo 实现 Serializable接口，为了将数据取出做反序列化操作， 因为二级的缓存的存储方式多种多样，有可能存储在内存中，也可能储存到磁盘中。如果我们要再取这个缓存的话，就需要反序列化了。所以建议mybatis中的pojo都去实现Serializable接口。

mybatis解读

1、开启缓存的弊端是数据没有实时性，当数据库中的数据一旦修改，查询的数据还是缓存中的数据没有实时性，对于某些需要实时性显示数据的接口我们可以设置 useCache=“false” ,设置该属性后，该接口每次查询出来都是去执行sql查询出实时性数据。如：

  1. <select id="findArtPageview" parameterType="com.Article" resultType="int" useCache="false">
  2. select pageview from article where aid=#{aid}
  3. </select>

设置useCache=false可以禁用当前select语句的二级缓存，即每次查询都会发出sql去查询，默认情况是true，即该sql使用二级缓存。所以：针对每次查询都需要最新的数据sql，要设置成useCache=false，禁用二级缓存。

2、清空缓存，一般下执行完commit操作都需要刷新缓存，flushCache=true表示刷新缓存，这样可以避免数据库脏读。但是如果你不想刷新缓存只需要这么做：

  1. <update id="pageviewAdd" parameterType="com.Goods" flushCache="false">
  2.   update goods set pageview=#{pageview} where gid=#{gid}
  3. </update>

将flushCache=true改为flushCache=false就不用刷新了

总结

1、当为select语句时：
flushCache默认为false，表示任何时候语句被调用，都不会去清空本地缓存和二级缓存。
useCache默认为true，表示会将本条语句的结果进行二级缓存。

2、当为insert、update、delete语句时：
flushCache默认为true，表示任何时候语句被调用，都会导致本地缓存和二级缓存被清空。
useCache属性在该情况下没有。

当为select语句的时候，如果没有去配置flushCache、useCache，那么默认是启用缓存的，所以，如果有必要，那么就需要人工修改配置。

1、二级缓存

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

img

如何使用二级缓存

1.1、开启二级缓存

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

  1. <!--开启二级缓存-->
  2. <settings>
  3.         <setting name="cacheEnabled" value="true"/>
  4. </settings>

其次在UserMapper.xml文件中开启缓存（如果我们是基于注解形式进行查询，可以在mapper查询接口上添加**@CacheNamespace**注解开启二级缓存）

  1. 方式一：在xml文件中配置
  2.  <!--开启二级缓存-->
  3. <cache></cache>
  5. 方式二：在mapper接口上添加上
  6. @CacheNamespace
  8. 后面可以带参数指定加载自定义的缓存实现类
  9. @CacheNamespace(implementation = RedisCache.class)//开启二级缓存

我们可以看到mapper.xml文件中就这么一个空标签，其实这里可以配置,PerpetualCache这个类是mybatis默认实现缓存功能的类。我们不写type就使用mybatis默认的缓存，也可以去实现Cache接口来自定义缓存。

img

  1. public class PerpetualCache implements Cache {
  3.     private final String id;
  4.     private MapcObject, Object> cache = new HashMapC);
  5.     public PerpetualCache(St ring id) {
  6.      this.id = id;
  7. }

我们可以看到二级缓存底层还是HashMap结构

  1. public class User implements Serializable(
  2.     //⽤户ID
  3.     private int id;
  4.     //⽤户姓名
  5.     private String username;
  6.     //⽤户性别
  7.     private String sex;
  8. }

注意：

开启了二级缓存后，还需要将要缓存的pojo实现Serializable接口，为了将缓存数据取出执行反序列化操作，因为二级缓存数据存储介质多种多样，不一定只存在内存中，有可能存在硬盘中，如果我们要再取这个缓存的话，就需要反序列化了。所以mybatis中的pojo都去实现Serializable接口。

1.2、测试

1.2.1、测试?级缓存和sqlSession无关

  1. @Test
  2. public void testTwoCache(){
  4.     //根据 sqlSessionFactory 产⽣ session
  5.     SqlSession sqlSession1 = sessionFactory.openSession();
  6.     SqlSession sqlSession2 = sessionFactory.openSession();
  7.     UserMapper userMapper1 = sqlSession1.getMapper(UserMapper. class );
  8.     UserMapper userMapper2 = sqlSession2.getMapper(UserMapper. class );
  9.     //第⼀次查询，发出sql语句，并将查询的结果放⼊缓存中
  10.     User u1 = userMapper1.selectUserByUserId(1);
  11.     System.out.println(u1);
  12.     sqlSession1.close(); //第⼀次查询完后关闭 sqlSession ,sqlsession关闭后就会清除一级缓存
  13.     //第⼆次查询，即使sqlSession1已经关闭了，这次查询依然不发出sql语句
  14.     User u2 = userMapper2.selectUserByUserId(1);
  15.     System.out.println(u2);
  16.     sqlSession2.close();
  17. }

可以看出上面两个不同的sqlSession,第一个关闭了，第二次查询依然不发出sql查询语句
1.2.2、测试执行\commit*()操作，二级缓存数据清空*

  1. @Test
  2. public void testTwoCache(){
  4.     //根据 sqlSessionFactory 产⽣ session
  5.     SqlSession sqlSession1 = sessionFactory.openSession();
  6.     SqlSession sqlSession2 = sessionFactory.openSession();
  7.     SqlSession sqlSession3 = sessionFactory.openSession();
  8.     String statement = "com.lagou.pojo.UserMapper.selectUserByUserld" ;
  9.     UserMapper userMapper1 = sqlSession1.getMapper(UserMapper. class );
  10.     UserMapper userMapper2 = sqlSession2.getMapper(UserMapper. class );
  11.     UserMapper userMapper3 = sqlSession2.getMapper(UserMapper. class );
  12.     //第⼀次查询，发出sql语句，并将查询的结果放⼊缓存中
  13.     User u1 = userMapperl.selectUserByUserId( 1 );
  14.     System.out.println(u1);
  15.     sqlSessionl .close(); //第⼀次查询完后关闭sqlSession
  16.     //执⾏更新操作，commit()
  17.     u1.setUsername( "aaa" );
  18.     userMapper3.updateUserByUserId(u1);
  19.     sqlSession3.commit();
  21.     //第⼆次查询，由于上次更新操作，缓存数据已经清空(防⽌数据脏读)，这⾥必须再次发出sql语
  22.     User u2 = userMapper2.selectUserByUserId( 1 );
  23.     System.out.println(u2);
  24.     sqlSession2.close();
  25. }

查看控制台情况：

img

1.3、useCache和flushCache

mybatis中还可以配置userCache和flushCache等配置项，userCache是用来设置是否禁用二级缓 存的，在statement中设置useCache=false可以禁?当前select语句的二级缓存，即每次查询都会发出sql去查询，默认情况是true,即该sql使用二级缓存，还可以使用注解方式禁用@Options(useCache=false),flushCache的注解配置方法同上 。

方法一：


select * from user where id=#{id}

方法二：

@Options({useCache = false, flushCache=“true”****})
@Select({“select * from user where id = #{id}”})
public User findUserById(Integer id);

一般下执行完commit操作都需要刷新缓存，flushCache=true表示刷新缓存，这样可以避免数据库脏读。所以我们不用设置，默认即可

2、二级缓存整合redis

上面我们介绍了 mybatis自带的二级缓存，但是这个缓存是单服务器工作，无法实现分布式缓存。 那么什么是分布式缓存呢？假设现在有两个服务器1和2,用户访问的时候访问了 1服务器，查询后的缓存就会放在1服务器上，假设现在有个用户访问的是2服务器，那么他在2服务器上就无法获取刚刚那个缓存，如下图所示：

img

为了解决这个问题，就得找一个分布式的缓存，专门用来存储缓存数据的，这样不同的服务器要缓存数据都往它那里存，取缓存数据也从它那里取，如下图所示：

img

如上图所示，在几个不同的服务器之间，我们使用第三方缓存框架，将缓存都放在这个第三方框架中,然后无论有多少台服务器，我们都能从缓存中获取数据。

这里我们介绍mybatis与redis的整合。
刚刚提到过，mybatis提供了一个eache接口，如果要实现自己的缓存逻辑，实现cache接口开发即可。mybatis本身默认实现了一个，但是这个缓存的实现无法实现分布式缓存，所以我们要自己来实现。redis分布式缓存就可以，mybatis提供了一个针对cache接口的redis实现类，该类存在mybatis-redis包中。

实现：

2.1、pom文件

  1. <dependency>
  2.         <groupId>org.mybatis.caches</groupId>
  3.         <artifactId>mybatis-redis</artifactId>
  4.         <version>1.0.0-beta2</version>
  5. </dependency>

2.2、配置文件

Mapper.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  3. "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  5. <mapper namespace="com.lagou.mapper.IUserMapper">
  7. <cache type="org.mybatis.caches.redis.RedisCache" /> 二级缓存类地址
  9. <select id="findAll" resultType="com.lagou.pojo.User" useCache="true">
  10.     select * from user
  11. </select>

2.3、redis.properties （名字必须叫这个，不然无法获取到里面的数据）

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

2.4、测试

  1. @Test
  2. public void SecondLevelCache(){
  4.     SqlSession sqlSession1 = sqlSessionFactory.openSession();
  5.     SqlSession sqlSession2 = sqlSessionFactory.openSession();
  6.     SqlSession sqlSession3 = sqlSessionFactory.openSession();
  7.     IUserMapper mapper1 = sqlSession1.getMapper(IUserMapper.class);
  8.     lUserMapper mapper2 = sqlSession2.getMapper(lUserMapper.class);
  9.     lUserMapper mapper3 = sqlSession3.getMapper(IUserMapper.class);
  10.     User user1 = mapper1.findUserById(1);
  11.     sqlSession1.close(); //清空⼀级缓存
  12.     User user = new User();
  13.     user.setId(1);
  14.     user.setUsername("lisi");
  15.     mapper3.updateUser(user);
  16.     sqlSession3.commit();
  17.     User user2 = mapper2.findUserById(1);
  18.     System.out.println(user1==user2);
  19. }

2.5、源码分析

RedisCache和大家普遍实现Mybatis的缓存方案大同小异，无非是实现Cache接口，并使用jedis操作缓存；不过该项目在设计细节上有一些区别；

  1. public final class RedisCache implements Cache {
  3. public RedisCache(final String id) {
  5.     if (id == null) {
  7.         throw new IllegalArgumentException("Cache instances require anID");
  8.     }
  9.     this.id = id;
  10.     RedisConfig redisConfig =
  11.     RedisConfigurationBuilder.getInstance().parseConfiguration();
  12.     pool = new JedisPool(redisConfig, redisConfig.getHost(),
  13.     redisConfig.getPort(),
  14.     redisConfig.getConnectionTimeout(),
  15.     redisConfig.getSoTimeout(), redisConfig.getPassword(),
  16.     redisConfig.getDatabase(), redisConfig.getClientName());
  17. }

RedisCache在mybatis启动的时候，由MyBatis的CacheBuilder创建，创建的方式很简单，就是调用RedisCache的带有String参数的构造方法，即RedisCache(String id)；而在RedisCache的构造方法中，调用了 RedisConfigu rationBuilder 来创建 RedisConfig 对象，并使用 RedisConfig 来创建JedisPool。

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

  1. public class RedisConfig extends JedisPoolConfig {
  3. private String host = Protocol.DEFAULT_HOST;
  4. private int port = Protocol.DEFAULT_PORT;
  5. private int connectionTimeout = Protocol.DEFAULT_TIMEOUT;
  6. private int soTimeout = Protocol.DEFAULT_TIMEOUT;
  7. private String password;
  8. private int database = Protocol.DEFAULT_DATABASE;
  9. private String clientName;

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

  1. public RedisConfig parseConfiguration(ClassLoader classLoader) {
  3.     Properties config = new Properties();
  4.     InputStream input = classLoader.getResourceAsStream(redisPropertiesFilename);
  5.     if (input != null) {
  7.         try {
  9.             config.load(input);
  10.         } catch (IOException e) {
  12.             throw new RuntimeException(
  13.                  "An error occurred while reading classpath property '"
  14.                   + redisPropertiesFilename
  15.                   + "', see nested exceptions", e);
  16.         } finally {
  18.         try {
  20.             input.close();
  21.         } catch (IOException e) {
  23.         // close quietly
  24.       }
  25.     }
  26.     }
  27.     RedisConfig jedisConfig = new RedisConfig();
  28.     setConfigProperties(config, jedisConfig);
  29.     return jedisConfig;
  30. }

核心的方法就是parseConfiguration方法，该方法从classpath中读取一个redis.properties?件:

  1. host=localhost
  2. port=6379
  3. connectionTimeout=5000
  4. soTimeout=5000
  5. password= database=0 clientName=

并将该配置文件中的内容设置到RedisConfig对象中，并返回；接下来，就是RedisCache使用RedisConfig类创建完成edisPool；在RedisCache中实现了一个简单的模板方法，用来操作Redis：

  1. private Object execute(RedisCallback callback) {
  3.     Jedis jedis = pool.getResource();
  4.     try {
  6.         return callback.doWithRedis(jedis);
  7.     } finally {
  9.     jedis.close();
  10.     }
  11. }

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

  1. public interface RedisCallback {
  3.     Object doWithRedis(Jedis jedis);
  4. }

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

  1. @Override
  2.         public void putObject(final Object key, final Object value) {
  4.             execute(new RedisCallback() {
  6.                 @Override
  7.                 public Object doWithRedis(Jedis jedis) {
  9.                     jedis.hset(id.toString().getBytes(), key.toString().getBytes(),
  10.                             SerializeUtil.serialize(value));
  11.                     return null;
  12.                 }
  13.             });
  14.         }
  15.         @Override
  16.         public Object getObject(final Object key) {
  18.             return execute(new RedisCallback() {
  20.                 @Override
  21.                 public Object doWithRedis(Jedis jedis) {
  23.                     return SerializeUtil.unserialize(jedis.hget(id.toString().getBytes(),
  24.                             key.toString().getBytes()));
  25.                 }
  26.             });
  27.         }

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

发表评论

表情：
评论列表 （有 0 条评论，185人围观）

还没有评论，来说两句吧...

相关阅读

    相关 MyBatis：二级缓存

    基本知识： 分类： 1. 内置二级缓存（其主要任务是映射） 2. 外置第三方产品 内置二级缓存： 开启方法： 1. 在映射文件中添加<cache/>标签

    清疚清疚/ 0 赞/ 450 阅读