MyBatis缓存机制与性能优化实战

1. MyBatis缓存机制深度解析

作为Java生态中最受欢迎的ORM框架之一，MyBatis的缓存设计直接影响着应用性能表现。我们先拆解其缓存架构的核心组成：

1.1 一级缓存工作原理

一级缓存是MyBatis默认开启的会话级缓存，其实现原理值得深入探讨：

java复制// 源码示例：BaseExecutor类中的本地缓存实现
public abstract class BaseExecutor implements Executor {
    protected PerpetualCache localCache;
    
    public <E> List<E> query(...) {
        // 生成缓存Key的逻辑
        CacheKey key = createCacheKey(...);
        // 查询前先检查本地缓存
        list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;
        if (list != null) {
            handleLocallyCachedOutputParameters(...);
        } else {
            list = queryFromDatabase(...);
            localCache.putObject(key, list);
        }
    }
}

这个设计带来了几个重要特性：

• 生命周期：与SqlSession绑定，会话结束即失效
• 作用范围：同一个SqlSession内的重复查询
• 失效机制：执行INSERT/UPDATE/DELETE操作时自动清空

实际踩坑：在分布式环境下，一级缓存可能导致不同节点数据不一致。我们曾遇到过一个生产案例：服务A更新数据后，服务B由于使用不同SqlSession仍读取到旧值，最终通过强制设置cacheEnabled=false解决。

1.2 二级缓存实现机制

二级缓存提供了更广范围的缓存共享：

xml复制<!-- 开启二级缓存的配置示例 -->
<cache
  eviction="LRU"
  flushInterval="60000"
  size="512"
  readOnly="true"/>

其工作流程可分为四个阶段：

1. 事务提交时写入：只有sqlSession.commit()后才会同步到二级缓存
2. 序列化存储：默认使用JVM堆内存，可通过集成Redis等实现分布式缓存
3. 多会话共享：所有SqlSession实例共享同一缓存区域
4. 策略化清理：支持LRU/FIFO/SOFT等淘汰算法

1.3 缓存Key生成算法

理解CacheKey的生成对排查缓存问题至关重要：

java复制// 关键参数影响缓存Key的哈希值
public class CacheKey {
    private static final int DEFAULT_MULTIPLIER = 37;
    private int multiplier;
    private int hashcode;
    private long checksum;
    private int count;
    private List<Object> updateList;
    
    public void update(Object object) {
        int baseHashCode = object == null ? 1 : object.hashCode();
        count++;
        checksum += baseHashCode;
        baseHashCode *= count;
        hashcode = multiplier * hashcode + baseHashCode;
        updateList.add(object);
    }
}

影响Key的主要因素包括：

• MappedStatement的ID
• 分页参数offset和limit
• 实际传入的parameterObject
• 环境变量（如datasourceId）

2. 性能瓶颈诊断方法论

2.1 监控指标体系建设

建立完整的监控体系是优化的前提：

2.2 典型问题模式识别

通过多年实战总结出这些常见反模式：

1. N+1查询问题

sql复制<!-- 错误示例 -->
<select id="findUser" resultMap="userMap">
    SELECT * FROM users WHERE id = #{id}
</select>

<resultMap id="userMap">
    <collection property="orders" select="findOrdersByUserId" column="id"/>
</resultMap>

优化方案：使用join查询替代多次查询

2. 大对象缓存

java复制// 典型错误：缓存10MB的报表数据
@Cacheable(value = "reportCache", key = "#date")
public Report generateDailyReport(Date date) {
    // 生成报表逻辑...
}

优化方案：拆分缓存或改用文件存储

3. 缓存穿透防护

java复制// 使用布隆过滤器预防缓存穿透
public class BloomFilterCacheDecorator implements Cache {
    private final Cache delegate;
    private final BloomFilter<String> filter;

    public Object getObject(Object key) {
        if (!filter.mightContain(key.toString())) {
            return null;
        }
        return delegate.getObject(key);
    }
}

3. 多级缓存优化实战

3.1 本地缓存调优

Caffeine与MyBatis的集成示例：

java复制public class CaffeineCache implements Cache {
    private final com.github.benmanes.caffeine.cache.Cache<Object, Object> cache;

    public CaffeineCache(String id) {
        this.cache = Caffeine.newBuilder()
            .maximumSize(1000)
            .expireAfterWrite(10, TimeUnit.MINUTES)
            .recordStats()
            .build();
    }

    @Override
    public Object getObject(Object key) {
        return cache.getIfPresent(key);
    }
}

