SpringBoot集成Ehcache：从注解驱动到多级缓存实战-代码聚汇网

SpringBoot集成Ehcache：从注解驱动到多级缓存实战

爱宝妈·2026-04-20·阅读 60 GEO检测（免费）

SpringBootEhcache缓存优化

|难度：普通|阅读约 14 分钟

1. 为什么选择Ehcache与SpringBoot集成？

在开发高并发应用时，数据库常常成为性能瓶颈。我曾经参与过一个电商促销系统，当秒杀活动开始时，数据库QPS瞬间飙升到2万+，导致整个系统响应变慢。这时候引入缓存就像给系统装上了涡轮增压器，而Ehcache就是其中最轻量高效的解决方案之一。

Ehcache作为纯Java实现的进程内缓存，相比Redis这类分布式缓存有个显著优势——零网络开销。实测下来，本地缓存操作的耗时通常在微秒级别，而远程缓存即使在内网环境下也至少需要毫秒级。对于商品详情页这种读多写少的场景，用Ehcache做第一层缓存能让90%以上的请求根本不用打到数据库。

Spring Cache的抽象层让缓存集成变得异常简单。还记得我第一次用@Cacheable注解时，只加了四行代码就让接口QPS从500提升到了8000+。这种开箱即用的体验，正是SpringBoot开发者最爱的"约定优于配置"哲学体现。

需要模型API调用？免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。

2. 五分钟快速搭建基础缓存

先来搞个最小可运行示例。新建SpringBoot项目时，记得勾选Spring Cache Starter和Ehcache依赖。如果已经建好项目，手动添加这两个依赖：

xml复制<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>
</dependency>
<dependency>
    <groupId>org.ehcache</groupId>
    <artifactId>ehcache</artifactId>
    <version>3.10.0</version>
</dependency>

在application.properties中加入配置：

properties复制# 启用Ehcache
spring.cache.type=ehcache
# 配置文件位置
spring.cache.ehcache.config=classpath:ehcache.xml

创建src/main/resources/ehcache.xml：

xml复制<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:noNamespaceSchemaLocation="ehcache.xsd">
    <cache alias="productCache">
        <heap unit="entries">2000</heap>
    </cache>
</config>

在启动类加上@EnableCaching注解：

java复制@SpringBootApplication
@EnableCaching
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

现在就可以在Service层使用缓存了：

java复制@Service
public class ProductService {
    @Cacheable(value = "productCache", key = "#id")
    public Product getProductById(Long id) {
        // 模拟数据库查询
        return productRepository.findById(id).orElseThrow();
    }
}

我遇到过新手常犯的错误是忘记加@EnableCaching，结果缓存根本不生效。还有一次同事把@Cacheable加在private方法上，这也是不行的——Spring的AOP代理只能拦截public方法。

3. 深度解析Ehcache多级存储

Ehcache真正的威力在于它的分层存储架构。想象下你家的储物系统：最常用的东西放抽屉（堆内存），次常用的放柜子（堆外内存），很少用的放地下室（磁盘）。Ehcache也是这样工作的。

堆内存存储就像你的办公桌抽屉：

xml复制<cache alias="hotData">
    <heap unit="MB">100</heap> <!-- 最大100MB -->
</cache>

这种存储速度最快但空间有限，适合缓存高频访问的小数据，比如用户会话信息。

堆外内存存储突破了JVM堆大小限制：

xml复制<cache alias="warmData">
    <offheap unit="MB">500</offheap> <!-- 500MB堆外内存 -->
</cache>

我做过测试，同样缓存1GB数据，堆外内存比堆内存多用约15%的CPU，但避免了GC停顿。有个金融项目用这个特性缓存实时行情数据，YGC时间从200ms降到了50ms以内。

磁盘持久化存储适合海量冷数据：

xml复制<persistence directory="/data/ehcache"/>
<cache alias="coldData">
    <disk unit="GB" persistent="true">20</disk>
</cache>

实际配置多级缓存时，建议采用这种金字塔结构：

xml复制<cache alias="multiLevelCache">
    <heap unit="entries">1000</heap>
    <offheap unit="MB">100</offheap>
    <disk unit="GB">1</disk>
</cache>

曾经有个坑让我调试了半天：磁盘存储需要确保目录有写权限，最好用绝对路径。还有次服务器重启后缓存没恢复，原来是忘了设persistent="true"。

4. 高级缓存策略与实战技巧

