<!-- MyBatis核心依賴(lài) -->
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.3.0</version>
</dependency>

<!-- Redis緩存依賴(lài)（MyBatis官方適配） -->
<dependency>
    <groupId>org.mybatis.caches</groupId>
    <artifactId>mybatis-redis</artifactId>
    <version>1.0.0-beta2</version>
</dependency>

<!-- Redis客戶(hù)端 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

# Redis服務(wù)器地址
redis.host=192.168.1.100
# Redis端口
redis.port=6379
# 連接超時(shí)時(shí)間（毫秒）
redis.timeout=2000
# Redis密碼（無(wú)密碼則留空）
redis.password=your_redis_password
# 數(shù)據(jù)庫(kù)索引（默認(rèn)0）
redis.database=1
# 緩存默認(rèn)過(guò)期時(shí)間（毫秒，30分鐘）
redis.default.expiration=1800000

package com.example.entity;

import lombok.Data;
import java.io.Serializable;
import java.time.LocalDateTime;

/**
 * 用戶(hù)實(shí)體類(lèi)（必須實(shí)現(xiàn)Serializable）
 */
@Data
public class User implements Serializable {
    // 序列化版本號(hào)（避免反序列化沖突）
    private static final long serialVersionUID = 1L;
    
    private Long id;
    private String username;
    private String email;
    private LocalDateTime createTime;
}

<?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">

<mapper namespace="com.example.mapper.UserMapper">
    <!-- 配置Redis作為二級(jí)緩存 -->
    <cache 
        type="org.mybatis.caches.redis.RedisCache"  <!-- 指定Redis緩存實(shí)現(xiàn)類(lèi) -->
        eviction="LRU"  <!-- 緩存淘汰策略：最近最少使用 -->
        flushInterval="300000"  <!-- 自動(dòng)刷新間隔（5分鐘） -->
        size="1000"  <!-- 最大緩存對(duì)象數(shù)量 -->
        readOnly="false"/>  <!-- 非只讀（需序列化） -->

    <!-- 查詢(xún)語(yǔ)句：默認(rèn)使用二級(jí)緩存 -->
    <select id="selectById" resultType="com.example.entity.User">
        SELECT id, username, email, create_time AS createTime
        FROM t_user
        WHERE id = #{id}
    </select>

    <!-- 更新語(yǔ)句：默認(rèn)觸發(fā)緩存清空（flushCache=true） -->
    <update id="update">
        UPDATE t_user
        SET username = #{username}, email = #{email}
        WHERE id = #{id}
    </update>
</mapper>

mybatis:
  configuration:
    cache-enabled: true  # 全局啟用二級(jí)緩存（默認(rèn)true）
  mapper-locations: classpath:mapper/*.xml  # 指定Mapper.xml路徑

@Slf4j
@Service
public class UserService {
    @Autowired
    private UserMapper userMapper;

    /**
     * 查詢(xún)用戶(hù)：優(yōu)先從Redis緩存獲取
     */
    public User getUserById(Long id) {
        if (Objects.isNull(id)) {
            log.warn("用戶(hù)ID為空");
            return null;
        }
        User user = userMapper.selectById(id);
        log.info("查詢(xún)用戶(hù)結(jié)果：{}", user);
        return user;
    }

    /**
     * 更新用戶(hù)：觸發(fā)Redis緩存清空
     */
    @Transactional
    public void updateUser(User user) {
        if (Objects.isNull(user) || Objects.isNull(user.getId())) {
            log.warn("用戶(hù)信息不完整");
            return;
        }
        int rows = userMapper.update(user);
        log.info("更新用戶(hù)影響行數(shù)：{}", rows);
        // 事務(wù)提交后，MyBatis會(huì)自動(dòng)清空Redis中該Mapper的緩存
    }
}

package com.example.cache;

import org.mybatis.caches.redis.RedisCache;
import java.util.UUID;

/**
 * 自定義Redis緩存，添加應(yīng)用前綴避免鍵沖突
 */
public class CustomRedisCache extends RedisCache {
    // 應(yīng)用唯一標(biāo)識(shí)（避免多應(yīng)用共用Redis時(shí)鍵沖突）
    private static final String APP_PREFIX = "myapp:";

