MyBatis三级缓存实战：高级缓存策略的实现与应用-阿里云开发者社区

基于前面的内容，我们已经非常熟悉了 MyBatis 的一级缓存和二级缓存的设计，一级缓存是将数据存储在了 SqlSession 的 BaseExecutor 中，仅对同一个 SqlSession 有效，二级缓存是基于一级缓存的基础之上，使用 CachingExecutor 来装饰一级缓存，而 CachingExecutor 是在 MyBatis 初始化阶段就完成了创建，全局有效。

不过我们通过源码可以看到，归根结底 MyBatis 是通过 PerpetualCache 来存储的缓存数据，而 PerpetualCache 的底层仅仅是使用的 HashMap 来存储，设计的还是非常的简陋，包括缓存的清理都是非常的粗暴（更新就清空），而且一级、二级缓存都是存储在本机内存的，如果是分布式的集群部署就会存在数据不一致的情况，所以我们有必要再引入一种更为高级的缓存。

三级缓存

三级缓存也称为定制缓存，它可以跨应用共享缓存数据。不过 MyBatis 自身是没有提供三级缓存的方案，所以通常都是引入第三方作为缓存方案。三级缓存也可以再次细分一下：

JVM 缓存：EhCache、OsCache、JBossCache…
中间件缓存：Redis、MemCache…

本文我们选取两个有代表性的方案进行集成测试，分别是 EhCache 和 Redis。

在我看来，MyBatis 的 ”三级缓存“ 这个词似乎并不恰当，因为其目的是为了替换 MyBatis 的二级缓存。并不是说实实在在就有三个层级。

整合 EhCache

Ehcache 是一个流行的开源 Java 缓存框架，被广泛应用于各种 Java 项目中。在 MyBatis 中，Ehcache 通常被用作 MyBatis 的二级缓存的实现之一，用于在多个会话之间共享缓存数据，提高数据访问性能。

作用范围：跨会话缓存，Ehcache 可以在多个 SqlSession 之间共享缓存数据，有效减少数据库访问次数，提高系统性能和响应速度。
缓存实现：

插件化实现：MyBatis 支持插件化的缓存实现，可以通过配置文件来选择使用 Ehcache 作为二级缓存的实现。
基于内存：Ehcache 是一种基于内存的缓存框架，可以快速访问缓存数据，适用于需要快速读取数据的场景。

配置方式：

XML 配置：可以通过 MyBatis 的 XML 配置文件来配置 Ehcache，包括缓存的属性、大小、过期时间等。
注解配置：也可以通过注解的方式来配置 Ehcache，例如使用 @CacheNamespace 注解来配置缓存策略。

特性：

高性能：Ehcache 是一个高性能的缓存框架，能够快速地读取和写入缓存数据。
可扩展性：Ehcache 支持水平扩展，可以根据应用程序的需求来扩展缓存集群，以满足不同规模的应用场景。
数据一致性：Ehcache 提供了丰富的配置选项，可以通过配置来保证缓存数据的一致性和可靠性。

集成方式：

Maven 集成：可以通过 Maven 或 Gradle 等构建工具来集成 Ehcache 到 MyBatis 项目中。
配置文件：需要在 MyBatis 的配置文件中进行相关配置，指定使用 Ehcache 作为二级缓存的实现。

注意事项：

缓存清理策略：需要根据业务需求和系统性能来选择合适的缓存清理策略，以保证缓存数据的及时更新和一致性。
内存管理：由于 Ehcache 是基于内存的缓存框架，需要注意内存的管理和监控，避免内存溢出或性能下降的问题。

添加依赖

<!--引入 EhCache-->
<dependency>
    <groupId>org.mybatis.caches</groupId>
    <artifactId>mybatis-ehcache</artifactId>
    <version>1.1.0</version>
</dependency>
<!--引入 EhCache 所需要的日志依赖-->
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>1.8.0-beta4</version>
</dependency>
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-log4j12</artifactId>
    <version>1.8.0-beta4</version>
