构建本地缓存（如Caffeine）+ 分布式缓存（如Redis集群）的二级缓存架构

在构建高可用、高性能的分布式系统时，采用"本地缓存（如Caffeine） + 分布式缓存（如Redis集群）"的二级缓存架构，确实是一种非常有效的策略。它能够显著提升系统性能、缓解数据库压力，并增强系统的容错能力。下面我将为您详细解析这套方案的实现细节、核心挑战以及最佳实践。

🎯 二级缓存架构概述

二级缓存的核心思想是利用不同层级缓存的优势，形成互补。本地缓存（L1） 提供极快的访问速度（微秒级），但容量有限且无法在应用实例间共享；分布式缓存（L2，如Redis集群） 提供共享存储和更大的容量，但受网络开销影响，速度稍慢（毫秒级）。两者结合，既满足了低延迟要求，又保证了数据在分布式环境下的可用性。

其基本工作流程，即数据读取顺序，可以概括为：L1 → L2 → 数据库。具体流程如下：

css 复制代码

flowchart TD
    A[客户端请求] --> B{本地缓存<br>L1 Cache 是否存在?}
    B -- 是， 命中 ⚡ --> C[直接返回数据]
    B -- 否， 未命中 --> D{Redis缓存<br>L2 Cache 是否存在?}
    D -- 是 --> E[回填至本地缓存 L1] --> C
    D -- 否 --> F[查询数据库] --> G[同时回填至 L2 和 L1] --> C

🛠️ 核心实现方案

以下是一种基于 Spring Boot 的常用实现方式。

1. 项目依赖

首先，在 pom.xml中引入必要的依赖。

xml 复制代码

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
    <groupId>com.github.ben-manes.caffeine</groupId>
    <artifactId>caffeine</artifactId>
</dependency>

2. 配置缓存实例

接着，分别配置 Caffeine 本地缓存和 RedisTemplate。

typescript 复制代码

@Configuration
public class CacheConfig {
    // 配置 Caffeine 本地缓存
    @Bean
    public Cache<String, Object> caffeineCache() {
        return Caffeine.newBuilder()
                .maximumSize(1000) // 控制内存占用
                .expireAfterWrite(10, TimeUnit.MINUTES) // 设置过期时间
                .recordStats() // 开启统计功能
                .build();
    }

    // 配置 RedisTemplate
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);
        // 设置序列化器，推荐使用JSON序列化
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        return template;
    }
}

3. 实现二级缓存工具类

这是最核心的部分，负责协调 L1 和 L2 的读写逻辑。

typescript 复制代码

@Component
public class TwoLevelCacheManager {
    @Autowired
    private Cache<String, Object> localCache; // Caffeine
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    private static final String REDIS_PREFIX = "cache:";

    public <T> T get(String key, Class<T> type, Supplier<T> loader) {
        // 1. 查询L1本地缓存
        Object value = localCache.getIfPresent(key);
        if (value != null) {
            return type.cast(value);
        }

        // 2. 查询L2分布式缓存(Redis)
        String redisKey = REDIS_PREFIX + key;
        value = redisTemplate.opsForValue().get(redisKey);
        if (value != null) {
            // 回填到L1本地缓存
            localCache.put(key, value);
            return type.cast(value);
        }

        // 3. 缓存均未命中，使用提供者（如数据库查询）加载数据
        T loadedValue = loader.get();
        if (loadedValue != null) {
            // 同时写入L2和L1，确保数据一致性
            redisTemplate.opsForValue().set(redisKey, loadedValue, Duration.ofMinutes(30));
            localCache.put(key, loadedValue);
        }
        return loadedValue;
    }

    public void evict(String key) {
        // 删除缓存时，需要同时清除L1和L2
        localCache.invalidate(key);
        String redisKey = REDIS_PREFIX + key;
        redisTemplate.delete(redisKey);
    }
}

4. 在Service中使用

typescript 复制代码

@Service
public class ProductService {
    @Autowired
    private TwoLevelCacheManager cacheManager;
    @Autowired
    private ProductRepository repository;

    public Product getProductById(Long id) {
        String cacheKey = "product:" + id;
        return cacheManager.get(cacheKey, Product.class, () -> {
            // 这里是数据加载器，当缓存未命中时，会执行此逻辑（如从数据库查询）
            return repository.findById(id).orElse(null);
        });
    }

    public void updateProduct(Product product) {
        // 更新数据库...
        repository.save(product);
        // 清除缓存
        String cacheKey = "product:" + product.getId();
        cacheManager.evict(cacheKey);
    }
}

⚠️ 核心挑战与解决方案

实现二级缓存架构时，需要特别关注以下几个问题：

缓存一致性

这是最大的挑战。当数据更新时，如何保证多个节点上的本地缓存（L1）和分布式缓存（L2）中的数据是同步的？
- 策略：采用 "先更新数据库，再删除缓存" 的策略。推荐结合 延迟双删 来应对高并发场景下的极端不一致情况。
- 同步机制 ：当某个节点执行写操作后，需要通过 发布/订阅机制（如 Redis Pub/Sub 或消息队列）广播消息，通知其他所有节点删除对应的本地缓存。这确保了其他节点在下次读取时会从 L2 获取最新数据。
缓存穿透、击穿与雪崩
- 穿透：查询一个不存在的数据。解决方案：缓存空值（并设置较短的过期时间），或使用布隆过滤器（Bloom Filter）进行初步判断。
- 击穿：某个热点 key 在失效的瞬间，大量请求击穿到数据库。解决方案：使用分布式互斥锁（Mutex Lock），保证只有一个线程去加载数据，其他线程等待。
- 雪崩：大量 key 在同一时间过期，导致请求全部落至数据库。解决方案：为 key 的过期时间添加随机值，避免同时过期。
内存控制

Caffeine 等本地缓存是基于 JVM 堆内存的，必须设置合理的 maximumSize或 expireAfterWrite/expireAfterAccess策略，防止内存溢出（OOM）。

💡 最佳实践建议

监控：开启 Caffeine 的 recordStats()功能，并监控缓存命中率，以便调整策略。
容量规划：根据业务热点数据量，为 L1 和 L2 设置不同的容量和过期时间。通常 L1 的过期时间应短于 L2，作为一道"保护层"。
故障隔离：二级缓存的一个巨大优势是，即使 Redis 集群完全宕机，系统依然可以依靠本地缓存提供部分服务，实现了故障隔离，增强了系统韧性。

通过上述方案，您可以构建一个既能应对高并发、低延迟需求，又能保证高可用性和数据一致性的稳健缓存系统。这套架构在实践中已被证明能将页面响应时间从百毫秒级别显著降低至几十甚至几毫秒，并大幅减轻数据库压力。