基于Spring Boot的多级缓存架构实现

基于Spring Boot的多级缓存架构实现

以下是一个基于Spring Boot的多级缓存架构实现示例

---

多级缓存架构实现方案

1. 依赖配置（pom.xml）

1. <dependency>
2.     <groupId>org.springframework.boot</groupId>
3.     <artifactId>spring-boot-starter-cache</artifactId>
4. </dependency>
5. <dependency>
6.     <groupId>com.github.ben-manes.caffeine</groupId>
7.     <artifactId>caffeine</artifactId>
8. </dependency>
9. <dependency>
10.     <groupId>org.springframework.boot</groupId>
11.     <artifactId>spring-boot-starter-data-redis</artifactId>
12. </dependency>

复制代码

2. 缓存配置类

1. @Configuration
2. @EnableCaching
3. public class MultiLevelCacheConfig {
5.     // 一级缓存（本地缓存）
6.     @Bean
7.     public CacheManager caffeineCacheManager() {
8.         CaffeineCacheManager manager = new CaffeineCacheManager();
9.         manager.setCaffeine(Caffeine.newBuilder()
10.                 .maximumSize(1000)
11.                 .expireAfterWrite(30, TimeUnit.SECONDS)); // 本地缓存比Redis缓存更短
12.         return manager;
13.     }
15.     // 二级缓存（Redis缓存）
16.     @Bean
17.     public CacheManager redisCacheManager(RedisConnectionFactory factory) {
18.         RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
19.                 .entryTtl(Duration.ofMinutes(5))
20.                 .serializeValuesWith(SerializationPair.fromSerializer(RedisSerializer.json()));
22.         return RedisCacheManager.builder(factory)
23.                 .cacheDefaults(config)
24.                 .transactionAware()
25.                 .build();
26.     }
28.     // 组合缓存管理器
29.     @Bean
30.     @Primary
31.     public CacheManager multiLevelCacheManager(
32.             @Qualifier("caffeineCacheManager") CacheManager level1,
33.             @Qualifier("redisCacheManager") CacheManager level2) {
34.         return new MultiLevelCacheManager(level1, level2);
35.     }
36. }

复制代码

3. 多级缓存管理器实现

1. public class MultiLevelCacheManager implements CacheManager {
3.     private final CacheManager level1; // 本地缓存
4.     private final CacheManager level2; // Redis缓存
5.     private final ConcurrentMap<String, Cache> cacheMap = new ConcurrentHashMap<>();
7.     public MultiLevelCacheManager(CacheManager level1, CacheManager level2) {
8.         this.level1 = level1;
9.         this.level2 = level2;
10.     }
12.     @Override
13.     public Cache getCache(String name) {
14.         return cacheMap.computeIfAbsent(name,
15.             key -> new MultiLevelCache(
16.                 level1.getCache(name),
17.                 level2.getCache(name)
18.             ));
19.     }
21.     @Override
22.     public Collection<String> getCacheNames() {
23.         return Stream.concat(
24.             level1.getCacheNames().stream(),
25.             level2.getCacheNames().stream()
26.         ).collect(Collectors.toSet());
27.     }
29.     // 多级缓存实现
30.     static class MultiLevelCache implements Cache {
31.         private final Cache level1;
32.         private final Cache level2;
33.         private final String name;
35.         public MultiLevelCache(Cache level1, Cache level2) {
36.             this.level1 = level1 != null ? level1 : new NoOpCache();
37.             this.level2 = level2 != null ? level2 : new NoOpCache();
38.             this.name = level1.getName() + ":" + level2.getName();
39.         }
41.         @Override
42.         public String getName() {
43.             return name;
44.         }
46.         @Override
47.         public Object getNativeCache() {
48.             return this;
49.         }
51.         @Override
52.         public ValueWrapper get(Object key) {
53.             // 先查一级缓存
54.             ValueWrapper value = level1.get(key);
55.             if (value == null) {
56.                 // 二级缓存查询
57.                 value = level2.get(key);
58.                 if (value != null) {
59.                     // 回填一级缓存
60.                     level1.put(key, value.get());
61.                 }
62.             }
63.             return value;
64.         }
66.         @Override
67.         public <T> T get(Object key, Class<T> type) {
68.             // 实现逻辑类似get方法
69.             T value = level1.get(key, type);
70.             if (value == null) {
71.                 value = level2.get(key, type);
72.                 if (value != null) {
73.                     level1.put(key, value);
74.                 }
75.             }
76.             return value;
77.         }
79.         @Override
80.         public void put(Object key, Object value) {
81.             // 同时写入两级缓存
82.             level1.put(key, value);
83.             level2.put(key, value);
84.         }
86.         @Override
87.         public void evict(Object key) {
88.             // 同时清除两级缓存
89.             level1.evict(key);
90.             level2.evict(key);
91.         }
93.         @Override
94.         public void clear() {
95.             level1.clear();
96.             level2.clear();
97.         }
98.     }
100.     // 空缓存实现（容错）
101.     static class NoOpCache implements Cache {
102.         // 实现基础的Cache方法，返回空值
103.     }
104. }

