Spring Cache：构建高性能应用的缓存利器

在现代软件开发中，构建高性能、高可用性的应用是至关重要的目标。随着用户流量的增长和数据量的膨胀，应用程序常常面临数据库压力大、外部服务调用延迟高、计算密集型任务耗时等性能瓶颈。缓存作为一种有效的优化手段，能够显著提升应用的响应速度并降低后端资源的负载。

然而，直接在业务逻辑中嵌入缓存代码（如手动管理Map或直接调用缓存客户端API）往往会导致代码耦合度高、难以维护和测试。为了解决这一问题，Spring Framework 提供了强大的缓存抽象层（Spring Cache Abstraction），它允许开发者以声明式的方式使用缓存，将缓存逻辑从业务代码中解耦，从而构建出更加清晰、灵活和高性能的应用。

本文将深入探讨 Spring Cache 抽象层，详细介绍它的核心概念、使用方法、高级特性以及如何将其集成到实际应用中，帮助开发者充分利用这一利器来构建高性能的Java应用。

第一章：性能瓶颈与缓存的价值

在深入了解 Spring Cache 之前，我们首先回顾一下应用程序常见的性能瓶颈以及缓存如何成为解决这些问题的关键。

1. 常见的性能瓶颈

数据库访问: 频繁或复杂的数据库查询通常是应用性能的最大瓶颈。每次查询都需要建立连接、执行SQL、传输数据，这些操作都消耗时间和资源。
外部服务调用: 调用外部REST API、SOAP服务或其他微服务同样涉及网络延迟和对方服务的处理时间。高延迟的外部调用会直接影响用户体验。
计算密集型任务: 某些业务逻辑可能涉及复杂的计算、数据处理或算法执行，这些任务可能非常耗时，阻塞请求线程。
重复计算: 应用程序可能在短时间内或多次重复执行完全相同的计算或数据查找，而结果是相同的。

2. 缓存的价值

缓存是一种将计算结果或数据临时存储在快速访问介质（如内存）中的技术。当应用程序需要相同的数据或计算结果时，首先检查缓存。如果缓存中存在（缓存命中），则直接返回缓存中的数据，避免了昂贵的后端操作。如果缓存中没有（缓存未命中），则执行后端操作，获取结果，并将结果存入缓存，以便后续请求使用。

缓存带来的主要益处包括：

降低延迟: 从内存中读取数据通常比从磁盘、数据库或通过网络获取数据快几个数量级，显著降低了响应时间。
减少后端负载: 降低了对数据库、外部服务或其他计算资源的访问频率，减轻了它们的压力，提高了系统的整体吞吐量。
提高可用性: 在后端服务短暂不可用时，缓存中的数据可能仍然可用，提供一定程度的服务降级能力（虽然这通常需要更复杂的策略）。

然而，引入缓存也带来了新的挑战：

缓存一致性: 如何确保缓存中的数据与后端数据源保持同步？如何处理数据更新导致缓存失效的问题？
内存管理: 缓存通常存储在内存中，需要注意缓存大小，防止内存溢出。需要有淘汰策略（如LRU, LFU）来管理缓存项的生命周期。
分布式缓存: 在分布式系统中，缓存数据需要在多个应用实例间共享，需要使用分布式缓存系统（如Redis, Memcached）。
复杂性: 手动管理缓存逻辑会使业务代码变得复杂和难以维护。

Spring Cache 抽象层正是为了应对这些挑战，提供了一种声明式、标准化的方式来使用缓存。

第二章：Spring Cache 抽象层简介

Spring Cache 抽象层并非一个具体的缓存实现，而是一个统一的接口和一组注解。它的核心思想是将缓存操作（存入、获取、移除）从具体的缓存技术中剥离出来，通过代理和AOP（面向切面编程）的方式，在方法执行前后自动插入缓存逻辑。

1. 核心概念

