在高并发系统设计中，缓存是提升性能的关键策略之一。随着业务的发展，单一的缓存方案往往无法同时兼顾性能、可靠性和一致性等多方面需求。此时，二级缓存架构应运而生，本文将介绍在Spring Boot中实现二级缓存的三种方案。 ## 一、二级缓存概述 ### 1.1 什么是二级缓存二级缓存是一种多层次的缓存架构，通常由以下两个层次组成： - **一级缓存**（本地缓存）：直接在应用服务器内存中，访问速度极快，但容量有限且在分布式环境下无法共享 - **二级缓存**（分布式缓存）：独立的缓存服务，如Redis或Memcached，可被多个应用实例共享，容量更大二级缓存的工作流程通常是：先查询本地缓存，若未命中则查询分布式缓存，仍未命中才访问数据库，并将结果回填到各级缓存中。 ### 1.2 为什么需要二级缓存单一缓存方案存在明显局限性： - **仅使用本地缓存**：无法在分布式环境下保持数据一致性，每个实例都需要从数据库加载数据 - **仅使用分布式缓存**：每次访问都需要网络IO，无法发挥本地缓存的性能优势二级缓存结合了两者优势： - 利用本地缓存的高性能，大幅减少网络IO - 通过分布式缓存保证数据一致性 - 减轻数据库压力，提高系统整体吞吐量 - 更好的故障隔离，即使分布式缓存不可用，本地缓存仍可提供部分服务 ## 二、Spring Cache + Redis方案 ### 2.1 基本原理该方案利用Spring Cache提供的缓存抽象，配合Caffeine(本地缓存)和Redis(分布式缓存)实现二级缓存。 Spring Cache提供了统一的缓存操作接口，可以通过简单的注解实现缓存功能。 ### 2.2 实现步骤 #### 2.2.1 添加依赖 ``` org.springframework.boot spring-boot-starter-web org.springframework.boot spring-boot-starter-cache org.springframework.boot spring-boot-starter-data-redis com.github.ben-manes.caffeine caffeine com.fasterxml.jackson.core jackson-databind ``` #### 2.2.2 配置二级缓存管理器 ``` @Configuration @EnableCaching public class CacheConfig { @Value("${spring.application.name:app}") private String appName; @Bean public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) { // 创建Redis缓存管理器 RedisCacheManager redisCacheManager = RedisCacheManager.builder(redisConnectionFactory) .cacheDefaults(getRedisCacheConfigurationWithTtl(3600)) // 默认1小时过期 .withCacheConfiguration("userCache", getRedisCacheConfigurationWithTtl(1800)) // 用户缓存30分钟 .withCacheConfiguration("productCache", getRedisCacheConfigurationWithTtl(7200)) // 产品缓存2小时 .build(); // 创建Caffeine缓存管理器 CaffeineCacheManager caffeineCacheManager = new CaffeineCacheManager(); caffeineCacheManager.setCaffeine(Caffeine.newBuilder() .initialCapacity(100) // 初始容量 .maximumSize(1000) // 最大容量 .expireAfterWrite(5, TimeUnit.MINUTES) // 写入后5分钟过期 .recordStats()); // 开启统计 // 创建二级缓存管理器 return new LayeringCacheManager(caffeineCacheManager, redisCacheManager); } private RedisCacheConfiguration getRedisCacheConfigurationWithTtl(long seconds) { return RedisCacheConfiguration.defaultCacheConfig() .entryTtl(Duration.ofSeconds(seconds)) .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer())) .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer())) .disableCachingNullValues() .computePrefixWith(cacheName -> appName + ":" + cacheName + ":"); } // 二级缓存管理器实现 public static class LayeringCacheManager implements CacheManager { private final CacheManager localCacheManager; private final CacheManager remoteCacheManager; private final Map cacheMap = new ConcurrentHashMap<>(); public LayeringCacheManager(CacheManager localCacheManager, CacheManager remoteCacheManager) { this.localCacheManager = localCacheManager; this.remoteCacheManager = remoteCacheManager; } @Override public Cache getCache(String name) { return cacheMap.computeIfAbsent(name, cacheName -> { Cache localCache = localCacheManager.getCache(cacheName); Cache remoteCache = remoteCacheManager.getCache(cacheName); return new LayeringCache(localCache, remoteCache); }); } @Override public Collection getCacheNames() { Set names = new LinkedHashSet<>(); names.addAll(localCacheManager.getCacheNames()); names.addAll(remoteCacheManager.getCacheNames()); return names; } // 二级缓存实现 static class LayeringCache implements Cache { private final Cache localCache; private final Cache remoteCache; public LayeringCache(Cache localCache, Cache remoteCache) { this.localCache = localCache; this.remoteCache = remoteCache; } @Override public String getName() { return localCache.getName(); } @Override public Object getNativeCache() { return this; } @Override public ValueWrapper get(Object key) { // 先查本地缓存 ValueWrapper wrapper = localCache.get(key); if (wrapper != null) { return wrapper; } // 本地未命中，查远程缓存 wrapper = remoteCache.get(key); if (wrapper != null) { Object value = wrapper.get(); // 回填本地缓存 localCache.put(key, value); } return wrapper; } @Override public T get(Object key, Class type) { // 先查本地缓存 T value = localCache.get(key, type); if (value != null) { return value; } // 本地未命中，查远程缓存 value = remoteCache.get(key, type); if (value != null) { // 回填本地缓存 localCache.put(key, value); } return value; } @Override public T get(Object key, Callable valueLoader) { // 先查本地缓存 try { T value = localCache.get(key, () -> { // 本地未命中，查远程缓存 try { return remoteCache.get(key, valueLoader); } catch (Exception e) { // 远程缓存未命中或异常，执行valueLoader加载数据 T newValue = valueLoader.call(); if (newValue != null) { remoteCache.put(key, newValue); // 填充远程缓存 } return newValue; } }); return value; } catch (Exception e) { // 本地缓存异常，尝试直接读远程缓存 try { return remoteCache.get(key, valueLoader); } catch (Exception ex) { if (ex instanceof RuntimeException) { throw (RuntimeException) ex; } throw new IllegalStateException(ex); } } } @Override public void put(Object key, Object value) { remoteCache.put(key, value); // 先放入远程缓存 localCache.put(key, value); // 再放入本地缓存 } @Override public void evict(Object key) { remoteCache.evict(key); // 先清远程缓存 localCache.evict(key); // 再清本地缓存 } @Override public void clear() { remoteCache.clear(); // 先清远程缓存 localCache.clear(); // 再清本地缓存 } } } } ``` #### 2.2.3 使用缓存注解 ``` @Service public class UserServiceImpl implements UserService { @Autowired private UserRepository userRepository; @Override @Cacheable(cacheNames = "userCache", key = "#id") public User getUserById(Long id) { return userRepository.findById(id).orElse(null); } @Override @CachePut(cacheNames = "userCache", key = "#user.id") public User saveUser(User user) { return userRepository.save(user); } @Override @CacheEvict(cacheNames = "userCache", key = "#id") public void deleteUser(Long id) { userRepository.deleteById(id); } } ``` #### 2.2.4 缓存同步问题在分布式环境下，需要保证缓存一致性。我们可以通过Redis的发布订阅机制实现： ``` @Configuration public class CacheEvictionConfig { @Bean public RedisMessageListenerContainer redisMessageListenerContainer(RedisConnectionFactory connectionFactory) { RedisMessageListenerContainer container = new RedisMessageListenerContainer(); container.setConnectionFactory(connectionFactory); return container; } @Bean public RedisCacheMessageListener redisCacheMessageListener(RedisMessageListenerContainer listenerContainer, CacheManager cacheManager) { return new RedisCacheMessageListener(listenerContainer, cacheManager); } // 缓存消息监听器 public static class RedisCacheMessageListener { private static final String CACHE_CHANGE_TOPIC = "cache:changes"; private final CacheManager cacheManager; public RedisCacheMessageListener(RedisMessageListenerContainer listenerContainer, CacheManager cacheManager) { this.cacheManager = cacheManager; listenerContainer.addMessageListener((message, pattern) -> { String body = new String(message.getBody()); CacheChangeMessage cacheMessage = JSON.parseObject(body, CacheChangeMessage.class); // 清除本地缓存 Cache cache = cacheManager.getCache(cacheMessage.getCacheName()); if (cache != null) { if (cacheMessage.getKey() != null) { cache.evict(cacheMessage.getKey()); } else { cache.clear(); } } }, new ChannelTopic(CACHE_CHANGE_TOPIC)); } } @Bean public CacheChangePublisher cacheChangePublisher(RedisTemplate redisTemplate) { return new CacheChangePublisher(redisTemplate); } // 缓存变更消息发布器 public static class CacheChangePublisher { private static final String CACHE_CHANGE_TOPIC = "cache:changes"; private final RedisTemplate redisTemplate; public CacheChangePublisher(RedisTemplate redisTemplate) { this.redisTemplate = redisTemplate; } public void publishCacheEvict(String cacheName, Object key) { CacheChangeMessage message = new CacheChangeMessage(cacheName, key); redisTemplate.convertAndSend(CACHE_CHANGE_TOPIC, JSON.toJSONString(message)); } public void publishCacheClear(String cacheName) { CacheChangeMessage message = new CacheChangeMessage(cacheName, null); redisTemplate.convertAndSend(CACHE_CHANGE_TOPIC, JSON.toJSONString(message)); } } // 缓存变更消息 @Data @AllArgsConstructor public static class CacheChangeMessage { private String cacheName; private Object key; } } ``` ### 2.3 优缺点分析 **优点：** 1. 集成Spring Cache，使用简单，只需通过注解即可实现缓存功能 1. 支持多种缓存实现的无缝切换 1. 二级缓存逻辑集中管理，便于维护 1. 支持缓存失效时间、容量等细粒度控制 **缺点：** 1. 需要自行实现二级缓存管理器，代码相对复杂 1. 缓存同步需要额外实现，有一定复杂度 1. 自定义缓存加载策略不够灵活 1. 对于复杂查询场景支持有限 ### 2.4 适用场景 - 需要快速集成缓存功能的项目 - 使用Spring框架且熟悉Spring Cache机制的团队 - 读多写少的业务场景 - 对缓存一致性要求不是特别高的场景 ## 三、自定义二级缓存框架 ### 3.1 基本原理该方案通过自定义缓存框架，精确控制缓存的读写流程、失效策略和同步机制，实现更加贴合业务需求的二级缓存。这种方式虽然实现复杂度高，但提供了最大的灵活性和控制力。 ### 3.2 实现步骤 #### 3.2.1 定义缓存接口 ``` public interface Cache { V get(K key); void put(K key, V value); void remove(K key); void clear(); long size(); boolean containsKey(K key); } public interface CacheLoader { V load(K key); } ``` #### 3.2.2 实现本地缓存 ``` public class LocalCache implements Cache { private final com.github.benmanes.caffeine.cache.Cache cache; public LocalCache(long maximumSize, long expireAfterWriteSeconds) { this.cache = Caffeine.newBuilder() .maximumSize(maximumSize) .expireAfterWrite(expireAfterWriteSeconds, TimeUnit.SECONDS) .recordStats() .build(); } @Override public V get(K key) { return cache.getIfPresent(key); } @Override public void put(K key, V value) { if (value != null) { cache.put(key, value); } } @Override public void remove(K key) { cache.invalidate(key); } @Override public void clear() { cache.invalidateAll(); } @Override public long size() { return cache.estimatedSize(); } @Override public boolean containsKey(K key) { return cache.getIfPresent(key) != null; } public CacheStats stats() { return cache.stats(); } } ``` #### 3.2.3 实现Redis分布式缓存 ``` public class RedisCache implements Cache { private final RedisTemplate redisTemplate; private final String cachePrefix; private final long expireSeconds; private final Class valueType; public RedisCache(RedisTemplate redisTemplate, String cachePrefix, long expireSeconds, Class valueType) { this.redisTemplate = redisTemplate; this.cachePrefix = cachePrefix; this.expireSeconds = expireSeconds; this.valueType = valueType; } private String getCacheKey(K key) { return cachePrefix + ":" + key.toString(); } @Override public V get(K key) { String cacheKey = getCacheKey(key); return (V) redisTemplate.opsForValue().get(cacheKey); } @Override public void put(K key, V value) { if (value != null) { String cacheKey = getCacheKey(key); redisTemplate.opsForValue().set(cacheKey, value, expireSeconds, TimeUnit.SECONDS); } } @Override public void remove(K key) { String cacheKey = getCacheKey(key); redisTemplate.delete(cacheKey); } @Override public void clear() { Set keys = redisTemplate.keys(cachePrefix + ":*"); if (keys != null && !keys.isEmpty()) { redisTemplate.delete(keys); } } @Override public long size() { Set keys = redisTemplate.keys(cachePrefix + ":*"); return keys != null ? keys.size() : 0; } @Override public boolean containsKey(K key) { String cacheKey = getCacheKey(key); return Boolean.TRUE.equals(redisTemplate.hasKey(cacheKey)); } } ``` #### 3.2.4 实现二级缓存 ``` public class TwoLevelCache implements Cache { private final Cache localCache; private final Cache remoteCache; private final CacheLoader cacheLoader; private final String cacheName; private final CacheEventPublisher eventPublisher; public TwoLevelCache(Cache localCache, Cache remoteCache, CacheLoader cacheLoader, String cacheName, CacheEventPublisher eventPublisher) { this.localCache = localCache; this.remoteCache = remoteCache; this.cacheLoader = cacheLoader; this.cacheName = cacheName; this.eventPublisher = eventPublisher; } @Override public V get(K key) { // 先查本地缓存 V value = localCache.get(key); if (value != null) { return value; } // 本地未命中，查远程缓存 value = remoteCache.get(key); if (value != null) { // 回填本地缓存 localCache.put(key, value); return value; } // 远程也未命中，加载数据 if (cacheLoader != null) { value = cacheLoader.load(key); if (value != null) { // 填充缓存 put(key, value); } } return value; } @Override public void put(K key, V value) { if (value != null) { // 先放入远程缓存，再放入本地缓存 remoteCache.put(key, value); localCache.put(key, value); } } @Override public void remove(K key) { // 先清远程缓存，再清本地缓存 remoteCache.remove(key); localCache.remove(key); // 发布缓存失效事件 if (eventPublisher != null) { eventPublisher.publishCacheEvictEvent(cacheName, key); } } @Override public void clear() { // 先清远程缓存，再清本地缓存 remoteCache.clear(); localCache.clear(); // 发布缓存清空事件 if (eventPublisher != null) { eventPublisher.publishCacheClearEvent(cacheName); } } @Override public long size() { return remoteCache.size(); } @Override public boolean containsKey(K key) { return localCache.containsKey(key) || remoteCache.containsKey(key); } } ``` #### 3.2.5 缓存事件发布和订阅 ``` @Component public class CacheEventPublisher { private final RedisTemplate redisTemplate; private static final String CACHE_EVICT_TOPIC = "cache:evict"; private static final String CACHE_CLEAR_TOPIC = "cache:clear"; public CacheEventPublisher(RedisTemplate redisTemplate) { this.redisTemplate = redisTemplate; } public void publishCacheEvictEvent(String cacheName, Object key) { Map message = new HashMap<>(); message.put("cacheName", cacheName); message.put("key", key); redisTemplate.convertAndSend(CACHE_EVICT_TOPIC, JSON.toJSONString(message)); } public void publishCacheClearEvent(String cacheName) { Map message = new HashMap<>(); message.put("cacheName", cacheName); redisTemplate.convertAndSend(CACHE_CLEAR_TOPIC, JSON.toJSONString(message)); } } @Component public class CacheEventListener { private final Map> cacheMap; public CacheEventListener(RedisMessageListenerContainer listenerContainer, Map> cacheMap) { this.cacheMap = cacheMap; // 监听缓存失效事件 MessageListener evictListener = (message, pattern) -> { String body = new String(message.getBody()); Map map = JSON.parseObject(body, Map.class); String cacheName = (String) map.get("cacheName"); Object key = map.get("key"); TwoLevelCache cache = (TwoLevelCache) cacheMap.get(cacheName); if (cache != null) { // 只清除本地缓存，远程缓存已经由发布者清除 ((LocalCache)cache.getLocalCache()).remove(key); } }; // 监听缓存清空事件 MessageListener clearListener = (message, pattern) -> { String body = new String(message.getBody()); Map map = JSON.parseObject(body, Map.class); String cacheName = (String) map.get("cacheName"); TwoLevelCache cache = (TwoLevelCache) cacheMap.get(cacheName); if (cache != null) { // 只清除本地缓存，远程缓存已经由发布者清除 ((LocalCache)cache.getLocalCache()).clear(); } }; listenerContainer.addMessageListener(evictListener, new ChannelTopic("cache:evict")); listenerContainer.addMessageListener(clearListener, new ChannelTopic("cache:clear")); } } ``` #### 3.2.6 缓存管理器 ``` @Component public class TwoLevelCacheManager { private final RedisTemplate redisTemplate; private final CacheEventPublisher eventPublisher; private final Map> cacheMap = new ConcurrentHashMap<>(); public TwoLevelCacheManager(RedisTemplate redisTemplate, CacheEventPublisher eventPublisher) { this.redisTemplate = redisTemplate; this.eventPublisher = eventPublisher; } public TwoLevelCache getCache(String cacheName, Class valueType, CacheLoader cacheLoader) { return getCache(cacheName, valueType, cacheLoader, 1000, 300, 3600); } @SuppressWarnings("unchecked") public TwoLevelCache getCache(String cacheName, Class valueType, CacheLoader cacheLoader, long localMaxSize, long localExpireSeconds, long remoteExpireSeconds) { return (TwoLevelCache) cacheMap.computeIfAbsent(cacheName, name -> { LocalCache localCache = new LocalCache<>(localMaxSize, localExpireSeconds); RedisCache remoteCache = new RedisCache<>(redisTemplate, name, remoteExpireSeconds, valueType); return new TwoLevelCache<>(localCache, remoteCache, cacheLoader, name, eventPublisher); }); } public Map> getCacheMap() { return Collections.unmodifiableMap(cacheMap); } } ``` #### 3.2.7 使用示例 ``` @Service public class UserServiceImpl implements UserService { @Autowired private UserRepository userRepository; @Autowired private TwoLevelCacheManager cacheManager; private TwoLevelCache userCache; @PostConstruct public void init() { userCache = cacheManager.getCache("user", User.class, this::loadUser, 1000, 300, 1800); } private User loadUser(Long id) { return userRepository.findById(id).orElse(null); } @Override public User getUserById(Long id) { return userCache.get(id); } @Override public User saveUser(User user) { User savedUser = userRepository.save(user); userCache.put(user.getId(), savedUser); return savedUser; } @Override public void deleteUser(Long id) { userRepository.deleteById(id); userCache.remove(id); } } ``` ### 3.3 优缺点分析 **优点：** 1. 完全自定义，可以根据业务需求灵活定制 1. 精确控制缓存的加载、更新和失效逻辑 1. 可以针对不同业务场景设计不同的缓存策略 1. 缓存监控和统计更加全面 **缺点：** 1. 开发工作量大，需要实现所有缓存逻辑 1. 代码复杂度高，需要考虑多种边界情况 1. 不能直接利用Spring等框架提供的缓存抽象 1. 维护成本较高 ### 3.4 适用场景 - 对缓存性能和行为有精确控制需求的项目 - 缓存策略复杂，标准框架难以满足的场景 - 大型项目，有专人负责缓存框架开发和维护 - 特殊业务需求，如精确的过期策略、按条件批量失效等 ## 四、JetCache框架方案 ### 4.1 基本原理 JetCache是阿里开源的一款Java缓存抽象框架，原生支持二级缓存，并提供丰富的缓存功能，如缓存自动刷新、异步加载、分布式锁等。它在API设计上类似Spring Cache，但功能更加强大和灵活。 ### 4.2 实现步骤 #### 4.2.1 添加依赖 ``` org.springframework.boot spring-boot-starter-web com.alicp.jetcache jetcache-starter-redis 2.7.1 ``` #### 4.2.2 配置JetCache ``` # application.yml jetcache: statIntervalMinutes: 15 areaInCacheName: false hidePackages: com.example local: default: type: caffeine limit: 1000 keyConvertor: fastjson expireAfterWriteInMillis: 300000 # 5分钟 remote: default: type: redis keyConvertor: fastjson valueEncoder: java valueDecoder: java poolConfig: minIdle: 5 maxIdle: 20 maxTotal: 50 host: ${redis.host} port: ${redis.port} expireAfterWriteInMillis: 1800000 # 30分钟 ``` 在启动类上启用JetCache： ``` @SpringBootApplication @EnableMethodCache(basePackages = "com.example") @EnableCreateCacheAnnotation public class Application { public static void main(String[] args) { SpringApplication.run(Application.class, args); } } ``` #### 4.2.3 使用注解方式 ``` @Service public class UserServiceImpl implements UserService { @Autowired private UserRepository userRepository; @Override @Cached(name = "user:", key = "#id", cacheType = CacheType.BOTH, expire = 1800) public User getUserById(Long id) { return userRepository.findById(id).orElse(null); } @Override @CacheUpdate(name = "user:", key = "#user.id", value = "#user") public User saveUser(User user) { return userRepository.save(user); } @Override @CacheInvalidate(name = "user:", key = "#id") public void deleteUser(Long id) { userRepository.deleteById(id); } } ``` #### 4.2.4 使用API方式 ``` @Service public class ProductServiceImpl implements ProductService { @Autowired private ProductRepository productRepository; @CreateCache(name = "product:", cacheType = CacheType.BOTH, expire = 3600, localExpire = 600) private Cache productCache; @Override public Product getProductById(Long id) { // 自动加载功能，若缓存未命中，会执行lambda中的逻辑并将结果缓存 return productCache.computeIfAbsent(id, this::loadProduct); } private Product loadProduct(Long id) { return productRepository.findById(id).orElse(null); } @Override public Product saveProduct(Product product) { Product savedProduct = productRepository.save(product); productCache.put(product.getId(), savedProduct); return savedProduct; } @Override public void deleteProduct(Long id) { productRepository.deleteById(id); productCache.remove(id); } // 批量操作 @Override public List getProductsByIds(List ids) { Map productMap = productCache.getAll(ids); List missedIds = ids.stream() .filter(id -> !productMap.containsKey(id)) .collect(Collectors.toList()); if (!missedIds.isEmpty()) { List missedProducts = productRepository.findAllById(missedIds); Map missedProductMap = missedProducts.stream() .collect(Collectors.toMap(Product::getId, p -> p)); // 更新缓存 productCache.putAll(missedProductMap); // 合并结果 productMap.putAll(missedProductMap); } return ids.stream() .map(productMap::get) .filter(Objects::nonNull) .collect(Collectors.toList()); } } ``` #### 4.2.5 高级特性：自动刷新和异步加载 ``` @Service public class StockServiceImpl implements StockService { @Autowired private StockRepository stockRepository; // 自动刷新缓存，适合库存等频繁变化的数据 @CreateCache(name = "stock:", cacheType = CacheType.BOTH, expire = 60, // 1分钟后过期 localExpire = 10, // 本地缓存10秒过期 refreshPolicy = RefreshPolicy.BACKGROUND, // 后台刷新 penetrationProtect = true) // 防止缓存穿透 private Cache stockCache; @Override public Stock getStockById(Long productId) { return stockCache.computeIfAbsent(productId, this::loadStock); } private Stock loadStock(Long productId) { return stockRepository.findByProductId(productId).orElse(new Stock(productId, 0)); } @Override public void updateStock(Long productId, int newQuantity) { stockRepository.updateQuantity(productId, newQuantity); stockCache.remove(productId); // 直接失效缓存，后台自动刷新会加载新值 } } ``` #### 4.2.6 缓存统计与监控 ``` @RestController @RequestMapping("/cache") public class CacheStatsController { @Autowired private CacheManager cacheManager; @GetMapping("/stats") public Map getCacheStats() { Collection caches = cacheManager.getCache(null); Map statsMap = new HashMap<>(); for (Cache cache : caches) { statsMap.put(cache.config().getName(), cache.getStatistics()); } return statsMap; } } ``` ### 4.3 优缺点分析 **优点：** 1. 原生支持二级缓存，使用简单 1. 提供注解和API两种使用方式，灵活性强 1. 内置多种高级特性，如自动刷新、异步加载、分布式锁等 1. 完善的缓存统计和监控支持 1. 社区活跃，文档完善 **缺点：** 1. 增加项目依赖，引入第三方框架 1. 配置相对复杂 1. 学习成本相对较高 ### 4.4 适用场景 - 需要开箱即用的二级缓存解决方案 - 对缓存有丰富需求的项目，如自动刷新、异步加载等 - 微服务架构，需要统一的缓存抽象 ## 五、总结选择合适的二级缓存方案需要考虑项目规模、团队技术栈、性能需求、功能需求等多方面因素。无论选择哪种方案，合理的缓存策略、完善的监控体系和优秀的运维实践都是构建高效缓存系统的关键。在实际应用中，缓存并非越多越好，应当根据业务特点和系统架构，在性能、复杂度和一致性之间找到平衡点。