关键参数对比实验：

3.2 分布式缓存集成

Redis二级缓存实现要点：

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

    public void putObject(Object key, Object value) {
        redisTemplate.opsForValue().set(
            key.toString(), 
            value,
            Duration.ofMinutes(30));
    }
    
    public Object getObject(Object key) {
        return redisTemplate.opsForValue().get(key.toString());
    }
}

序列化方案性能对比：

3.3 热点数据预加载

定时预热实现方案：

java复制@Scheduled(cron = "0 0 6 * * ?")
public void preloadHotData() {
    List<Long> hotItemIds = itemMapper.selectHotItems();
    hotItemIds.parallelStream().forEach(id -> {
        itemMapper.selectById(id); // 触发缓存加载
    });
}

预热效果对比：

4. 高级优化技巧

4.1 细粒度缓存控制

注解驱动缓存方案：

java复制@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface CustomCache {
    String region() default "default";
    int ttl() default 300;
    CacheType type() default CacheType.BOTH;
}

public class CacheInterceptor implements Interceptor {
    @Override
    public Object intercept(Invocation invocation) {
        CustomCache annotation = invocation.getMethod().getAnnotation(CustomCache.class);
        if (annotation != null) {
            CacheKey key = createKey(invocation);
            Cache cache = getCache(annotation.region());
            Object value = cache.getObject(key);
            if (value == null) {
                value = invocation.proceed();
                cache.putObject(key, value);
            }
            return value;
        }
        return invocation.proceed();
    }
}

4.2 缓存一致性保障

基于binlog的最终一致性方案：

python复制# 伪代码示例：Canal监听数据库变更
def handle_binlog_event(event):
    if event.type in (INSERT, UPDATE, DELETE):
        table = event.table
        redis.delete(f"mybatis:{table}:*")  # 通配删除相关缓存
        kafka.send("cache-evict", {"table": table})

4.3 动态缓存策略

根据QPS自动调整的智能缓存：

java复制public class AdaptiveCache implements Cache {
    private final Cache hotCache;  // Caffeine
    private final Cache coldCache; // Redis

    public Object getObject(Object key) {
        Object value = hotCache.getObject(key);
        if (value == null) {
            value = coldCache.getObject(key);
            if (value != null && isHotKey(key)) {
                hotCache.putObject(key, value);
            }
        }
        return value;
    }
    
    private boolean isHotKey(Object key) {
        // 基于滑动窗口算法判断热点
    }
}

5. 性能对比测试

5.1 测试环境配置

JMeter压测方案设计：

xml复制<ThreadGroup>
    <numThreads>500</numThreads>
    <rampUp>60</rampUp>
    <loopCount>1000</loopCount>
</ThreadGroup>

<JDBCRequest>
    <dataSource>mybatisDS</dataSource>
    <query>SELECT * FROM products WHERE id=${__Random(1,10000)}</query>
</JDBCRequest>

5.2 优化前后对比

测试结果数据：

5.3 内存占用分析

JVM堆内存使用对比：

6. 生产环境部署指南

6.1 灰度发布方案

缓存策略的滚动更新步骤：

1. 新节点部署时标记为v2版本
2. 配置中心下发双缓存策略
3. 流量逐步切量观察监控
4. 全量切换后清理旧缓存

6.2 熔断降级策略

Hystrix配置示例：

java复制@HystrixCommand(
    fallbackMethod = "getFromLocalCache",
    commandProperties = {
        @HystrixProperty(name="execution.isolation.thread.timeoutInMilliseconds", value="500"),
        @HystrixProperty(name="circuitBreaker.requestVolumeThreshold", value="20")
    }
)
public Product getProductWithRemoteCache(Long id) {
    // 访问分布式缓存
}

6.3 监控告警配置

关键告警规则示例：

yaml复制rules:
- alert: HighCacheMissRate
  expr: rate(mybatis_cache_misses_total[5m]) / rate(mybatis_cache_requests_total[5m]) > 0.3
  for: 10m
  labels:
    severity: warning
  annotations:
    summary: "High cache miss rate detected"

经过这些系统化的优化措施，我们在实际项目中实现了查询性能提升15倍的效果，同时将缓存相关故障率降低了90%。特别需要注意的是，任何缓存策略都需要结合具体业务场景进行调优，没有放之四海而皆准的银弹方案。