缓存预热#

1
/**
2
 * 多级缓存管理器
3
 * 整合Caffeine本地缓存和Redis分布式缓存
4
 *
5
 * @author Float (浮浮酱)
6
 */
7
@Slf4j
8
@Primary
9
@Component("multiLevelCacheManager")
10
public class MultiLevelCacheManager implements CacheManager {
11

12
    // L1缓存管理器（Caffeine）
13
    private final CaffeineCacheManager l1CacheManager;
14

15
    // L2缓存管理器（Redis）- 可选
16
    private final Optional<RedisCacheManager> l2CacheManager;
17

18
    // 存储已创建的多级缓存对象
19
    private final ConcurrentMap<String, Cache> cacheMap = new ConcurrentHashMap<>(16);
20

21
    @Autowired
22
    public MultiLevelCacheManager(
23
            @Qualifier("caffeineCacheManager") CaffeineCacheManager l1CacheManager,
24
            Optional<RedisCacheManager> l2CacheManager) {
25
        this.l1CacheManager = l1CacheManager;
26
        this.l2CacheManager = l2CacheManager;
27
        log.info("多级缓存管理器初始化完成 - L1: {}, L2: {}",
28
                l1CacheManager.getClass().getSimpleName(),
29
                l2CacheManager.map(cm -> cm.getClass().getSimpleName()).orElse("未启用"));
30
    }
31

32
    @Override
33
    public Cache getCache(String name) {
34
        // 双重检查锁模式，确保每个缓存名称只创建一个MultiLevelCache实例
35
        Cache cache = cacheMap.get(name);
36
        if (cache != null) {
37
            return cache;
38
        }
39

40
        synchronized (this) {
41
            cache = cacheMap.get(name);
42
            if (cache == null) {
43
                log.info("创建多级缓存 - 名称: {}", name);
44

45
                // 获取L1和L2缓存
46
                Cache l1Cache = l1CacheManager.getCache(name);
47
                Cache l2Cache = l2CacheManager.map(cm -> cm.getCache(name)).orElse(null);
48

49
                if (l1Cache == null) {
50
                    log.warn("无法创建多级缓存，L1缓存为空 - 名称: {}", name);
51
                    return null;
52
                }
53

54
                // 创建多级缓存实例（即使没有L2缓存也可以创建）
55
                cache = new MultiLevelCache(name, l1Cache, l2Cache);
56
                cacheMap.put(name, cache);
57

58
                log.info("多级缓存创建完成 - 名称: {}, L2缓存: {}", name, l2CacheManager.isPresent() ? "已启用" : "未启用");
59
            }
60
        }
61

62
        return cache;
63
    }
64

65
    @Override
66
    public Collection<String> getCacheNames() {
67
        return Collections.unmodifiableSet(cacheMap.keySet());
68
    }
69

70
    /**
71
     * 清空所有多级缓存
72
     */
73
    public void clearAll() {
74
        log.info("清空所有多级缓存");
75

76
        cacheMap.values().forEach(Cache::clear);
77
        cacheMap.clear();
78

79
        log.info("所有多级缓存清空完成");
80
    }
81

82
    /**
83
     * 获取缓存统计信息
84
     */
85
    public void printCacheStats() {
86
        log.info("=== 多级缓存统计信息 ===");
87

88
        cacheMap.forEach((name, cache) -> {
89
            if (cache instanceof MultiLevelCache) {
90
                MultiLevelCache multiCache = (MultiLevelCache) cache;
91
                log.info("缓存名称: {}", name);
92
                log.info("  L1缓存: {}", multiCache.getL1CacheStats());
93
                log.info("  L2缓存: {}", multiCache.getL2CacheStats());
94
            }
95
        });
96

97
        log.info("======================");
98
    }
99

100
    /**
101
     * 手动创建指定名称的多级缓存
102
     */
103
    public Cache createCache(String name) {
104
        if (!cacheMap.containsKey(name)) {
105
            getCache(name); // 调用getCache方法来创建
106
        }
107
        return cacheMap.get(name);
108
    }
109

110
}

