Java缓存读写提速案例实操

wen java案例 2026-06-26 34

本文目录导读：

Java缓存读写提速案例实操

目录导读
为什么需要缓存？——Java应用性能瓶颈分析
缓存选型：本地缓存 vs 分布式缓存
案例实操（一）：使用Caffeine本地缓存加速高频读接口
案例实操（二）：Redis分布式缓存解决数据库压力
缓存读写陷阱：雪崩、穿透、击穿的预防与解决
性能对比数据：缓存前后延迟与吞吐量变化
常见问题与解答（FAQ）
总结与最佳实践建议

目录导读

为什么需要缓存？——Java应用性能瓶颈分析
缓存选型：本地缓存 vs 分布式缓存
案例实操（一）：使用Caffeine本地缓存加速高频读接口
案例实操（二）：Redis分布式缓存解决数据库压力
缓存读写陷阱：雪崩、穿透、击穿的预防与解决
性能对比数据：缓存前后延迟与吞吐量变化
常见问题与解答（FAQ）
总结与最佳实践建议

为什么需要缓存？——Java应用性能瓶颈分析

在现代Java企业级应用中，数据库查询往往是最大的性能瓶颈，一个用户详情查询接口，如果每次请求都直接访问MySQL，随着并发量上升，数据库连接池会迅速耗尽,响应时间从10ms飙升到500ms以上。

缓存的核心作用：

将热点数据存储在内存中，读取速度提升100倍以上（内存纳秒级 vs 磁盘毫秒级）
减少数据库连接数，降低I/O开销
提升系统吞吐量，支撑高并发场景

典型场景：

电商商品详情页
用户登录状态Session存储
配置信息、字典数据

问答1：为什么不用HashMap做缓存？
答：HashMap缺乏过期策略、淘汰机制、并发控制，而Caffeine、Redis等专业缓存组件提供了TTL、LRU淘汰、读写锁等能力,避免内存溢出和数据不一致。

缓存选型：本地缓存 vs 分布式缓存

维度	本地缓存（Caffeine/Guava）	分布式缓存（Redis）
存储位置	JVM堆内	独立服务器内存
读写速度	纳秒级	毫秒级（网络开销）
数据共享	单JVM内	多服务实例共享
容量限制	受JVM堆大小限制	可扩展至数十GB
典型场景	单机应用、配置缓存	微服务、Session共享

选型原则：

单机应用或无状态服务 → 本地缓存
多实例集群需要数据一致性 → 分布式缓存

案例实操（一）：使用Caffeine本地缓存加速高频读接口

场景描述

用户查询热门文章列表（每天访问量百万级），数据库每次查询耗时约80ms，且数据更新频率低（每半小时更新一次）。

代码实现（Spring Boot + Caffeine）

@Component
public class HotArticleCache {
    private final Cache<String, List<Article>> cache = Caffeine.newBuilder()
            .expireAfterWrite(30, TimeUnit.MINUTES)  // 写入后30分钟过期
            .maximumSize(10000)
            .recordStats()
            .build();
    @Autowired
    private ArticleRepository articleRepository;
    public List<Article> getHotArticles() {
        return cache.get("hot_articles", key -> {
            // 缓存未命中时从数据库加载
            List<Article> articles = articleRepository.findTop10ByOrderByHitsDesc();
            System.out.println("[Caffeine] 缓存未命中，从数据库加载数据");
            return articles;
        });
    }
    public void evictHotArticles() {
        cache.invalidate("hot_articles");
    }
}

效果验证

// 测试代码
long start = System.currentTimeMillis();
List<Article> articles = hotArticleCache.getHotArticles();
System.out.println("首次查询耗时：" + (System.currentTimeMillis() - start) + "ms");
start = System.currentTimeMillis();
articles = hotArticleCache.getHotArticles();
System.out.println("缓存命中查询耗时：" + (System.currentTimeMillis() - start) + "ms");

输出：

首次查询耗时：84ms  
缓存命中查询耗时：2ms

问答2：Caffeine的expireAfterWrite和expireAfterAccess区别？

答：expireAfterWrite 从写入开始计时固定时长后过期；expireAfterAccess 从最后一次读/写开始计时，适合“读活跃数据”,前者更适合定期刷新的场景。

案例实操（二）：Redis分布式缓存解决数据库压力

场景描述

电商系统的库存查询接口，多个微服务实例需要共享库存数据,且支持快速失效。

代码实现（Spring Boot + Redis + Lettuce）

@Component
public class StockCacheService {
    @Autowired
    private StringRedisTemplate redisTemplate;
    private static final String STOCK_PREFIX = "stock:";
    public Integer getStock(Long productId) {
        String key = STOCK_PREFIX + productId;
        // 1. 先读缓存
        String cacheValue = redisTemplate.opsForValue().get(key);
        if (cacheValue != null) {
            return Integer.parseInt(cacheValue);
        }
        // 2. 缓存未命中，查数据库（带分布式锁防止缓存击穿）
        String lockKey = "lock:stock:" + productId;
        Boolean locked = redisTemplate.opsForValue().setIfAbsent(lockKey, "1", 5, TimeUnit.SECONDS);
        if (Boolean.TRUE.equals(locked)) {
            try {
                // 再次检查缓存（双重检查锁）
                cacheValue = redisTemplate.opsForValue().get(key);
                if (cacheValue != null) {
                    return Integer.parseInt(cacheValue);
                }
                // 从数据库查询（伪代码）
                Integer stock = stockRepository.queryStock(productId);
                if (stock != null) {
                    redisTemplate.opsForValue().set(key, String.valueOf(stock), 10, TimeUnit.MINUTES);
                }
                return stock;
            } finally {
                redisTemplate.delete(lockKey);  // 释放锁
            }
        } else {
            // 等待锁或降级
            Thread.sleep(100);
            return getStock(productId);  // 重试
        }
    }
}