CacheManager: 这是 Spring Cache 抽象的核心接口，负责管理应用中的所有 Cache 实例。它是访问缓存的入口。不同的缓存提供商会提供自己的 CacheManager 实现。
Cache: 代表一个具体的缓存区域或命名空间。每个 Cache 实例都以键值对的形式存储数据。可以通过 CacheManager 获取特定的 Cache 实例。
KeyGenerator: 负责为缓存数据生成键。Spring 提供了默认的键生成策略，也可以通过 SpEL 或自定义实现来指定键的生成规则。
CacheResolver: 用于动态确定使用哪个或哪些缓存来存储或检索数据。在更复杂的场景下，可能需要根据方法参数等信息选择不同的缓存。
CacheErrorHandler: 用于处理缓存操作过程中发生的错误，如缓存服务器连接失败、序列化异常等。

2. 为什么选择 Spring Cache？

解耦: 将缓存逻辑与业务逻辑分离，提高了代码的可读性和可维护性。
标准化: 提供了一套标准的注解和API，无论底层使用哪种缓存实现，上层应用代码风格保持一致。
灵活性: 可以轻松切换不同的缓存提供商（如 Ehcache, Caffeine, Redis, JCache/JSR-107 等），只需修改少量配置。
声明式: 通过简单的注解即可启用缓存，降低了开发成本。
可测试性: 缓存逻辑是切面，可以通过测试剥离或模拟缓存行为，简化单元测试。

第三章：快速上手：配置与基本使用

使用 Spring Cache 抽象层非常简单，主要包括以下几个步骤：

1. 添加依赖

首先，需要在项目的构建文件（如 Maven 或 Gradle）中添加 Spring Cache 相关的依赖，以及你选择的具体缓存提供商的依赖。

以 Maven 为例：

“`xml

org.springframework
spring-context
${spring.version}

com.github.ben-manes.caffeine
caffeine
${caffeine.version}

org.springframework.boot
spring-boot-starter-cache
${spring.boot.version}

org.springframework.boot
spring-boot-starter-data-redis
${spring.boot.version}

“`

如果使用 Spring Boot，通常只需要引入 spring-boot-starter-cache，然后根据需要添加具体的缓存实现依赖（如 caffeine, spring-boot-starter-data-redis），Spring Boot 会自动配置 CacheManager。

2. 启用缓存功能

在你的 Spring 配置类或主应用类上添加 @EnableCaching 注解，以启用基于注解的缓存功能。

“`java
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Configuration;

@Configuration
@EnableCaching
public class AppConfig {
// 其他 bean 定义
}
“`

如果使用 Spring Boot，通常在主应用类 (@SpringBootApplication) 上添加 @EnableCaching 即可。

3. 配置 CacheManager

Spring Cache 需要一个 CacheManager 来管理缓存。不同的缓存提供商有不同的 CacheManager 实现。如果你不 explicitly 配置，Spring Boot 会尝试自动配置一个，比如如果检测到 Caffeine 或 Ehcache，它会配置相应的 CacheManager；如果都没有，它会配置一个简单的基于 ConcurrentHashMap 的 CacheManager (ConcurrentMapCacheManager)，这通常用于简单的测试。

手动配置一个简单的 CacheManager 示例（不依赖任何外部库）：

“`java
import org.springframework.cache.CacheManager;
import org.springframework.cache.concurrent.ConcurrentMapCacheManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@EnableCaching
public class CacheConfig {

@Bean
public CacheManager cacheManager() {
    // 配置一个 ConcurrentMapCacheManager，指定缓存名称
    // 实际应用中会配置更强大的CacheManager，如RedisCacheManager, CaffeineCacheManager等
    return new ConcurrentMapCacheManager("users", "products");
}

}
“`

这个例子配置了一个简单的 ConcurrentMapCacheManager，它管理名为 “users” 和 “products” 的两个缓存区域。

4. 使用核心注解

配置完成后，就可以在需要应用缓存的方法上使用 Spring Cache 提供的注解了。

`@Cacheable`

这是最常用的注解，用于标记一个方法的结果可以被缓存。当方法被调用时，Spring Cache 会首先根据缓存名称和键查找缓存。
* 如果找到缓存项，则直接返回缓存的值，方法本身不会被执行。
* 如果未找到缓存项，则执行方法，并将方法的返回值存入缓存，然后再返回该值。

