Springboot3 + Springboot cache+Ehcache3 + Redisson 实现本地缓存管理及分布式本地缓存更新方案

'# Springboot3 + Springboot cache+Ehcache3 + Redisson 实现本地缓存管理及分布式本地缓存更新方案

一、背景与问题

在分布式系统中，缓存是提升性能的重要手段。传统做法常使用Redis这样的分布式缓存，但存在内存占用高、网络延迟和数据一致性等挑战。而本地缓存（Local Cache）作为缓存的轻量化方案，能显著降低网络开销，但面临多实例数据同步、缓存失效和并发更新等难题。

在Spring Boot 3生态中，我们需要一个既能利用本地缓存的高性能优势，又能解决分布式场景下缓存一致性问题的方案。本方案结合Spring Cache、Ehcache3和Redisson，构建了一个分布式本地缓存更新系统，通过本地缓存+分布式消息队列的双层架构，在保证高性能的同时实现多实例数据同步。

二、基本原理

1. 层级缓存架构

graph TD
    A[用户请求] --> B[本地缓存]
    B --> C{命中?}
    C -->|是| D[返回缓存数据]
    C -->|否| E[调用数据库]
    E --> F[更新本地缓存]
    F --> G[推送更新消息]
    G --> H[其他节点接收消息]
    H --> I[更新本地缓存]

2. 技术栈协同原理

Spring Cache：提供缓存注解和抽象层
Ehcache3：本地缓存的高性能实现
Redisson：分布式锁和消息队列的协调工具

3. 关键技术点

缓存失效策略：基于TTL的过期机制 + 热点数据的永不过期策略
分布式更新：通过Redisson的发布订阅机制实现缓存同步
并发控制：使用Redisson锁保证更新操作的原子性

三、环境准备

1. 依赖配置（Spring Boot 3.1.5）

<dependencies>
    <!-- Spring Boot Cache -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-cache</artifactId>
    </dependency>
    
    <!-- Ehcache3 -->
    <dependency>
        <groupId>org.ehcache</groupId>
        <artifactId>ehcache</artifactId>
        <version>3.12.3</version>
    </dependency>
    
    <!-- Redisson -->
    <dependency>
        <groupId>org.redisson</groupId>
        <artifactId>redisson-spring-boot-starter</artifactId>
        <version>3.18.7</version>
    </dependency>
</dependencies>

2. 配置文件（application.yml）

spring:
  cache:
    type: ehcache
    ehcache:
      config: class-path:ehcache.xml

<!-- ehcache.xml -->
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="http://www.ehcache.org/ehcache3.0.xsd">
    <cache name="userCache" maxEntriesLocalHeap="1000" eternal="false" timeToLiveSeconds="3600"/>
</ehcache>

四、核心实现

1. 缓存注解配置

@Configuration
@EnableCaching
public class CacheConfig {
    @Bean
    public CacheManager cacheManager() {
        EhcacheCacheManager cacheManager = (EhcacheCacheManager) CacheManager.create();
        return cacheManager;
    }
}

2. 缓存注解使用示例

@Service
public class UserService {
    @Cacheable(value = "userCache", key = "#userId")
    public User getUserById(Long userId) {
        // 模拟数据库查询
        return new User(userId, "Alice");
    }
    
    @CachePut(value = "userCache", key = "#user.id")
    public User updateUser(User user) {
        // 模拟更新数据库
        return user;
    }
}

3. Redisson分布式更新实现

@Component
public class CacheUpdateService {
    @Autowired
    private RedissonClient redissonClient;
    
    public void updateCache(Long userId, User user) {
        RTopic topic = redissonClient.getTopic("userCacheUpdate");
        topic.publish(new CacheUpdateEvent(userId, user));
    }
    
    @Data
    public static class CacheUpdateEvent {
        private Long userId;
        private User user;
        
        public CacheUpdateEvent(Long userId, User user) {
            this.userId = userId;
            this.user = user;
        }
    }
}

@Component
public class CacheListener {
    @Autowired
    private CacheManager cacheManager;
    
    @Autowired
    private RedissonClient redissonClient;
    
    public CacheListener() {
        RTopic topic = redissonClient.getTopic("userCacheUpdate");
        topic.addListener(CacheUpdateEvent.class, (channel, event) -> {
            Cache<Object, Object> userCache = cacheManager.getCache("userCache");
            userCache.put(event.getUserId(), event.getUser());
        });
    }
}

五、完整案例

1. 示例项目结构

src
└── main
    └── java
        └── com.example
            ├── config
            │   └── CacheConfig.java
            ├── service
            │   ├── UserService.java
            │   └── CacheUpdateService.java
            ├── listener
            │   └── CacheListener.java
            └── CacheApplication.java

2. 完整案例代码

// UserService.java
@Service
public class UserService {
    @Cacheable(value = "userCache", key = "#userId")
    public User getUserById(Long userId) {
        // 模拟数据库查询
        return new User(userId, "Alice");
    }
    
    @CachePut(value = "userCache", key = "#user.id")
    public User updateUser(User user) {
        // 模拟更新数据库
        return user;
    }
}

// CacheUpdateService.java
@Component
public class CacheUpdateService {
    @Autowired
    private RedissonClient redissonClient;
    