缓存失效是个大学问。我见过最惨的案例是某社交平台设置所有缓存5分钟过期，结果每到整点系统就卡死——因为所有缓存同时重建导致数据库雪崩。

Ehcache提供了灵活的过期策略：

xml复制<cache alias="timedCache">
    <expiry>
        <tti unit="minutes">30</tti> <!-- 空闲时间 -->
        <ttl unit="hours">2</ttl>    <!-- 绝对时间 -->
    </expiry>
</cache>

对于缓存穿透问题，可以用空值缓存：

java复制@Cacheable(value = "userCache", unless = "#result == null")
public User getUser(String id) {
    User user = userDao.findById(id);
    return user != null ? user : new NullUser();
}

缓存更新时，我更喜欢用@CachePut而不是@CacheEvict：

java复制@CachePut(value = "userCache", key = "#user.id")
public User updateUser(User user) {
    return userDao.update(user);
}

监控缓存命中率也很重要，在配置里开启统计：

xml复制<cache alias="monitoredCache" statistics="true">
    <heap unit="entries">1000</heap>
</cache>

然后通过代码获取统计信息：

java复制CacheStatistics stats = cacheManager.getCache("monitoredCache")
    .getStatistics();
log.info("命中率：{}%", stats.getCacheHitPercentage());

在分布式环境中，可以用Terracotta集群：

xml复制<cache alias="clusterCache">
    <terracotta cluster="my-cluster"/>
</cache>

不过要注意网络延迟，我曾经把集群节点跨机房部署，结果缓存性能还不如不用。

5. 性能调优与问题排查

Ehcache的性能很大程度上取决于配置参数。根据我的经验，这几个指标需要特别关注：

堆内存条目数不要超过10000，否则GC压力会明显增大
堆外内存建议设置为堆内存的2-5倍
磁盘存储最好用SSD，机械硬盘的吞吐量可能成为瓶颈

用JConsole连接应用后，可以看到Ehcache的MBean，里面有很多有用的统计信息。如果发现缓存命中率低于70%，可能需要调整缓存大小或淘汰策略。

常见问题排查步骤：

确认@EnableCaching已添加
检查方法是否为public
查看ehcache.xml是否被正确加载
通过日志确认缓存操作是否执行
检查key的生成策略是否合理

我写了个简单的测试工具类来验证缓存：

java复制public class CacheTester {
    @Autowired
    private CacheManager cacheManager;
    
    public void testCache(String cacheName) {
        Cache cache = cacheManager.getCache(cacheName);
        cache.put("testKey", "testValue");
        assert "testValue".equals(cache.get("testKey"));
    }
}

对于高并发场景，建议用JMeter做压力测试。曾经发现一个诡异现象：缓存命中率随并发量增加而下降。最后查明是因为缓存没有设置并发策略：

xml复制<cache alias="concurrentCache">
    <heap unit="entries">5000</heap>
    <resources>
        <thread-pool size="16"/>
    </resources>
</cache>

6. 与其他技术的整合实践

在Spring Security中缓存权限信息能显著提升性能：

java复制@Cacheable(value = "authCache", key = "#username")
public UserDetails loadUserByUsername(String username) {
    // 数据库查询
}

和Hibernate二级缓存整合：

properties复制spring.jpa.properties.hibernate.cache.use_second_level_cache=true
spring.jpa.properties.hibernate.cache.region.factory_class=org.hibernate.cache.ehcache.EhCacheRegionFactory

在Web层缓存API响应：

java复制@GetMapping("/products/{id}")
@Cacheable(cacheNames = "apiCache", key = "#id")
public Product getProductApi(@PathVariable Long id) {
    return productService.getProductById(id);
}

定时刷新缓存的小技巧：

java复制@Scheduled(fixedRate = 3600000)
@CacheEvict(value = "productCache", allEntries = true)
public void refreshProductCache() {
    // 可添加日志等操作
}

对于热点数据，可以结合Caffeine做二级缓存：

java复制@Bean
public CaffeineCacheManager caffeineCacheManager() {
    CaffeineCacheManager manager = new CaffeineCacheManager();
    manager.setCaffeine(Caffeine.newBuilder()
        .maximumSize(1000)
        .expireAfterWrite(10, TimeUnit.MINUTES));
    return manager;
}

最后提醒下，缓存虽然好用但不要滥用。我见过最夸张的项目把所有数据库查询都加了缓存，结果内存占用超过20G，反而拖慢整体性能。好的缓存策略应该是精心设计的，而不是简单粗暴地给所有方法加上@Cacheable。