</dependency>
<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
</dependency>

配置文件

在 resources 目录下创建 ehcache.xml，并添加以下内容：

<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="https://ehcache.org/ehcache.xsd"
         updateCheck="false">
    <!--
       diskStore：为缓存路径，ehcache分为内存和磁盘两级，此属性定义磁盘的缓存位置。参数解释如下：
       user.home – 用户主目录
       user.dir  – 用户当前工作目录
     -->
    <diskStore path="cache"/>
    <!--
       defaultCache：默认缓存策略，当ehcache找不到定义的缓存时，则使用这个缓存策略。只能定义一个。
     -->
    <!--
      name:缓存名称。
      maxElementsInMemory:缓存最大数目
      maxElementsOnDisk：硬盘最大缓存个数。
      eternal:对象是否永久有效，一但设置了，timeout将不起作用。
      overflowToDisk:是否保存到磁盘，当系统当机时
      timeToIdleSeconds:设置对象在失效前的允许闲置时间（单位：秒）。仅当eternal=false对象不是永久有效时使用，可选属性，默认值是0，也就是可闲置时间无穷大。
      timeToLiveSeconds:设置对象在失效前允许存活时间（单位：秒）。最大时间介于创建时间和失效时间之间。仅当eternal=false对象不是永久有效时使用，默认是0.，也就是对象存活时间无穷大。
      diskPersistent：是否缓存虚拟机重启期数据 Whether the disk store persists between restarts of the Virtual Machine. The default value is false.
      diskSpoolBufferSizeMB：这个参数设置DiskStore（磁盘缓存）的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区。
      diskExpiryThreadIntervalSeconds：磁盘失效线程运行时间间隔，默认是120秒。
      memoryStoreEvictionPolicy：当达到maxElementsInMemory限制时，Ehcache将会根据指定的策略去清理内存。默认策略是LRU（最近最少使用）。你可以设置为FIFO（先进先出）或是LFU（较少使用）。
      clearOnFlush：内存数量最大时是否清除。
      memoryStoreEvictionPolicy:可选策略有：LRU（最近最少使用，默认策略）、FIFO（先进先出）、LFU（最少访问次数）。
      FIFO，first in first out，这个是大家最熟的，先进先出。
      LFU，Less Frequently Used，就是上面例子中使用的策略，直白一点就是讲一直以来最少被使用的。如上面所讲，缓存的元素有一个hit属性，hit值最小的将会被清出缓存。
      LRU，Least Recently Used，最近最少使用的，缓存的元素有一个时间戳，当缓存容量满了，而又需要腾出地方来缓存新的元素的时候，那么现有缓存元素中时间戳离当前时间最远的元素将被清出缓存。
   -->
    <defaultCache
            eternal="false"
            maxElementsInMemory="10000"
            overflowToDisk="true"
            diskPersistent="true"
            timeToIdleSeconds="1800"
            timeToLiveSeconds="259200"
            memoryStoreEvictionPolicy="LRU"/>
</ehcache>

Mapper 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">
<!-- 配置 namespace -->
<mapper namespace="world.xuewei.mybatis.dao.Account1Dao">
    <!-- 指定缓存类型 -->
    <cache type="org.mybatis.caches.ehcache.EhcacheCache"/>
    <!-- useCache="true" 可以省略 -->
    <select id="getAll" resultType="Account">
        select * from account
    </select>
</mapper>

cache 标签也是支持配置若干个 property 标签的，这样就可以省略上面的 ehcache.xml

<cache type="org.mybatis.caches.ehcache.EhcacheCache">
 <property name="eternal" value="false"/>
 <property name="maxElementsInMemory" value="10000"/>
 <property name="overflowToDisk" value="true"/>
 <property name="diskPersistent" value="true"/>
 <property name="timeToIdleSeconds" value="1800"/>
 <property name="timeToLiveSeconds" value="259200"/>
 <property name="memoryStoreEvictionPolicy" value="LRU"/>
</cache>