    public void updateCache(Long userId, User user) {
        RTopic topic = redissonClient.getTopic("userCacheUpdate");
        topic.publish(new CacheUpdateEvent(userId, user));
    }
    
    @Data
    public static class CacheUpdateEvent {
        private Long userId;
        private User user;
        
        public CacheUpdateEvent(Long userId, User user) {
            this.userId = userId;
            this.user = user;
        }
    }
}

// CacheListener.java
@Component
public class CacheListener {
    @Autowired
    private CacheManager cacheManager;
    
    @Autowired
    private RedissonClient redissonClient;
    
    public CacheListener() {
        RTopic topic = redissonClient.getTopic("userCacheUpdate");
        topic.addListener(CacheUpdateEvent.class, (channel, event) -> {
            Cache<Object, Object> userCache = cacheManager.getCache("userCache");
            userCache.put(event.getUserId(), event.getUser());
        });
    }
}

六、源码解析

1. Ehcache3 缓存机制

Ehcache3 使用两级缓存策略：

本地内存缓存：每个应用实例的内存空间
分布式缓存：通过Redisson实现的共享缓存

核心代码：

public class EhcacheCacheManager implements CacheManager {
    private final CacheManager ehcacheManager;
    
    public EhcacheCacheManager() {
        this.ehcacheManager = CacheManager.create();
    }
    
    public Cache<Object, Object> getCache(String name) {
        return ehcacheManager.getCache(name);
    }
}

2. Redisson 消息队列机制

Redisson 使用发布订阅模式实现分布式通信：

RTopic topic = redissonClient.getTopic("userCacheUpdate");
topic.publish(new CacheUpdateEvent(userId, user));

源码关键点：

使用Redis的Pub/Sub功能
通过RedissonClient建立连接
消息队列的异步处理机制

七、进阶使用

1. 缓存更新策略优化

// 设置缓存更新策略
CacheConfiguration config = CacheConfiguration
    .newCacheConfigurationBuilder(
        Long.class, User.class,
        ResourcePoolsBuilder.heap(1000)
    )
    .withExpiry(Expiry.timeToLiveSeconds(3600))
    .build();

2. 分布式锁控制

public void updateCacheSafely(Long userId, User user) {
    RLock lock = redissonClient.getLock("userCacheLock-" + userId);
    try {
        if (lock.tryLock(3, 10, TimeUnit.SECONDS)) {
            // 执行更新逻辑
        }
    } finally {
        lock.unlock();
    }
}

3. 缓存热数据持久化

@Cacheable(value = "userCache", key = "#userId", unless = "#result == null")
public User getHotUser(Long userId) {
    // 模拟热数据查询
    return new User(userId, "HotUser");
}

八、性能与工程实践

1. 性能优化策略

缓存命中率：通过@Cacheable的unless条件控制缓存更新
内存管理：配置maxEntriesLocalHeap限制内存占用
异步更新：使用Redisson的异步API减少阻塞

2. 异常处理方案

@Cacheable(value = "userCache", key = "#userId", unless = "#result == null")
public User getSafeUser(Long userId) {
    try {
        return getUserFromDatabase(userId);
    } catch (Exception e) {
        log.error("获取用户缓存失败", e);
        return null;
    }
}

3. 安全风险防控

敏感数据加密：使用AES加密缓存内容
缓存雪崩防护：设置随机TTL
缓存穿透防护：使用布隆过滤器

九、常见问题与踩坑

1. 常见错误

问题	原因	解决方案
缓存未命中	缓存配置错误	检查`ehcache.xml`配置
更新不一致	Redisson连接异常	检查Redis服务状态
内存溢出	本地缓存过大	调整`maxEntriesLocalHeap`

2. 常见坑点

缓存更新顺序问题：在分布式系统中，需要保证更新消息的顺序性
并发更新冲突：未使用锁机制导致数据不一致
缓存失效策略错误：未合理设置TTL导致缓存命中率下降

十、最佳实践

1. 推荐实践

混合缓存策略：热数据使用本地缓存，冷数据使用分布式缓存
渐进式更新：使用Redisson的异步更新机制
监控告警：集成Prometheus监控缓存命中率和内存使用

2. 代码规范

命名规范：缓存名称使用domain+entity格式（如userCache）
注解规范：@Cacheable使用key表达式避免重复
锁机制：使用Redisson锁控制更新操作

十一、总结

Spring Boot 3结合Ehcache3和Redisson实现的分布式本地缓存方案，通过本地缓存+分布式消息队列的架构，在保证高性能的同时解决了多实例数据同步的问题。这种方案适用于：

✅ 高并发场景：需要快速响应的业务系统
✅ 分布式系统：多个实例需要共享缓存数据
✅ 热数据处理：需要快速访问的高频数据

但需注意：

❌ 不适合：数据一致性要求极高的场景
❌ 不适合：需要持久化存储的场景
❌ 不适合：内存资源有限的轻量级系统

通过合理配置和实践，这种方案可以显著提升系统性能，同时保持良好的可维护性和扩展性。在实际开发中，建议结合监控系统持续优化缓存策略，以达到最佳性能平衡。