1
    /**
2
     * 根据ID查询商品
3
     * 缓存策略：多级缓存（L1 -> L2 -> DB）
4
     */
5
    @GetMapping("/{id}")
6
    public ResponseEntity<?> getProductById(@PathVariable Long id) {
7
        log.info("查询商品 - ID: {}", id);
8

9
        try {
10
            Optional<Product> product = productService.getProductById(id);
11
            if (product.isPresent()) {
12
                log.info("商品查询成功 - ID: {}, 名称: {}", id, product.get().getName());
13
                return ResponseEntity.ok(product.get());
14
            } else {
15
                log.warn("商品不存在 - ID: {}", id);
16
                return ResponseEntity.notFound().build();
17
            }
18
        } catch (Exception e) {
19
            log.error("查询商品失败 - ID: {}", id, e);
20
            return ResponseEntity.internalServerError().body("查询商品失败: " + e.getMessage());
21
        }
22
    }
23
    /**
24
     * 创建商品
25
     * 缓存策略：创建后清理相关缓存
26
     */
27
    @PostMapping
28
    public ResponseEntity<?> createProduct(@Valid @RequestBody Product product) {
29
        log.info("创建商品 - 名称: {}", product.getName());
30

31
        try {
32
            Product createdProduct = productService.createProduct(product);
33
            log.info("商品创建成功 - ID: {}, 名称: {}", createdProduct.getId(), createdProduct.getName());
34
            return ResponseEntity.ok(createdProduct);
35
        } catch (Exception e) {
36
            log.error("创建商品失败 - 名称: {}", product.getName(), e);
37
            return ResponseEntity.internalServerError().body("创建商品失败: " + e.getMessage());
38
        }
39
    }
40
    /**
41
     * 更新商品
42
     * 缓存策略：更新后清理所有相关缓存
43
     */
44
    @PutMapping("/{id}")
45
    public ResponseEntity<?> updateProduct(@PathVariable Long id, @Valid @RequestBody Product product) {
46
        log.info("更新商品 - ID: {}, 名称: {}", id, product.getName());
47

48
        try {
49
            Product updatedProduct = productService.updateProduct(id, product);
50
            log.info("商品更新成功 - ID: {}, 名称: {}", updatedProduct.getId(), updatedProduct.getName());
51
            return ResponseEntity.ok(updatedProduct);
52
        } catch (Exception e) {
53
            log.error("更新商品失败 - ID: {}", id, e);
54
            return ResponseEntity.internalServerError().body("更新商品失败: " + e.getMessage());
55
        }
56
    }
57
    /**
58
     * 删除商品
59
     * 缓存策略：删除后清理所有相关缓存
60
     */
61
    @DeleteMapping("/{id}")
62
    public ResponseEntity<?> deleteProduct(@PathVariable Long id) {
63
        log.info("删除商品 - ID: {}", id);
64

65
        try {
66
            productService.deleteProduct(id);
67
            log.info("商品删除成功 - ID: {}", id);
68
            return ResponseEntity.ok("商品删除成功");
69
        } catch (Exception e) {
70
            log.error("删除商品失败 - ID: {}", id, e);
71
            return ResponseEntity.internalServerError().body("删除商品失败: " + e.getMessage());
72
        }
73
    }

1
    /**
2
     * 根据ID查询商品
3
     * 使用多级缓存：L1(Caffeine) -> L2(Redis) -> DB
4
     */
5
    @Cacheable(value = "products", key = "#id", cacheManager = "multiLevelCacheManager")
6
    public Optional<Product> getProductById(Long id) {
7
        log.debug("从数据库查询商品 - ID: {}", id);
8
        Product product = productMapper.selectById(id);
9
        return Optional.ofNullable(product);
10
    }
11
    /**
12
     * 创建商品
13
     * 创建后需要清理相关缓存
14
     */
