Spring Boot 数据缓存与性能优化实战

2. 配置文件编写

在 application.properties 中开启 EhCache 并配置基础连接信息：

# 服务器端口
server.port=8080
# 数据库连接信息
spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driver-class-name=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=password
# JPA 配置
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
# H2 数据库控制台
spring.h2.console.enabled=true
spring.h2.console.path=/h2-console
# EhCache 配置
spring.cache.type=ehcache
spring.cache.ehcache.config=classpath:ehcache.xml

定义 ehcache.xml 来指定缓存策略，例如限制堆内存条目数和过期时间：

<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd">
    <defaultCache maxEntriesLocalHeap="10000"
                  eternal="false"
                  timeToIdleSeconds="120"
                  timeToLiveSeconds="120"
                  overflowToDisk="false"
                  diskPersistent="false"
                  diskExpiryThreadIntervalSeconds="120"></defaultCache>
    <cache name="productCache"
           maxEntriesLocalHeap="1000"
           eternal="false"
           timeToIdleSeconds="60"
           timeToLiveSeconds="60"
           overflowToDisk="false"
           diskPersistent="false"
           diskExpiryThreadIntervalSeconds="120"></cache>
</ehcache>

3. 业务层实现

启动类需添加 @EnableCaching 注解激活缓存功能。实体类、Repository 接口保持标准 JPA 写法。重点在于 Service 层的注解使用。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;

@Service
public class ProductService {
    @Autowired
    private ProductRepository productRepository;

    // 新增或更新时同步缓存
    @Transactional
    @CachePut(value = "productCache", key = "#product.id")
    public Product addProduct(Product product) {
        return productRepository.save(product);
    }

    @Transactional
    @CachePut(value = "productCache", key = "#product.id")
    public Product updateProduct(Product product) {
        return productRepository.save(product);
    }

    // 删除时清除缓存
    @Transactional
    @CacheEvict(value = "productCache", key = "#id")
    public void deleteProduct(Long id) {
        productRepository.deleteById(id);
    }

    // 查询时优先读取缓存
    @Transactional(readOnly = true)
    @Cacheable(value = "productCache", key = "#id")
    public Product getProductById(Long id) {
        System.out.println("从数据库查询产品：" + id);
        return productRepository.findById(id).orElse(null);
    }

    @Transactional(readOnly = true)
    public List<Product> getAllProducts() {
        return productRepository.findAll();
    }
}

控制器层只需正常调用 Service 方法即可，无需关心缓存逻辑：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.List;

@RestController
@RequestMapping("/api/products")
public class ProductController {
    @Autowired
    private ProductService productService;

    @GetMapping("/")
    public List<Product> getAllProducts() {
        return productService.getAllProducts();
    }

    @PostMapping("/")
    public Product addProduct(@RequestBody Product product) {
        return productService.addProduct(product);
    }

    @PutMapping("/{id}")
    public Product updateProduct(@PathVariable Long id, @RequestBody Product product) {
        product.setId(id);
        return productService.updateProduct(product);
    }

    @DeleteMapping("/{id}")
    public void deleteProduct(@PathVariable Long id) {
        productService.deleteProduct(id);
    }

    @GetMapping("/{id}")
    public Product getProductById(@PathVariable Long id) {
        return productService.getProductById(id);
    }
}

核心注解详解

Spring Cache 提供了三个核心注解，理解它们的区别是掌握缓存的关键。

@Cacheable

用于查询方法。当方法被调用时，Spring 会先检查缓存中是否存在对应 key 的数据。如果存在则直接返回；否则执行方法并将结果存入缓存。

注意：只有第一次请求会触发数据库查询，后续请求直接从缓存读取，控制台将不再打印'从数据库查询产品'日志。

@CachePut

用于更新操作（新增或修改）。它保证方法总是被执行，并将返回值写入缓存。这确保了即使缓存中有旧数据，也能被最新的结果覆盖。

@CacheEvict

用于删除操作。在执行方法后，根据指定的 key 从缓存中移除对应的数据，防止脏读。

切换为 Caffeine 缓存

如果需要更轻量级的本地缓存，可以替换为 Caffeine。步骤类似，只需调整依赖和配置。

1. 依赖变更

将 EhCache 依赖替换为 Caffeine：

<dependency>
    <groupId>com.github.ben-manes.caffeine</groupId>
    <artifactId>caffeine</artifactId>
</dependency>

2. 配置变更

在 application.properties 中指定 Caffeine 规格：

spring.cache.type=caffeine
spring.cache.caffeine.spec=maximumSize=1000,expireAfterWrite=60s

其余代码逻辑保持不变，Spring Boot 会自动适配底层缓存实现。

总结

通过上述实践，我们实现了 Spring Boot 与主流缓存框架的集成。在实际开发中，选择合适的缓存策略至关重要：

• 对于高频读取且变动较少的数据，使用 @Cacheable 效果显著。
• 涉及数据变更时，务必配合 @CachePut 或 @CacheEvict 维护一致性。
• 根据场景选择 EhCache 或 Caffeine，甚至引入 Redis 处理分布式需求。

掌握这些基础能力，能有效解决大部分数据访问性能问题。