Java多级缓存如何架构呢?写出实战代码.(开源下载)
Java多级缓存如何架构呢？写出实战代码.（开源下载）
我得理清楚多级缓存的概念。多级缓存通常是指使用多个不同层级的缓存来提升系统性能，比如本地缓存加上分布式缓存，或者再加上数据库之类的。常见的组合可能有Ehcache作为一级缓存，Redis作为二级缓存，这样可以减少对后端存储的直接访问，提高响应速度。
接下来需要考虑架构设计。多级缓存的一般结构是请求先到最快的缓存层，比如本地内存，如果命中就直接返回；如果没有命中，就查下一层，比如Redis；如果还没有，再查数据库。数据库查询之后，需要回填到各级缓存中，这样下次请求就能直接从缓存获取了。
然后，得考虑数据一致性的问题。多级缓存之间可能存在数据不一致的情况，尤其是在分布式环境中。比如，当Redis中的数据更新了，但本地缓存可能还存着旧数据。处理办法可以是通过消息队列发布更新事件，让各个节点监听并更新自己的本地缓存，或者设置合理的过期时间，让缓存自动失效。
代码实现方面，可能需要用Spring框架来整合Ehcache和Redis。首先配置Ehcache作为一级缓存，再通过CacheManager来管理。二级缓存的话，可以用RedisTemplate来操作Redis。然后自定义一个缓存管理器，实现多级缓存的逻辑，比如先查本地，再查Redis，都没有的话查数据库，然后回填。
还需要注意缓存穿透和雪崩的问题。穿透是指查询不存在的数据，导致每次都要查数据库，可以用布隆过滤器或者缓存空值来解决。雪崩是大量缓存同时失效，导致数据库压力过大，可以设置不同的过期时间。此外，缓存的淘汰策略也要考虑，比如LRU、LFU等。
实战代码部分，可能需要先搭建Spring Boot项目，引入Ehcache和Redis的依赖。然后配置Ehcache的XML文件，定义缓存策略。接着定义缓存服务类，封装多级缓存的获取和设置逻辑。在数据访问层，使用这个缓存服务来优先从缓存读取数据，没有的话再查数据库，并回填到缓存中。
举个例子，用户查询订单信息，先查本地Ehcache，如果有就直接返回；没有的话查Redis，如果Redis有，就回填到Ehcache并返回；如果都没有，查询数据库，然后保存到Ehcache和Redis中。同时，当订单信息更新时，需要清除或更新两级的缓存，保持数据一致性。
可能还需要考虑分布式环境下，各个节点的本地缓存如何同步。比如使用Redis的Pub/Sub功能，当某个节点更新了数据，发布一个事件，其他节点订阅这个事件，清除本地对应的缓存，这样下次请求时会重新加载最新数据。
测试部分，可以通过单元测试或者压力测试来验证多级缓存的效率和正确性。比如模拟高并发请求，观察是否有效减少数据库的访问次数，以及缓存命中率是否提升。
总结来说，架构多级缓存需要明确各级缓存的角色和交互方式，处理好数据一致性和同步问题，选择合适的缓存策略和工具，并通过代码实现各级缓存的协同工作。这样能够显著提升系统的性能和响应速度，减少对后端存储的压力。
多级缓存架构是提升系统性能的重要手段，通常采用 本地缓存 + 分布式缓存 的组合模式。以下是一个基于 Caffeine（本地缓存） + Redis（分布式缓存） 的实战方案，包含分层设计、数据同步策略和完整代码实现。
一、多级缓存架构设计
请求流程:
1. 客户端请求
2. Caffeine 本地缓存（一级缓存，进程内）
3. ↓ 未命中 → Redis 分布式缓存（二级缓存）
4. ↓ 未命中 → 数据库/外部服务
5. ↓ 回填缓存（先Redis再Caffeine）二、核心代码实现（Spring Boot + Caffeine + Redis）
1. 添加依赖
<!-- pom.xml -->
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-cache</artifactId>
</dependency>
<dependency>
<groupId>com.github.ben-manes.caffeine</groupId>
<artifactId>caffeine</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
</dependencies>2. 配置多级缓存
// CacheConfig.java
@Configuration
@EnableCaching
public class CacheConfig {
// 一级缓存：Caffeine
@Bean
public CacheManager caffeineCacheManager() {
CaffeineCacheManager cacheManager = new CaffeineCacheManager();
cacheManager.setCaffeine(Caffeine.newBuilder()
.initialCapacity(100)
.maximumSize(1000)
.expireAfterWrite(5, TimeUnit.MINUTES));
return cacheManager;
}
// 二级缓存：Redis
@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
RedisTemplate<String, Object> template = new RedisTemplate<>();
template.setConnectionFactory(factory);
template.setKeySerializer(new StringRedisSerializer());
template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
return template;
}
}3. 多级缓存管理器
// MultiLevelCacheManager.java
public class MultiLevelCacheManager implements CacheManager {
private final CacheManager caffeineCacheManager;
private final RedisTemplate<String, Object> redisTemplate;
private final Map<String, Cache> caches = new ConcurrentHashMap<>();
public MultiLevelCacheManager(CacheManager caffeineCacheManager, RedisTemplate<String, Object> redisTemplate) {
this.caffeineCacheManager = caffeineCacheManager;
this.redisTemplate = redisTemplate;
}
@Override
public Cache getCache(String name) {
return caches.computeIfAbsent(name, cacheName ->
new MultiLevelCache(cacheName,
caffeineCacheManager.getCache(cacheName),
redisTemplate));
}
static class MultiLevelCache implements Cache {
private final String name;
private final Cache caffeineCache;
private final RedisTemplate<String, Object> redisTemplate;
public MultiLevelCache(String name, Cache caffeineCache, RedisTemplate<String, Object> redisTemplate) {
this.name = name;
this.caffeineCache = caffeineCache;
this.redisTemplate = redisTemplate;
}
@Override
public ValueWrapper get(Object key) {
// 1. 先查Caffeine
ValueWrapper value = caffeineCache.get(key);
if (value != null) {
return value;
}
// 2. 再查Redis
String redisKey = name + ":" + key.toString();
Object redisValue = redisTemplate.opsForValue().get(redisKey);
if (redisValue != null) {
// 回填到本地缓存
caffeineCache.put(key, redisValue);
return () -> redisValue;
}
// 3. 未命中则返回null，由业务层处理数据库查询
return null;
}
@Override
public void put(Object key, Object value) {
// 同时写入两级缓存
caffeineCache.put(key, value);
String redisKey = name + ":" + key.toString();
redisTemplate.opsForValue().set(redisKey, value, 30, TimeUnit.MINUTES);
}
// 其他方法实现...
}
}4. 业务层使用示例
// UserService.java
@Service
public class UserService {
@Autowired
private UserRepository userRepository;
@Cacheable(value = "users", key = "#userId", cacheManager = "multiLevelCacheManager")
public User getUserById(Long userId) {
return userRepository.findById(userId).orElse(null);
}
@CacheEvict(value = "users", key = "#userId", cacheManager = "multiLevelCacheManager")
public void updateUser(User user) {
userRepository.save(user);
}
}三、关键优化策略
- 缓存穿透：对空值进行缓存（设置短过期时间）
- 缓存雪崩：Redis过期时间添加随机因子
- 数据一致性：
- 更新数据库后，删除两级缓存（@CacheEvict）
- 通过Redis Pub/Sub 通知其他节点失效本地缓存
- 热点数据：
- 本地缓存使用Window TinyLFU策略（Caffeine默认）
- 分布式锁控制回源
四、扩展功能建议
- 监控指标：集成Micrometer监控缓存命中率
- 动态配置：通过Apollo/Nacos动态调整缓存策略
- 分级存储：高频数据存本地，全量数据存Redis
- 冷热分离：本地缓存仅保留热点数据
完整代码需根据实际业务场景调整缓存策略和异常处理逻辑。