但是推荐还是使用单独的配置文件进行统一管理，这样可以避免冗余。

测试程序

public class Cache3Test {
    private SqlSession sqlSession;
    @Before
    public void before() throws IOException {
        InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        sqlSession = sessionFactory.openSession();
    }
    /**
     * 验证二级缓存，多个 SqlSession 有效
     */
    @Test
    public void testGetAll() {
        Account1Dao accountDao1 = sqlSession.getMapper(Account1Dao.class);
        Account1Dao accountDao2 = sqlSession.getMapper(Account1Dao.class);
        System.out.println("==== 第一次执行，查询出数据并缓存 ====");
        accountDao1.getAll().forEach(System.out::println);
        sqlSession.commit();
        System.out.println("==== 第二次执行，查询出缓存数据 ====");
        accountDao2.getAll().forEach(System.out::println);
        sqlSession.commit();
    }
}

实现效果

整合 Redis

使用 Redis 作为 MyBatis 的二级缓存，即将查询结果缓存到 Redis 中，从而避免了频繁地访问数据库。通过 Redis 的高性能和可扩展性，可以有效地提高系统的性能和可伸缩性。

使用 Redis 作为 MyBatis 的二级缓存有以下几个好处：

性能提升: Redis 是一个高性能的内存数据库，具有快速的读写速度和低延迟的特性。将查询结果缓存到 Redis 中可以大大加快数据的访问速度，减少了对数据库的频繁访问，从而提升了系统的整体性能。
减轻数据库压力: 将查询结果缓存到 Redis 中可以减轻数据库的压力，特别是在高并发的场景下。通过减少数据库的访问次数，可以降低数据库的负载，提高数据库的性能和稳定性。
分布式支持: Redis 支持分布式部署，可以搭建多个 Redis 节点来构建一个高可用的缓存集群。这样可以保证缓存的高可用性和可扩展性，同时还能够通过分片和复制等技术来提高缓存的吞吐量和容量。
数据持久化: Redis 支持数据持久化，可以将缓存数据持久化到磁盘中，以防止数据丢失。这样即使发生系统故障或者重启，缓存数据也不会丢失，保证了系统的数据一致性和可靠性。
灵活性和扩展性: Redis 提供了丰富的数据结构和功能，支持字符串、哈希、列表、集合、有序集合等数据类型，可以满足不同场景下的缓存需求。同时，通过 Redis 的丰富的配置选项和扩展机制，可以灵活地定制和扩展缓存功能，满足不同项目的需求。

手写实现

添加依赖

<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>4.2.3</version>
</dependency>
<dependency>
      <groupId>org.apache.commons</groupId>
      <artifactId>commons-lang3</artifactId>
      <version>3.12.0</version>
</dependency>

Jedis 工具类

/**
 * @author 薛伟
 */
public class JedisUtil {
    private static final JedisPool jedisPool;
    static {
        JedisPoolConfig config = new JedisPoolConfig();
        config.setMaxIdle(5);
        config.setMaxTotal(50);
        config.setMaxWait(Duration.ofMinutes(5));
        // 这里最好是将配置写在配置文件中
        jedisPool = new JedisPool(config, "*.*.*.*", 6379);
    }
    /**
     * 获取客户端
     */
    public static Jedis getJedis() {
        return jedisPool.getResource();
    }
    /**
     * 关闭客户端
     */
    public static void close(Jedis jedis) {
        jedis.close();
    }
}

自定义 RedisCache

/**
 * 自定义开发 Redis 三级缓存
 * 存储数据的时候将 Key 和 Value 都转为 byte[]，提升效率
 * 需要缓存的 Key 和 Value 都实现序列化接口
 *
 * @author 薛伟
 */