15
    @Caching(evict = {
16
        @CacheEvict(value = "products", key = "'all'", cacheManager = "multiLevelCacheManager"),
17
        @CacheEvict(value = "products", key = "'category:' + #product.category", cacheManager = "multiLevelCacheManager"),
18
        @CacheEvict(value = "products", key = "'hot:*'", allEntries = true, cacheManager = "multiLevelCacheManager"),
19
        @CacheEvict(value = "products", key = "'latest:*'", allEntries = true, cacheManager = "multiLevelCacheManager")
20
    })
21
    @Transactional
22
    public Product createProduct(Product product) {
23
        log.debug("创建商品 - 名称: {}", product.getName());
24
        productMapper.insert(product);
25
        log.info("商品创建成功 - ID: {}, 名称: {}", product.getId(), product.getName());
26
        return product;
27
    }
28
    /**
29
     * 更新商品
30
     * 更新后需要清理所有相关缓存
31
     */
32
    @Caching(evict = {//组合多个缓存操作
33
        //定义驱逐规则
34
        @CacheEvict(value = "products", key = "#id", cacheManager = "multiLevelCacheManager"),//驱逐单个商品缓存
35
        @CacheEvict(value = "products", key = "'all'", cacheManager = "multiLevelCacheManager"),//驱逐所有商品列表缓存
36
        @CacheEvict(value = "products", key = "'category:' + #product.category", cacheManager = "multiLevelCacheManager"),//驱逐分类商品列表缓存
37
        @CacheEvict(value = "products", key = "'hot:*'", allEntries = true, cacheManager = "multiLevelCacheManager"),//批量驱逐模式匹配的缓存
38
        @CacheEvict(value = "products", key = "'latest:*'", allEntries = true, cacheManager = "multiLevelCacheManager")//批量驱逐模式匹配的缓存
39
    })
40
    @Transactional
41
    public Product updateProduct(Long id, Product product) {
42
        log.debug("更新商品 - ID: {}", id);
43

44
        Product existingProduct = productMapper.selectById(id);
45
        if (existingProduct == null) {
46
            throw new RuntimeException("商品不存在，ID: " + id);
47
        }
48

49
        // 更新商品信息
50
        existingProduct.setName(product.getName());
51
        existingProduct.setDescription(product.getDescription());
52
        existingProduct.setPrice(product.getPrice());
53
        existingProduct.setStock(product.getStock());
54
        existingProduct.setCategory(product.getCategory());
55
        existingProduct.setStatus(product.getStatus());
56
        existingProduct.setImageUrl(product.getImageUrl());
57

58
        productMapper.updateById(existingProduct);
59
        log.info("商品更新成功 - ID: {}, 名称: {}", existingProduct.getId(), existingProduct.getName());
60
        return existingProduct;
61
    }
62

63
    /**
64
     * 删除商品
65
     * 删除后需要清理所有相关缓存
66
     */
67
    @Caching(evict = {
68
        @CacheEvict(value = "products", key = "#id", cacheManager = "multiLevelCacheManager"),
69
        @CacheEvict(value = "products", key = "'all'", cacheManager = "multiLevelCacheManager"),
70
        @CacheEvict(value = "products", key = "'category:*'", allEntries = true, cacheManager = "multiLevelCacheManager"),
71
        @CacheEvict(value = "products", key = "'hot:*'", allEntries = true, cacheManager = "multiLevelCacheManager"),
72
        @CacheEvict(value = "products", key = "'latest:*'", allEntries = true, cacheManager = "multiLevelCacheManager")
73
    })
74
    @Transactional
75
    public void deleteProduct(Long id) {
76
        log.debug("删除商品 - ID: {}", id);
77

78
        Product product = productMapper.selectById(id);
79
        if (product == null) {
80
            throw new RuntimeException("商品不存在，ID: " + id);
81
        }
82

83
        productMapper.deleteById(id);
84
        log.info("商品删除成功 - ID: {}", id);
85
    }