    public CustomRedisCache(String id) {
        super(id);
    }

    /**
     * 重寫(xiě)緩存鍵，添加應(yīng)用前綴
     */
    @Override
    public Object getObject(Object key) {
        String cacheKey = APP_PREFIX + key.toString();
        return super.getObject(cacheKey);
    }

    @Override
    public void putObject(Object key, Object value) {
        String cacheKey = APP_PREFIX + key.toString();
        super.putObject(cacheKey, value);
    }

    @Override
    public Object removeObject(Object key) {
        String cacheKey = APP_PREFIX + key.toString();
        return super.removeObject(cacheKey);
    }
}

<cache type="com.example.cache.CustomRedisCache"/>

/**
 * 手動(dòng)刪除指定用戶(hù)的緩存
 */
public void deleteUserCache(Long userId) {
    // 獲取UserMapper的緩存對(duì)象
    Cache cache = sqlSessionFactory.getConfiguration().getCache("com.example.mapper.UserMapper");
    if (Objects.nonNull(cache)) {
        // 構(gòu)造緩存鍵（需與MyBatis生成規(guī)則一致）
        // 鍵格式：namespace + "::" + SQLID + "::" + 參數(shù)
        String cacheKey = "com.example.mapper.UserMapper::selectById::" + userId;
        cache.removeObject(cacheKey);
        log.info("手動(dòng)刪除用戶(hù)緩存，key: {}", cacheKey);
    }
}

@Transactional
public void updateUserWithDelayDelete(User user) {
    // 1. 更新數(shù)據(jù)庫(kù)
    userMapper.update(user);
    // 2. 第一次刪除緩存（事務(wù)提交后執(zhí)行）
    transactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
        @Override
        public void afterCommit() {
            // 事務(wù)提交后刪除緩存
            deleteUserCache(user.getId());
            
            // 3. 延遲1秒后第二次刪除（避免更新前的請(qǐng)求仍讀取舊緩存）
            CompletableFuture.runAsync(() -> {
                try {
                    Thread.sleep(1000);
                    deleteUserCache(user.getId());
                } catch (InterruptedException e) {
                    log.error("延遲刪除緩存失敗", e);
                }
            });
        }
    });
}

package com.example.cache;

import com.fasterxml.jackson.databind.ObjectMapper;
import org.apache.ibatis.cache.Cache;
import org.springframework.data.redis.core.RedisTemplate;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class JsonRedisCache implements Cache {
    private final String id;
    private final ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    private final RedisTemplate<String, Object> redisTemplate;
    private final ObjectMapper objectMapper = new ObjectMapper();

    public JsonRedisCache(String id) {
        this.id = id;
        // 注入RedisTemplate（實(shí)際需通過(guò)Spring上下文獲?。?
        this.redisTemplate = SpringContextHolder.getBean(RedisTemplate.class);
    }

    @Override
    public String getId() { return id; }

    @Override
    public void putObject(Object key, Object value) {
        try {
            String jsonValue = objectMapper.writeValueAsString(value);
            redisTemplate.opsForValue().set(key.toString(), jsonValue, 30, TimeUnit.MINUTES);
        } catch (Exception e) {
            log.error("緩存序列化失敗", e);
        }
    }

    @Override
    public Object getObject(Object key) {
        try {
            String jsonValue = (String) redisTemplate.opsForValue().get(key.toString());
            if (StringUtils.hasText(jsonValue)) {
                // 根據(jù)實(shí)際類(lèi)型反序列化（簡(jiǎn)化示例）
                return objectMapper.readValue(jsonValue, User.class);
            }
        } catch (Exception e) {
            log.error("緩存反序列化失敗", e);
        }
        return null;
    }

    @Override
    public Object removeObject(Object key) {
        redisTemplate.delete(key.toString());
        return null;
    }

    @Override
    public void clear() {
        // 清空當(dāng)前namespace的所有緩存（需批量刪除匹配鍵）
    }

    @Override
    public int getSize() { return 0; }

    @Override
    public ReadWriteLock getReadWriteLock() { return readWriteLock; }
}