语法:

java @Cacheable(value = {"cacheName1", "cacheName2"}, key = "...")

value (或 cacheNames): 指定缓存区域的名称，可以是一个或多个。必需属性。
key: 指定缓存项的键。可以是 SpEL 表达式。如果未指定，Spring 会使用默认的键生成策略（基于方法参数）。可选属性。
condition: 一个 SpEL 表达式，在方法执行前评估。只有当表达式为 true 时，方法的结果才会被缓存。可选属性。
unless: 一个 SpEL 表达式，在方法执行后评估。只有当表达式为 true 时，方法的结果才不会被缓存。常用于根据返回值判断是否缓存，例如 unless="#result == null" 表示如果返回值为 null 则不缓存。可选属性。

示例:

“`java
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

@Service
public class UserService {

@Cacheable(value = "users", key = "#userId") // 缓存到名为"users"的缓存区，键是方法参数userId
public User getUserById(Long userId) {
    System.out.println("Fetching user from database for id: " + userId);
    // 模拟从数据库查询用户
    try {
        Thread.sleep(1000); // 模拟耗时操作
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
    return new User(userId, "User " + userId);
}

@Cacheable(value = "products", key = "#productName.toLowerCase()", unless = "#result == null") // 键是小写产品名，如果结果为null则不缓存
public Product getProductByName(String productName) {
     System.out.println("Fetching product from external service for name: " + productName);
     // 模拟从外部服务查询产品
     if ("non-existent".equalsIgnoreCase(productName)) {
         return null; // 模拟未找到
     }
     return new Product(productName.hashCode(), productName, 10.0);
}

}

class User {
private Long id;
private String name;
// constructor, getters, setters…
public User(Long id, String name) { this.id = id; this.name = name; }
public Long getId() { return id; }
public String getName() { return name; }
@Override public String toString() { return “User{” + “id=” + id + “, name='” + name + ‘\” + ‘}’; }
}

class Product {
private Integer id;
private String name;
private Double price;
// constructor, getters, setters…
public Product(Integer id, String name, Double price) { this.id = id; this.name = name; this.price = price; }
// getters, setters…
@Override public String toString() { return “Product{” + “id=” + id + “, name='” + name + ‘\” + “, price=” + price + ‘}’; }
}
“`

第一次调用 getUserById(1L) 时，方法会执行，并打印 “Fetching user from database…”，然后将结果存入 “users” 缓存，键为 “1”。第二次以及后续调用 getUserById(1L) 时，会直接从缓存获取，不再执行方法体。

`@CachePut`

用于标记一个方法，无论如何都要执行该方法，并将方法的返回值放入缓存。它不会在方法执行前检查缓存。这通常用于更新操作，确保缓存与最新的数据同步。

语法:

java @CachePut(value = {"cacheName1", "cacheName2"}, key = "...")

属性与 @Cacheable 类似 (value, key, condition, unless)。

示例:

“`java
import org.springframework.cache.annotation.CachePut;
import org.springframework.stereotype.Service;

@Service
public class UserService {

// ... getUserById method ...

@CachePut(value = "users", key = "#user.id") // 执行updateUser方法，将返回的user对象更新到"users"缓存，键是user对象的id
public User updateUser(User user) {
    System.out.println("Updating user in database: " + user.getId());
    // 模拟更新数据库操作
    try {
        Thread.sleep(500);
    } catch (InterruptedException e) {
         Thread.currentThread().interrupt();
    }
    // 模拟返回更新后的用户对象
    user.setName(user.getName() + "_Updated");
    return user; // 返回更新后的用户
}

}
“`

调用 updateUser(user) 方法后，无论缓存中是否有该用户，方法都会执行，并将返回的最新 User 对象存入 “users” 缓存，键为该用户的 ID。

`@CacheEvict`

用于标记一个方法，当该方法执行后，移除缓存中的一个或多个项。这通常用于删除或使数据失效的操作。

语法:

java @CacheEvict(value = {"cacheName1", "cacheName2"}, key = "...", allEntries = false, beforeInvocation = false)

