MyBatis 二级缓存问题与避坑#

public interface Cache {
    String getId();                          // Mapper 的 namespace
    void putObject(Object key, Object value);
    Object getObject(Object key);
    Object removeObject(Object key);
    void clear();                            // 清空缓存
    int getSize();                           // 缓存大小
    default void lock() {}                   // 锁（空实现）
    default void unlock() {}
    default void readWriteDataSource() {}    // 读写数据源
}

// 装饰器链（cache 标签的 eviction 属性决定用哪个）
public class LruCache implements Cache {    // eviction="LRU"，默认
    private final Cache delegate;
    private Map<Object, Object> keyMap;    // LRU 淘汰

    @Override
    public void putObject(Object key, Object value) {
        delegate.putObject(key, value);
        cycleKeyMap(key);
    }

    private void cycleKeyMap(Object key) {
        keyMap.put(key, key);
        if (keyMap.size() > size) {
            // 淘汰最久未使用的
            Object oldestKey = keyMap.keySet().iterator().next();
            delegate.removeObject(oldestKey);
        }
    }
}

// 其他装饰器
public class FifoCache implements Cache {}   // 先进先出
public class SoftCache implements Cache {}   // 软引用，内存不足时回收
public class WeakCache implements Cache {}    // 弱引用，GC 时回收
public class ScheduledCache implements Cache {} // 定期清空
public class SerializedCache implements Cache {} // 序列化后存储
public class SynchronizedCache implements Cache {} // 线程安全

// 场景：订单主表和明细表关联查询，存入二级缓存
// Mapper: OrderMapper.xml
<select id="findOrderWithDetail" resultMap="OrderDetailMap" useCache="true">
    SELECT o.*, d.* FROM orders o
    LEFT JOIN order_detail d ON o.id = d.order_id
    WHERE o.id = #{id}
</select>

// 用户 A 更新订单主表
<update id="updateOrder">
    UPDATE orders SET status = 'PAID' WHERE id = #{id}
</update>

// 问题：updateOrder 会清空 OrderMapper 的二级缓存
// 但 findOrderWithDetail 的缓存还在！
// 其他用户 B 查询时，命中的是旧的关联数据

// TransactionalCache.putObject 的源码
public void putObject(Object key, Object value) {
    // 关键：不是直接 put 到 delegate，而是放入 pending map
    entriesToAddOnCommit.put(key, value);
}

// 只有 commit 时才真正写入
public void commit() {
    if (clearOnCommit) {
        delegate.clear();
    }
    // 把 pending 数据刷入底层缓存
    delegate.putObject(entriesToAddOnCommit);
    entriesToAddOnCommit.clear();
}

public class RedisCache implements Cache {
    private final String id;
    private final RedisTemplate<Object, Object> redisTemplate;

    public RedisCache(String id) {
        this.id = id;
        // 懒加载 RedisTemplate
        this.redisTemplate = RedisTemplateBuilder.getTemplate();
    }

    @Override
    public void putObject(Object key, Object value) {
        // 序列化后存入 Redis，过期时间设为 1 小时
        redisTemplate.opsForValue().set(
            id + ":" + key.toString(),
            serialize(value),
            1, TimeUnit.HOURS
        );
    }

    @Override
    public Object getObject(Object key) {
        byte[] bytes = redisTemplate.opsForValue().get(id + ":" + key.toString());
        return bytes == null ? null : deserialize(bytes);
    }

    @Override
    public void clear() {
        // 删除该 namespace 下的所有缓存
        Set<String> keys = redisTemplate.keys(id + ":*");
        if (keys != null && !keys.isEmpty()) {
            redisTemplate.delete(keys);
        }
    }
}

// SqlSession1：开启事务，修改数据，未 commit
SqlSession session1 = factory.openSession();
OrderMapper mapper1 = session1.getMapper(OrderMapper.class);
Order order = mapper1.findById(1L);
order.setStatus("PAID");
mapper1.updateOrder(order);
// 此时数据已修改但未 commit

// SqlSession2：在另一个 session 中查询
SqlSession session2 = factory.openSession();
OrderMapper mapper2 = session2.getMapper(OrderMapper.class);
// 二级缓存的 getObject 先查 delegate（已提交数据），再查 pending
Order cached = mapper2.findById(1L);
// 不会读到 SqlSession1 未 commit 的数据
// 因为 putObject 时先放入了 pending，commit 后才写入 delegate

// 问题核心：OrderMapper 更新了 orders 表，但 OrderDetailMapper 的缓存不会失效
// 假设用户查过这个关联查询
List<OrderDetail> details = orderDetailMapper.findByOrderId(orderId);
// 存入 OrderDetailMapper 的二级缓存

// 之后 OrderMapper 更新了 orders 表
orderMapper.updateOrder(order);
// 只清空 OrderMapper 的缓存，OrderDetailMapper 的缓存还在！

// 再次查询，命中旧缓存
List<OrderDetail> oldDetails = orderDetailMapper.findByOrderId(orderId);
// 返回的是旧数据！

// MyBatis 提供了缓存命中率统计
// 查看某个 Mapper 的缓存命中率
// 在日志中会打印：Cache Hit Ratio [com.xxx.OrderMapper]: 0.85

// 自定义 Cache 实现，基于版本号的乐观锁
public class VersionedCache implements Cache {
    private final Cache delegate;
    private final Map<Object, VersionedValue> versionMap = new ConcurrentHashMap<>();

    @Override
    public void putObject(Object key, Object value) {
        VersionedValue vv = new VersionedValue(value, version++);
        versionMap.put(key, vv);
        delegate.putObject(key, vv);
    }

    @Override
    public Object getObject(Object key) {
        VersionedValue vv = (VersionedValue) delegate.getObject(key);
        if (vv == null) return null;
        // 校验版本号，不一致时强制刷新
        if (vv.version < versionMap.get(key).version) {
            delegate.removeObject(key);
            return null;
        }
        return vv.value;
    }
}