详细介绍一下MyBatis的缓存机制

Key = HashMap<Object, Object> {
    "MappedStatementId": Mapper接口全类名+方法名（如com.example.mapper.UserMapper.selectById）,
    "SQL语句": 最终执行的SQL（含动态SQL拼接结果）,
    "参数": 查询参数（如id=1001）,
    "环境信息": 数据库连接环境（如数据源ID、事务状态）
}

// 1. 获取 SqlSession（默认不自动提交事务）
SqlSession sqlSession = sqlSessionFactory.openSession();
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

// 2. 第一次查询：访问数据库，结果存入一级缓存
User user1 = userMapper.selectById(1001); 
System.out.println(user1); // 数据库查询

// 3. 第二次查询：参数相同，直接从一级缓存获取
User user2 = userMapper.selectById(1001); 
System.out.println(user2); // 缓存命中，无数据库查询

// 4. 执行更新操作：触发一级缓存清空
userMapper.updateName(1001, "新名字");
sqlSession.commit();

// 5. 第三次查询：缓存已失效，重新访问数据库
User user3 = userMapper.selectById(1001); 
System.out.println(user3); // 数据库查询

// 6. 关闭 SqlSession：一级缓存销毁
sqlSession.close();

<configuration>
  <settings>
    <!-- 开启二级缓存总开关（关闭后所有 Mapper 的二级缓存都失效） -->
    <setting name="cacheEnabled" value="true"/>
  </settings>
</configuration>

<!-- UserMapper.xml -->
<mapper namespace="com.example.mapper.UserMapper">
  <!-- 开启二级缓存，配置缓存参数 -->
  <cache 
    eviction="LRU"          <!-- 缓存回收策略（默认 LRU） -->
    flushInterval="60000"    <!-- 缓存过期时间（毫秒，60秒） -->
    size="1024"              <!-- 缓存最大条目数（默认 1024） -->
    readOnly="true"          <!-- 是否只读（默认 false） -->
    blocking="false"         <!-- 是否阻塞（缓存未命中时等待其他线程查询结果，默认 false） -->
  />

  <!-- 单个查询方法可单独控制是否使用二级缓存（默认使用） -->
  <select id="selectById" resultType="User" useCache="true">
    select * from user where id = #{id}
  </select>

  <!-- 增删改方法可控制是否触发缓存清空（默认触发） -->
  <update id="updateName" flushCache="true">
    update user set name = #{name} where id = #{id}
  </update>
</mapper>

// 实体类实现 Serializable 接口
public class User implements Serializable {
  private Long id;
  private String name;
  // getter/setter...
}

// 1. 第一个 SqlSession：查询并写入二级缓存
SqlSession sqlSession1 = sqlSessionFactory.openSession();
UserMapper mapper1 = sqlSession1.getMapper(UserMapper.class);
User user1 = mapper1.selectById(1001); // 数据库查询，结果存入一级缓存+二级缓存
sqlSession1.close(); // 关闭 SqlSession 时，一级缓存销毁，二级缓存保留

// 2. 第二个 SqlSession：共享二级缓存
SqlSession sqlSession2 = sqlSessionFactory.openSession();
UserMapper mapper2 = sqlSession2.getMapper(UserMapper.class);
User user2 = mapper2.selectById(1001); // 二级缓存命中，无数据库查询
sqlSession2.close();

// 3. 第三个 SqlSession：执行更新操作，触发二级缓存清空
SqlSession sqlSession3 = sqlSessionFactory.openSession();
UserMapper mapper3 = sqlSession3.getMapper(UserMapper.class);
mapper3.updateName(1001, "新名字");
sqlSession3.commit(); // 提交事务，清空 UserMapper 的二级缓存
sqlSession3.close();

// 4. 第四个 SqlSession：缓存失效，重新查询
SqlSession sqlSession4 = sqlSessionFactory.openSession();
UserMapper mapper4 = sqlSession4.getMapper(UserMapper.class);
User user4 = mapper4.selectById(1001); // 二级缓存已失效，数据库查询
sqlSession4.close();