复制代码

4. 业务层使用

1. @Service
2. public class ProductService {
4.     @Cacheable(value = "products", key = "#id")
5.     public Product getProduct(Long id) {
6.         // 数据库查询逻辑
7.         return productRepository.findById(id)
8.                .orElseThrow(() -> new NotFoundException("Product not found"));
9.     }
11.     @CacheEvict(value = "products", key = "#product.id")
12.     public void updateProduct(Product product) {
13.         productRepository.save(product);
14.     }
15. }

复制代码

5. 配置说明（application.yml）

1. spring:
2.   cache:
3.     multi-level:
4.       level1:
5.         ttl: 30s    # 本地缓存时间
6.         max-size: 1000
7.       level2:
8.         ttl: 5m     # Redis缓存时间
9.   redis:
10.     host: redis-cluster.prod
11.     port: 6379
12.     timeout: 2000ms

复制代码

---

关键实现要点

• 缓存层级策略
  

     

• 一致性保障
  

• 写操作：同时清除两级缓存（@CacheEvict​）
  
• 读操作：二级缓存掷中后自动回填一级缓存
  
• TTL策略：一级缓存TTL（30s） < 二级缓存TTL（5m）
  

• 性能优化
  

• 本地缓存：使用Caffeine高性能缓存库
  
• 异步回填：可扩展为异步加载（需自定义CacheLoader）
  
• 批量操作：支持@Cacheable的批量查询优化
  

---

扩展发起

• 缓存预热
  

1. @PostConstruct
2. public void preloadHotData() {
3.     // 加载热点数据到缓存
4.     hotProducts.forEach(product ->
5.         cacheManager.getCache("products").put(product.getId(), product));
6. }

复制代码

• 监控集成
  

1. @Bean
2. public MeterRegistryCustomizer<MeterRegistry> cacheMetrics() {
3.     return registry -> {
4.         CaffeineCacheManager caffeine = context.getBean(CaffeineCacheManager.class);
5.         RedisCacheManager redis = context.getBean(RedisCacheManager.class);
6.         
7.         // 注册Caffeine监控
8.         CacheMetrics.monitor(registry, caffeine, "level1");
9.         // 注册Redis监控
10.         CacheMetrics.monitor(registry, redis, "level2");
11.     };
12. }

复制代码

• 防雪崩策略
  

1. // 在MultiLevelCache.get方法中添加
2. ValueWrapper get(Object key) {
3.     try {
4.         // 添加分布式锁检查
5.         if (lockManager.tryLock(key)) {
6.             // 实际查询逻辑
7.         }
8.     } finally {
9.         lockManager.unlock(key);
10.     }
11. }

复制代码

‍

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。