value (或 cacheNames): 指定缓存区域的名称。必需属性。
key: 指定要移除的缓存项的键。可以是 SpEL 表达式。可选属性。
allEntries: 如果设置为 true，则清除指定缓存区域中的所有项，而忽略 key 属性。默认 false。
beforeInvocation: 如果设置为 true，则在方法执行前清除缓存。默认 false，表示在方法成功执行后清除。如果方法执行期间抛出异常，且 beforeInvocation 为 false，则缓存不会被清除；如果 beforeInvocation 为 true，则无论方法是否成功，缓存都会被清除。

示例:

“`java
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.stereotype.Service;

@Service
public class UserService {

// ... getUserById, updateUser methods ...

@CacheEvict(value = "users", key = "#userId") // 删除"users"缓存中键为userId的项
public void deleteUser(Long userId) {
    System.out.println("Deleting user from database: " + userId);
    // 模拟删除数据库操作
    try {
        Thread.sleep(500);
    } catch (InterruptedException e) {
         Thread.currentThread().interrupt();
    }
}

@CacheEvict(value = "products", allEntries = true) // 删除"products"缓存区的所有项
public void deleteAllProductsCache() {
    System.out.println("Clearing all products cache.");
    // 此方法本身可能不需要执行任何业务逻辑，仅用于清除缓存
}

}
“`

调用 deleteUser(1L) 会清除 “users” 缓存中键为 “1” 的项。调用 deleteAllProductsCache() 会清空 “products” 缓存。

`@Caching`

当需要在同一个方法上应用多个缓存操作时，可以使用 @Caching 注解来组合它们。

语法:

java @Caching( cacheable = { @Cacheable(...) }, put = { @CachePut(...) }, evict = { @CacheEvict(...) } )

每个属性都接受一个相应注解的数组。

示例:

“`java
import org.springframework.cache.annotation.Cacheable;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Caching;
import org.springframework.stereotype.Service;

@Service
public class ProductService {

@Caching(
    cacheable = @Cacheable(value = "products", key = "#productId"), // 第一次调用按ID缓存
    put = {
        @CachePut(value = "products", key = "#result.id"), // 每次调用都按返回结果的ID更新缓存
        @CachePut(value = "productsByName", key = "#result.name.toLowerCase()") // 每次调用都按返回结果的name更新另一个缓存
    }
)
public Product findProductById(Long productId) {
    System.out.println("Finding product by ID: " + productId);
    // 模拟查询并返回Product
    Product product = new Product(productId.intValue(), "Product " + productId, 100.0 * productId);
    return product;
}

}
“`

这个例子在一个方法上同时使用了 @Cacheable 和 @CachePut。当第一次调用 findProductById(1L) 时，它会执行方法（因为缓存未命中），并将结果存入 “products” 缓存，键为 “1”（由 @Cacheable 控制）。同时，由于 @CachePut 总是执行并将结果放入缓存，它会将结果放入 “products” 缓存（键为 result.id 即 “1”）和 “productsByName” 缓存（键为 result.name 的小写形式）。在后续调用中，如果按 ID 查找 (findProductById(1L))， @Cacheable 会命中缓存，直接返回结果，方法不再执行， @CachePut 也不会触发。这可能不是最佳组合，但展示了如何在一个方法上应用多个操作。更常见的场景可能是 @CachePut 和 @CacheEvict 的组合用于更新后失效相关缓存。

第四章：深入理解：键生成与条件缓存

1. 键生成策略 (Key Generation)

缓存的键是唯一标识缓存项的关键。Spring Cache 提供了灵活的键生成机制。