<!-- MyBatis 缓存接口 -->
<dependency>
  <groupId>org.mybatis</groupId>
  <artifactId>mybatis</artifactId>
  <version>3.5.13</version>
</dependency>
<!-- Redis 客户端 -->
<dependency>
  <groupId>redis.clients</groupId>
  <artifactId>jedis</artifactId>
  <version>4.4.6</version>
</dependency>
<!-- 序列化工具（可选，用于对象序列化） -->
<dependency>
  <groupId>com.alibaba</groupId>
  <artifactId>fastjson2</artifactId>
  <version>2.0.41</version>
</dependency>

import org.apache.ibatis.cache.Cache;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * 自定义 Redis 缓存实现
 */
public class RedisCache implements Cache {
  // 缓存 ID（对应 Mapper 的 namespace）
  private final String id;
  // Redis 连接池
  private final JedisPool jedisPool;
  // 读写锁（保证线程安全）
  private final ReadWriteLock readWriteLock = new ReentrantReadWriteLock();

  // 构造方法：MyBatis 会自动传入 Mapper 的 namespace 作为 id
  public RedisCache(String id) {
    if (id == null) {
      throw new IllegalArgumentException("Cache ID cannot be null");
    }
    this.id = id;
    // 初始化 Redis 连接池（实际开发中应通过配置文件读取参数）
    this.jedisPool = new JedisPool("localhost", 6379);
  }

  @Override
  public String getId() {
    return id; // 缓存唯一标识（必须返回 Mapper 的 namespace）
  }

  // 存入缓存：key 是 MyBatis 生成的缓存 Key，value 是查询结果
  @Override
  public void putObject(Object key, Object value) {
    try (Jedis jedis = jedisPool.getResource()) {
      // 序列化 key 和 value（使用 fastjson2）
      String redisKey = key.toString();
      String redisValue = com.alibaba.fastjson2.JSON.toJSONString(value);
      // 存入 Redis，设置过期时间（30分钟）
      jedis.setex(redisKey, 1800, redisValue);
    }
  }

  // 获取缓存：根据 key 查询 Redis
  @Override
  public Object getObject(Object key) {
    try (Jedis jedis = jedisPool.getResource()) {
      String redisKey = key.toString();
      String redisValue = jedis.get(redisKey);
      if (redisValue == null) {
        return null;
      }
      // 反序列化：根据实际返回类型转换（此处简化处理，实际需结合 TypeHandler）
      return com.alibaba.fastjson2.JSON.parseObject(redisValue, Object.class);
    }
  }

  // 移除缓存（MyBatis 内部很少调用，可空实现）
  @Override
  public Object removeObject(Object key) {
    try (Jedis jedis = jedisPool.getResource()) {
      return jedis.del(key.toString());
    }
  }

  // 清空缓存（增删改操作时触发）
  @Override
  public void clear() {
    try (Jedis jedis = jedisPool.getResource()) {
      // 模糊删除当前 Mapper 的所有缓存（key 前缀为 id + ":"）
      jedis.keys(id + ":*").forEach(jedis::del);
    }
  }

  // 获取缓存大小（可选实现）
  @Override
  public int getSize() {
    try (Jedis jedis = jedisPool.getResource()) {
      return Math.toIntExact(jedis.keys(id + ":*").size());
    }
  }

  // 获取读写锁（MyBatis 用于并发控制）
  @Override
  public ReadWriteLock getReadWriteLock() {
    return readWriteLock;
  }
}

<mapper namespace="com.example.mapper.UserMapper">
  <!-- 配置 Redis 缓存实现（替代默认缓存） -->
  <cache type="com.example.cache.RedisCache">
    <!-- 可自定义缓存参数（通过构造方法或 setter 注入） -->
  </cache>

  <!-- 查询方法使用 Redis 缓存 -->
  <select id="selectById" resultType="User" useCache="true">
    select * from user where id = #{id}
  </select>
</mapper>