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>