默认策略: 如果不指定 key 属性，Spring 会使用 SimpleKeyGenerator 作为默认策略。对于没有参数的方法，生成 SimpleKey.EMPTY。对于只有一个参数的方法，直接使用该参数作为键。对于有多个参数的方法，生成一个 SimpleKey 对象，其中包含所有参数。
使用 SpEL 表达式: @Cacheable 等注解的 key 属性支持 Spring Expression Language (SpEL)。这是最常用和灵活的方式。
- #paramName: 使用方法参数作为键。例如 #userId, #user.id.
- #a[index] 或 #p[index]: 使用方法参数数组中的元素。例如 #a[0] 表示第一个参数。
- #root: 提供了对根对象的访问，包括：
  - #root.method: 当前被缓存的方法对象。
  - #root.methodName: 方法名字符串。
  - #root.args: 方法参数数组。
  - #root.target: 目标对象（被代理的对象）。
  - #root.targetClass: 目标对象的类。
  - #root.caches: 与当前方法关联的缓存集合。
  - #root.returnValue: 方法的返回值（仅在 unless 和 @CachePut 中可用）。
- 结合其他 SpEL 语法，如对象属性访问 (#user.id), 方法调用 (#user.getName()), 字符串操作 (#productName.toLowerCase()), 静态方法调用 (T(java.lang.String).valueOf(#productId)), 运算符 (#id + "_" + #type) 等。

示例:

“`java
@Cacheable(value = “orders”, key = “#userId + ‘_’ + #orderType”) // 组合多个参数作为键
public List getOrdersByUserAndType(Long userId, String orderType) { … }

@Cacheable(value = “items”, key = “#item.id”) // 使用参数对象的属性作为键
public Item getItem(Item item) { … }

@Cacheable(value = “config”, key = “#root.methodName”) // 使用方法名作为键
public String getConfig() { … }
“`

自定义 KeyGenerator: 如果内置的或 SpEL 表达式无法满足需求，可以实现 org.springframework.cache.interceptor.KeyGenerator 接口，并将其配置为一个 Spring Bean。然后通过 @Cacheable(keyGenerator = "myCustomKeyGenerator") 属性引用。

示例:

“`java
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.cache.interceptor.SimpleKey;
import org.springframework.stereotype.Component;
import java.lang.reflect.Method;

@Component(“myCustomKeyGenerator”)
public class MyCustomKeyGenerator implements KeyGenerator {

@Override
public Object generate(Object target, Method method, Object... params) {
    // 示例：如果参数包含User对象，使用User的ID作为键，否则使用默认SimpleKey
    if (params.length > 0 && params[0] instanceof User) {
        return ((User) params[0]).getId();
    }
    return SimpleKey.generateValue(params);
}

}

// 使用自定义KeyGenerator
@Service
public class UserService {
@Cacheable(value = “users”, keyGenerator = “myCustomKeyGenerator”)
public User getUserByAnyMeans(Object identifier) { // identifier could be ID, username object, etc.
System.out.println(“Finding user using custom key generator: ” + identifier);
// … logic to find user …
return new User(1L, “Generated User”);
}
}
“`

2. 条件缓存 (Conditional Caching)

@Cacheable, @CachePut, @CacheEvict 都支持 condition 和 unless 属性，它们都是 SpEL 表达式，用于根据条件决定是否执行缓存操作。

condition: 在方法执行前评估。如果表达式结果为 true，则执行缓存操作（检查缓存或准备缓存结果）；如果为 false，则跳过整个缓存逻辑，直接执行方法。
- 常用于根据输入参数决定是否缓存。例如：condition="#userId > 0" 只缓存 ID 大于 0 的用户。
unless: 在方法执行后评估（在获取结果或方法返回后）。如果表达式结果为 true，则不执行缓存操作（不将结果放入缓存，或不清除缓存）；如果为 false，则执行缓存操作。
- 常用于根据方法返回值决定是否缓存。例如：unless="#result == null" 如果返回值为 null 则不缓存；unless="#result.size() == 0" 如果集合为空则不缓存。在 @CacheEvict 中，unless="#result == false" 可以表示只有当方法返回 true 时才清除缓存。

示例:

“`java
@Cacheable(value = “products”, key = “#productId”, condition = “#productId != null”) // 只在productId不为null时缓存
public Product getProductDetails(Long productId) { … }

@Cacheable(value = “results”, key = “#param”, unless = “#result.status != ‘SUCCESS'”) // 只在返回结果的status为SUCCESS时缓存
public Result processData(String param) { … }

@CacheEvict(value = “users”, key = “#userId”, condition = “#isAdmin”) // 只有当isAdmin参数为true时才清除缓存
public void deleteUser(Long userId, boolean isAdmin) { … }
“`

通过灵活运用 key、condition 和 unless，可以精确控制缓存的行为，满足各种复杂的业务需求。

第五章：缓存提供商集成与高级特性

Spring Cache 抽象层的一个强大之处在于可以轻松集成各种缓存提供商。只需要在配置中指定相应的 CacheManager 实现即可。

1. 常用的缓存提供商

ConcurrentMapCacheManager: Spring 内置，基于 java.util.concurrent.ConcurrentHashMap。简单，适合测试和小型应用，不支持分布式和持久化。
SimpleCacheManager: Spring 内置，允许你手动指定一个 java.util.concurrent.ConcurrentHashMap 集合作为底层存储。
CaffeineCacheManager: 集成 Caffeine 库，这是一个高性能的 Java 内存缓存库，是 Guava Cache 的改进替代品。
EhCacheCacheManager: 集成 Ehcache 库，一个流行的 Java 进程内缓存库，支持多种存储策略（内存、磁盘），功能丰富。
RedisCacheManager: 集成 Spring Data Redis，将 Redis 作为分布式缓存使用。支持持久化和分布式特性，适用于多实例应用。
JCacheCacheManager: 集成 JCache (JSR-107) 规范的实现，如 Hazelcast、Ehcache 3.x、Apache Ignite 等。提供了标准化的 API。

2. 配置示例 (以 Redis 为例)

使用 Redis 作为缓存提供商通常需要引入 Spring Data Redis 依赖，并配置 Redis 连接信息。Spring Boot 会自动配置 RedisCacheManager 如果它检测到 Redis 相关依赖和配置。

依赖:

xml <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-cache</artifactId> </dependency>

application.properties/yml:

“`properties
spring.redis.host=localhost
spring.redis.port=6379

其他Redis配置…

“`

Java 配置 (如果需要自定义序列化等):

Spring Boot 默认配置的 RedisCacheManager 会使用 Jackson2JsonRedisSerializer 进行序列化，但对于复杂的对象或需要更高效的序列化，可能需要自定义。

“`java
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import java.time.Duration;

@Configuration
@EnableCaching
public class RedisCacheConfig {

@Bean
public RedisCacheManager cacheManager(RedisConnectionFactory connectionFactory) {
    RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
        .entryTtl(Duration.ofMinutes(10)) // 设置默认缓存过期时间为10分钟
        // 配置键和值的序列化方式
        .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new org.springframework.data.redis.serializer.StringRedisSerializer()))
        .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer())) // 或者使用FastJsonRedisSerializer等
        .disableCachingNullValues(); // 不缓存null值

    return RedisCacheManager.builder(connectionFactory)
        .cacheDefaults(config)
        // 可以为特定的缓存区域设置不同的配置
        // .withCacheConfiguration("users", config.entryTtl(Duration.ofHours(1)))
        .transactionAware() // 启用事务支持
        .build();
}

}
“`

序列化注意事项:

当使用分布式缓存如 Redis 时，缓存的 Key 和 Value 都需要进行序列化和反序列化。确保你的对象是可序列化的（实现 Serializable 接口，或者使用 Jackson、Fastjson、Kryo 等库进行序列化）。Spring Data Redis 提供了多种序列化器。选择合适的序列化器对于性能和兼容性至关重要。

3. 缓存名称 (value 属性)

@Cacheable 等注解的 value 属性指定了缓存区域的名称。这个名称对应着 CacheManager 中管理的某个 Cache 实例。在配置 CacheManager 时，通常会指定它管理的缓存名称列表，或者 CacheManager 能够动态创建缓存。例如，ConcurrentMapCacheManager 可以通过构造函数指定名称，也可以在第一次使用某个名称时自动创建一个新的 ConcurrentMapCache。RedisCacheManager 等分布式缓存管理器通常也支持动态创建，或者在配置中预定义缓存及其属性（如过期时间）。

4. 缓存错误处理 (CacheErrorHandler)

缓存系统可能会发生故障（如缓存服务器宕机）。默认情况下，如果缓存操作发生异常，异常会向上抛出，可能导致应用中断。为了提高系统的健壮性，可以配置一个 CacheErrorHandler 来处理缓存错误。

实现 org.springframework.cache.interceptor.CacheErrorHandler 接口，并将其注册为 Spring Bean。

“`java
import org.springframework.cache.Cache;
import org.springframework.cache.interceptor.CacheErrorHandler;
import org.springframework.cache.interceptor.CacheOperationInvocationContext;
import org.springframework.cache.interceptor.CacheResolver;
import org.springframework.stereotype.Component;

@Component
public class MyCacheErrorHandler implements CacheErrorHandler {

@Override
public void handleCacheGetError(RuntimeException exception, Cache cache, Object key) {
    System.err.println("Cache Get Error: " + exception.getMessage() + " in cache " + cache.getName() + " for key " + key);
    // 可以选择记录日志，或者执行其他容错逻辑
    // 不要重新抛出异常，否则会中断正常的业务流程
}

@Override
public void handleCachePutError(RuntimeException exception, Cache cache, Object key, Object value) {
    System.err.println("Cache Put Error: " + exception.getMessage() + " in cache " + cache.getName() + " for key " + key);
}

@Override
public void handleCacheEvictError(RuntimeException exception, Cache cache, Object key) {
    System.err.println("Cache Evict Error: " + exception.getMessage() + " in cache " + cache.getName() + " for key " + key);
}

@Override
public void handleCacheClearError(RuntimeException exception, Cache cache) {
    System.err.println("Cache Clear Error: " + exception.getMessage() + " in cache " + cache.getName());
}

}
“`

通过实现这些方法，可以在缓存操作失败时执行自定义的处理逻辑，例如降级到直接访问后端数据源，或者仅仅记录错误日志而忽略缓存失败。

第六章：最佳实践与常见问题

使用 Spring Cache 虽然方便，但也需要遵循一些最佳实践并注意常见问题。

1. 选择合适的缓存提供商:
* 单应用实例、数据量不大且无需持久化，ConcurrentMap 或 Caffeine 是不错的选择。
* 分布式系统、需要共享缓存、数据量大或需要持久化，Redis、Memcached 或 JCache 实现（如 Hazelcast）是首选。

2. 精确控制缓存键:
* 确保键的唯一性，避免不同数据使用相同的键。
* 键应该包含所有影响方法结果的参数信息。
* 键的生成开销不应过大。
* 避免使用复杂对象作为键，除非正确实现了 equals() 和 hashCode() 方法，或者使用了支持对象作为键的序列化器。SpEL 是生成简单字符串键的常用且灵活的方式。

3. 合理设置缓存失效策略 (TTL/TTI):
* 为缓存项设置合理的过期时间 (Time To Live, TTL) 或最后访问时间 (Time To Idle, TTI)，防止缓存数据过旧。
* 对于数据更新不频繁但需要一致性较高的场景，TTL 和显式 @CacheEvict 结合使用。

4. 处理缓存一致性问题:
* 主动失效: 在数据更新、删除后，使用 @CacheEvict 清除对应的缓存项。
* 被动失效: 依赖缓存的 TTL/TTI 策略自动过期。适用于数据一致性要求不那么高，或者数据更新不频繁的场景。
* 读/写策略: 结合使用 @CachePut 和 @Cacheable，或者 @CacheEvict。例如，更新后使用 @CachePut 更新该项缓存，或使用 @CacheEvict 清除相关缓存。
* 在分布式环境中，缓存一致性更加复杂，可能需要依赖分布式缓存的特性或额外的机制。

5. 避免缓存穿透、击穿和雪崩:
* 缓存穿透: 查询一个不存在的数据，缓存和数据库都没有命中，导致每次查询都访问数据库。
* 解决方案：缓存空值（使用 unless="#result == null" 的反向逻辑），或者使用布隆过滤器。
* 缓存击穿: 某个热点数据过期时，大量请求同时涌入数据库。
* 解决方案：设置热点数据永不过期（配合后台刷新），或者使用分布式锁保证只有一个请求去加载数据并回写缓存。
* 缓存雪崩: 大量缓存项在同一时间过期，导致大量请求涌入数据库。
* 解决方案：为缓存项设置随机的过期时间，或者错开不同类型数据的过期时间。

6. 监控缓存状态:
* 集成监控工具（如 Micrometer、Spring Boot Actuator），监控缓存的命中率、未命中率、缓存大小、键数量等指标，以便及时发现和解决问题。

7. 小心使用 @Cacheable 的同步 (sync = true):
* 在 @Cacheable 中设置 sync = true 可以解决缓存击穿问题，它会同步地获取缓存值，如果未命中，只有一个线程会执行方法，其他等待。但这会阻塞其他请求，可能影响并发性能。谨慎使用，并在必要时结合分布式锁。

8. 缓存与事务:
* 默认情况下，缓存操作发生在事务提交之前。如果在事务中发生了异常导致回滚，但缓存操作（特别是 @CacheEvict 默认的 beforeInvocation = false）已经执行，可能导致缓存与数据库不一致。
* 将 @CacheEvict(beforeInvocation = true) 设置为在方法执行前清除，可以避免方法执行失败导致缓存残留脏数据的问题，但也可能导致方法执行失败时，缓存已经被清除而没有新的数据来填充。
* 对于需要强一致性的场景，考虑将缓存操作与事务绑定（例如，在事务提交后手动触发缓存更新或失效），但这会增加代码复杂性。Spring Cache 提供了 CacheManager 的 transactionAware() 方法，但其语义和适用场景需要仔细理解。

9. 代理陷阱:
* Spring Cache 是通过 AOP 实现的，通常使用代理（JDK 动态代理或 CGLIB 代理）。这意味着在同一个类内部，被代理对象的方法互相调用时，缓存注解可能不会生效。
* 例如，this.internalMethod() 调用类内部的另一个 @Cacheable 方法时，缓存切面可能不会被拦截。
* 解决方案：将需要缓存的方法放在不同的 Bean 中，或者配置 Spring AOP 使用 AspectJ 代理（适用于更复杂的场景）。Spring Boot 默认使用 CGLIB 代理，通常可以解决大部分内部调用问题，但最佳实践仍是避免内部调用带缓存注解的方法。

结论

Spring Cache 抽象层是 Spring Framework 为 Java 开发者提供的强大工具，它通过声明式的注解，极大地简化了缓存的集成和管理。开发者可以专注于业务逻辑，而将复杂的缓存细节交给 Spring 处理。通过合理地配置 CacheManager，选择合适的缓存提供商，并熟练运用 @Cacheable, @CachePut, @CacheEvict 等注解，结合精确的键生成、条件控制和错误处理，开发者能够有效地优化应用的性能瓶颈，构建出响应迅速、高吞吐量的现代高性能应用。

掌握 Spring Cache，意味着你手中多了一把构建高性能 Java 应用的利器。开始在你的项目中使用它吧，享受它带来的开发效率和性能提升！

Spring Cache：构建高性能应用的缓存利器 – wiki基地

Spring Cache：构建高性能应用的缓存利器

第一章：性能瓶颈与缓存的价值

第二章：Spring Cache 抽象层简介

第三章：快速上手：配置与基本使用

`@Cacheable`

`@CachePut`

`@CacheEvict`

`@Caching`

第四章：深入理解：键生成与条件缓存

第五章：缓存提供商集成与高级特性

其他Redis配置…

第六章：最佳实践与常见问题

结论

发表评论取消回复

Spring Cache：构建高性能应用的缓存利器

第一章：性能瓶颈与缓存的价值

第二章：Spring Cache 抽象层简介

第三章：快速上手：配置与基本使用

@Cacheable

@CachePut

@CacheEvict

@Caching

第四章：深入理解：键生成与条件缓存

第五章：缓存提供商集成与高级特性

其他Redis配置…

第六章：最佳实践与常见问题

结论

发表评论 取消回复

`@Cacheable`

`@CachePut`

`@CacheEvict`

`@Caching`

发表评论取消回复