@Slf4j
public class RedisCache implements Cache {
    /**
     * 缓存的唯一标识
     */
    private final String id;
    /**
     * Redis 客户端
     */
    private Jedis jedis;
    public RedisCache(String id) {
        this.id = id;
    }
    @Override
    public String getId() {
        return id;
    }
    @Override
    public void putObject(Object key, Object value) {
        log.info("设置 Redis 缓存：key {}", key);
        byte[] keyBytes = SerializationUtils.serialize((Serializable) key);
        byte[] valueBytes = SerializationUtils.serialize((Serializable) value);
        jedis = JedisUtil.getJedis();
        jedis.set(keyBytes, valueBytes);
        JedisUtil.close(jedis);
    }
    @Override
    public Object getObject(Object key) {
        byte[] keyBytes = SerializationUtils.serialize((Serializable) key);
        jedis = JedisUtil.getJedis();
        byte[] bytes = jedis.get(keyBytes);
        if (bytes == null) {
            return null;
        }
        Object deserialize = SerializationUtils.deserialize(bytes);
        JedisUtil.close(jedis);
        log.info("获取到 Redis 缓存：key {}", key);
        return deserialize;
    }
    @Override
    public Object removeObject(Object key) {
        Object object = getObject(key);
        if (object == null) {
            return null;
        }
        byte[] keyBytes = SerializationUtils.serialize((Serializable) key);
        jedis = JedisUtil.getJedis();
        jedis.del(keyBytes);
        JedisUtil.close(jedis);
        log.info("删除到 Redis 缓存：key {}", key);
        return null;
    }
    @Override
    public void clear() {
        jedis = JedisUtil.getJedis();
        jedis.flushDB();
        JedisUtil.close(jedis);
    }
    @Override
    public int getSize() {
        jedis = JedisUtil.getJedis();
        int size = (int) jedis.dbSize();
        JedisUtil.close(jedis);
        return size;
    }
    @Override
    public ReadWriteLock getReadWriteLock() {
        return null;
    }
}

Mapper 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">
<!-- 配置 namespace -->
<mapper namespace="world.xuewei.mybatis.dao.Account1Dao">
    <!-- 需要明确指定此标签，表示开启二级缓存 -->
    <cache type="world.xuewei.cache.RedisCache"/>
    <!-- useCache="true" 可以省略 -->
    <select id="getAll" resultType="Account">
        select * from account
    </select>
</mapper>

测试程序

public class Cache3Test {
    private SqlSession sqlSession;
    @Before
    public void before() throws IOException {
        InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        sqlSession = sessionFactory.openSession();
    }
    /**
     * 验证二级缓存，多个 SqlSession 有效
     */
    @Test
    public void testGetAll() {
        Account1Dao accountDao1 = sqlSession.getMapper(Account1Dao.class);
        Account1Dao accountDao2 = sqlSession.getMapper(Account1Dao.class);
        System.out.println("==== 第一次执行，查询出数据并缓存 ====");
        accountDao1.getAll().forEach(System.out::println);
        sqlSession.commit();
        System.out.println("==== 第二次执行，查询出缓存数据 ====");
        accountDao2.getAll().forEach(System.out::println);
        sqlSession.commit();
    }
}

实现效果

整合现有方案

添加依赖

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

配置文件

在 resources 目录下创建 redis 配置文件：

host=127.0.0.1
port=6379

Mapper 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">
<!-- 配置 namespace -->
<mapper namespace="world.xuewei.mybatis.dao.Account1Dao">
    <!-- 需要明确指定此标签，表示开启二级缓存 -->
    <cache type="org.mybatis.caches.redis.RedisCache"/>
    <!-- useCache="true" 可以省略 -->
    <select id="getAll" resultType="Account">
        select * from account
    </select>
</mapper>

实现的效果的测试程序都是一样的，我这里就不重复描述了。

MyBatis三级缓存实战：高级缓存策略的实现与应用

三级缓存

整合 EhCache

添加依赖

配置文件

Mapper XML 配置

测试程序

实现效果

整合 Redis

手写实现

添加依赖

Jedis 工具类

自定义 RedisCache

Mapper XML 配置

测试程序

实现效果

整合现有方案

添加依赖

配置文件

Mapper XML 配置

热门文章

最新文章

相关课程

相关电子书