缓存

Spring Framework 支持以透明方式向应用程序添加缓存。 抽象的核心是将缓存应用于方法，从而根据缓存中可用的信息减少执行次数。 缓存逻辑以透明方式应用，不会对调用程序造成任何干扰。 只要使用 @EnableCaching 注释启用了缓存支持， Spring Boot 就会自动配置缓存基础结构。spring-doc.cn

有关更多详细信息，请查看 Spring Framework 参考的相关部分。

简而言之，要将缓存添加到服务的操作中，请将相关 Comments 添加到其方法中，如以下示例所示：spring-doc.cn

import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Component;

@Component
public class MyMathService {

	@Cacheable("piDecimals")
	public int computePiDecimal(int precision) {
		...
	}

}
import org.springframework.cache.annotation.Cacheable
import org.springframework.stereotype.Component

@Component
class MyMathService {

	@Cacheable("piDecimals")
	fun computePiDecimal(precision: Int): Int {
		...
	}

}

此示例演示了如何在可能成本高昂的操作中使用缓存。 在 invoking 之前，抽象在缓存中查找与参数匹配的条目。 如果找到条目，则缓存中的内容会立即返回给调用方，并且不会调用该方法。 否则，将调用该方法，并在返回值之前更新缓存。computePiDecimalpiDecimalsprecisionspring-doc.cn

您还可以透明地使用标准 JSR-107 （JCache） 注释（例如 @CacheResult）。 但是，我们强烈建议您不要混合和匹配 Spring Cache 和 JCache 注释。

如果不添加任何特定的缓存库， Spring Boot 会自动配置一个简单的提供程序，该提供程序在内存中使用并发映射。 当需要缓存时（如前面的示例中），此提供程序会为您创建缓存。 简单提供程序并不真正推荐用于生产用途，但它非常适合入门并确保您了解这些功能。 当您决定要使用的缓存提供程序时，请务必阅读其文档以了解如何配置应用程序使用的缓存。 几乎所有提供程序都要求您显式配置在应用程序中使用的每个缓存。 有些提供了自定义属性定义的默认缓存的方法。piDecimalsspring.cache.cache-namesspring-doc.cn

还可以透明地从缓存中更新或逐出数据。

支持的缓存提供程序

缓存抽象不提供实际的存储，并且依赖于由 Cache 和 CacheManager 接口实现的抽象。spring-doc.cn

如果你还没有定义CacheManager类型的 Bean 或一个名为CacheResolver的 CacheResolver（参见CachingConfigurer），Spring Boot 会尝试检测以下提供程序（按指示的顺序）：cacheResolverspring-doc.cn

  1. 通用spring-doc.cn

  2. JCache （JSR-107）（EhCache 3、Hazelcast、Infinispan 等）spring-doc.cn

  3. Hazelcastspring-doc.cn

  4. Infinispan 无限spring-doc.cn

  5. Couchbasespring-doc.cn

  6. Redisspring-doc.cn

  7. 咖啡因spring-doc.cn

  8. 缓存2kspring-doc.cn

  9. 简单spring-doc.cn

此外，Spring Boot for Apache Geode 还提供了使用 Apache Geode 作为缓存提供程序的自动配置。spring-doc.cn

如果 Spring Boot 自动配置了CacheManager，则可以通过设置属性来强制使用特定的缓存提供程序。 如果需要在某些环境（例如测试）中使用无操作缓存，请使用此属性。spring.cache.type
使用 starter 快速添加基本缓存依赖项。 首发球员带来了 . 如果手动添加依赖项，则必须包含才能使用 JCache 或 Caffeine 支持。spring-boot-starter-cachespring-context-supportspring-context-support

如果CacheManager是由 Spring Boot 自动配置的，那么你可以通过公开实现CacheManagerCustomizer接口的 Bean ，在完全初始化之前进一步调整其配置。 下面的示例设置一个标志，以表示不应将值向下传递到底层 Map：nullspring-doc.cn

import org.springframework.boot.autoconfigure.cache.CacheManagerCustomizer;
import org.springframework.cache.concurrent.ConcurrentMapCacheManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration(proxyBeanMethods = false)
public class MyCacheManagerConfiguration {

	@Bean
	public CacheManagerCustomizer<ConcurrentMapCacheManager> cacheManagerCustomizer() {
		return (cacheManager) -> cacheManager.setAllowNullValues(false);
	}

}
import org.springframework.boot.autoconfigure.cache.CacheManagerCustomizer
import org.springframework.cache.concurrent.ConcurrentMapCacheManager
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration

@Configuration(proxyBeanMethods = false)
class MyCacheManagerConfiguration {

	@Bean
	fun cacheManagerCustomizer(): CacheManagerCustomizer<ConcurrentMapCacheManager> {
		return CacheManagerCustomizer { cacheManager ->
			cacheManager.isAllowNullValues = false
		}
	}

}
在前面的示例中，需要自动配置的ConcurrentMapCacheManager。 如果不是这种情况（您提供了自己的配置或自动配置了其他缓存提供程序），则根本不会调用定制器。 您可以根据需要拥有任意数量的定制器，也可以使用 @Order 或 Ordered 对它们进行排序。

通用

如果上下文定义了至少一个 Cache bean，则使用泛型缓存。 创建一个包装该类型的所有 bean 的CacheManager。spring-doc.cn

JCache （JSR-107）

JCache 是通过 CachingProvider 在 Classpath 上（即 Classpath 上存在符合 JSR-107 的缓存库）来引导的，并且 JCacheCacheManager 由Starters提供。 可以使用各种兼容的库，并且 Spring Boot 为 Ehcache 3、Hazelcast 和 Infinispan 提供依赖项管理。 也可以添加任何其他兼容的库。spring-boot-starter-cachespring-doc.cn

可能会存在多个提供程序，在这种情况下，必须显式指定提供程序。 即使 JSR-107 标准没有强制执行定义配置文件位置的标准化方法， Spring Boot 也会尽力适应使用实现细节设置缓存，如以下示例所示：spring-doc.cn

spring.cache.jcache.provider=com.example.MyCachingProvider
spring.cache.jcache.config=classpath:example.xml
# Only necessary if more than one provider is present
spring:
  cache:
    jcache:
      provider: "com.example.MyCachingProvider"
      config: "classpath:example.xml"
当缓存库同时提供本机实现和 JSR-107 支持时， Spring Boot 更喜欢 JSR-107 支持，因此，如果你切换到不同的 JSR-107 实现，则可以使用相同的功能。
Spring Boot 具有对 Hazelcast 的一般支持。 如果单个 HazelcastInstance 可用，则它也会自动重新用于 CacheManager，除非指定了该属性。spring.cache.jcache.config

有两种方法可以自定义底层 CacheManager：spring-doc.cn

如果定义了标准的CacheManager Bean，则它将自动包装在抽象期望的CacheManager实现中。 不会对其应用进一步的自定义。

Hazelcast

Spring Boot 具有对 Hazelcast 的一般支持。 如果 HazelcastInstance 已被自动配置并且位于 Classpath 上，则它会自动包装在 CacheManager 中。com.hazelcast:hazelcast-springspring-doc.cn

Hazelcast 可以用作符合 JCache 的缓存或符合 Spring CacheManager 的缓存。 当设置为 时，Spring Boot 将使用基于 CacheManager 的实现。 如果要将 Hazelcast 用作符合 JCache 的缓存，请设置为 . 如果您有多个符合 JCache 的缓存提供程序并希望强制使用 Hazelcast，则必须显式设置 JCache 提供程序。spring.cache.typehazelcastspring.cache.typejcache

Infinispan 无限

Infinispan 没有默认的配置文件位置，因此必须显式指定它。 否则，将使用默认引导程序。spring-doc.cn

spring.cache.infinispan.config=infinispan.xml
spring:
  cache:
    infinispan:
      config: "infinispan.xml"

可以通过设置属性在启动时创建缓存。 如果定义了自定义 ConfigurationBuilder Bean，则它用于自定义缓存。spring.cache.cache-namesspring-doc.cn

为了兼容 Spring Boot 的 Jakarta EE 9 基线，必须使用 Infinispan 的模块。 对于每个具有 variant 的模块，必须使用 variant 代替 standard module。 例如，和 必须分别代替 和 一起使用。-jakarta-jakartainfinispan-core-jakartainfinispan-commons-jakartainfinispan-coreinfinispan-commonsspring-doc.cn

Couchbase

如果 Spring Data Couchbase 可用并且配置了 Couchbase，则会自动配置 CouchbaseCacheManager。 可以通过设置属性在启动时创建其他缓存，并且可以使用 properties 配置缓存默认值。 例如，以下配置将创建并缓存条目过期时间为 10 分钟：spring.cache.cache-namesspring.cache.couchbase.*cache1cache2spring-doc.cn

spring.cache.cache-names=cache1,cache2
spring.cache.couchbase.expiration=10m
spring:
  cache:
    cache-names: "cache1,cache2"
    couchbase:
      expiration: "10m"

如果你需要对配置进行更多控制，请考虑注册一个CouchbaseCacheManagerBuilderCustomizer bean。 以下示例显示了一个定制器，该定制器为 和 配置特定的条目过期时间 ：cache1cache2spring-doc.cn

import java.time.Duration;

import org.springframework.boot.autoconfigure.cache.CouchbaseCacheManagerBuilderCustomizer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.couchbase.cache.CouchbaseCacheConfiguration;

@Configuration(proxyBeanMethods = false)
public class MyCouchbaseCacheManagerConfiguration {

	@Bean
	public CouchbaseCacheManagerBuilderCustomizer myCouchbaseCacheManagerBuilderCustomizer() {
		return (builder) -> builder
				.withCacheConfiguration("cache1", CouchbaseCacheConfiguration
						.defaultCacheConfig().entryExpiry(Duration.ofSeconds(10)))
				.withCacheConfiguration("cache2", CouchbaseCacheConfiguration
						.defaultCacheConfig().entryExpiry(Duration.ofMinutes(1)));

	}

}
import org.springframework.boot.autoconfigure.cache.CouchbaseCacheManagerBuilderCustomizer
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import org.springframework.data.couchbase.cache.CouchbaseCacheConfiguration
import java.time.Duration

@Configuration(proxyBeanMethods = false)
class MyCouchbaseCacheManagerConfiguration {

	@Bean
	fun myCouchbaseCacheManagerBuilderCustomizer(): CouchbaseCacheManagerBuilderCustomizer {
		return CouchbaseCacheManagerBuilderCustomizer { builder ->
			builder
				.withCacheConfiguration(
					"cache1", CouchbaseCacheConfiguration
						.defaultCacheConfig().entryExpiry(Duration.ofSeconds(10))
				)
				.withCacheConfiguration(
					"cache2", CouchbaseCacheConfiguration
						.defaultCacheConfig().entryExpiry(Duration.ofMinutes(1))
				)
		}
	}

}

Redis

如果 Redis 可用且已配置，则会自动配置 RedisCacheManager。 可以通过设置属性在启动时创建其他缓存，并且可以使用 properties 配置缓存默认值。 例如，以下配置创建并缓存生存时间为 10 分钟：spring.cache.cache-namesspring.cache.redis.*cache1cache2spring-doc.cn

spring.cache.cache-names=cache1,cache2
spring.cache.redis.time-to-live=10m
spring:
  cache:
    cache-names: "cache1,cache2"
    redis:
      time-to-live: "10m"
默认情况下，会添加键前缀，这样，如果两个单独的缓存使用相同的键，Redis 没有重叠的键，也不会返回无效值。 如果您创建自己的 RedisCacheManager，我们强烈建议您保持启用此设置。
您可以通过添加自己的 RedisCacheConfiguration @Bean来完全控制默认配置。 如果您需要自定义默认序列化策略，这可能很有用。

如果需要对配置进行更多控制，请考虑注册RedisCacheManagerBuilderCustomizer Bean。 以下示例显示了一个定制器，该定制器为 和 配置特定的生存时间 ：cache1cache2spring-doc.cn

import java.time.Duration;

import org.springframework.boot.autoconfigure.cache.RedisCacheManagerBuilderCustomizer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;

@Configuration(proxyBeanMethods = false)
public class MyRedisCacheManagerConfiguration {

	@Bean
	public RedisCacheManagerBuilderCustomizer myRedisCacheManagerBuilderCustomizer() {
		return (builder) -> builder
				.withCacheConfiguration("cache1", RedisCacheConfiguration
						.defaultCacheConfig().entryTtl(Duration.ofSeconds(10)))
				.withCacheConfiguration("cache2", RedisCacheConfiguration
						.defaultCacheConfig().entryTtl(Duration.ofMinutes(1)));

	}

}
import org.springframework.boot.autoconfigure.cache.RedisCacheManagerBuilderCustomizer
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import org.springframework.data.redis.cache.RedisCacheConfiguration
import java.time.Duration

@Configuration(proxyBeanMethods = false)
class MyRedisCacheManagerConfiguration {

	@Bean
	fun myRedisCacheManagerBuilderCustomizer(): RedisCacheManagerBuilderCustomizer {
		return RedisCacheManagerBuilderCustomizer { builder ->
			builder
				.withCacheConfiguration(
					"cache1", RedisCacheConfiguration
						.defaultCacheConfig().entryTtl(Duration.ofSeconds(10))
				)
				.withCacheConfiguration(
					"cache2", RedisCacheConfiguration
						.defaultCacheConfig().entryTtl(Duration.ofMinutes(1))
				)
		}
	}

}

咖啡因

Caffeine 是 Guava 缓存的 Java 8 重写，它取代了对 Guava 的支持。 如果存在 Caffeine，则会自动配置 CaffeineCacheManager（由 starter 提供）。 缓存可以通过设置属性在启动时创建，并且可以按以下选项之一（按指示的顺序）进行自定义：spring-boot-starter-cachespring.cache.cache-namesspring-doc.cn

  1. 由spring.cache.caffeine.specspring-doc.cn

  2. 定义了 CaffeineSpec beanspring-doc.cn

  3. 定义了咖啡因豆spring-doc.cn

例如，以下配置创建并缓存最大大小为 500 且生存时间为 10 分钟的缓存cache1cache2spring-doc.cn

spring.cache.cache-names=cache1,cache2
spring.cache.caffeine.spec=maximumSize=500,expireAfterAccess=600s
spring:
  cache:
    cache-names: "cache1,cache2"
    caffeine:
      spec: "maximumSize=500,expireAfterAccess=600s"

如果定义了 CacheLoader bean，则它将自动与 CaffeineCacheManager 相关联。 由于 CacheLoader 将与缓存管理器管理的所有缓存相关联，因此必须将其定义为 . auto-configuration 会忽略任何其他泛型类型。CacheLoader<Object, Object>spring-doc.cn

缓存2k

Cache2k 是内存中的缓存。 如果存在 Cache2k spring 集成，则会自动配置 a。SpringCache2kCacheManagerspring-doc.cn

可以通过设置属性在启动时创建缓存。 可以使用 Cache2kBuilderCustomizer bean 自定义缓存默认值。 以下示例显示了一个定制器，该定制器将缓存的容量配置为 200 个条目，过期时间为 5 分钟：spring.cache.cache-namesspring-doc.cn

import java.util.concurrent.TimeUnit;

import org.springframework.boot.autoconfigure.cache.Cache2kBuilderCustomizer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration(proxyBeanMethods = false)
public class MyCache2kDefaultsConfiguration {

	@Bean
	public Cache2kBuilderCustomizer myCache2kDefaultsCustomizer() {
		return (builder) -> builder.entryCapacity(200)
				.expireAfterWrite(5, TimeUnit.MINUTES);
	}

}
import org.springframework.boot.autoconfigure.cache.Cache2kBuilderCustomizer
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import java.util.concurrent.TimeUnit

@Configuration(proxyBeanMethods = false)
class MyCache2kDefaultsConfiguration {

	@Bean
	fun myCache2kDefaultsCustomizer(): Cache2kBuilderCustomizer {
		return Cache2kBuilderCustomizer { builder ->
			builder.entryCapacity(200)
				.expireAfterWrite(5, TimeUnit.MINUTES)
		}
	}
}

简单

如果找不到其他提供程序，则配置使用 ConcurrentHashMap 作为缓存存储的简单实现。 如果您的应用程序中不存在缓存库，则这是默认值。 默认情况下，缓存是根据需要创建的，但您可以通过设置属性来限制可用缓存的列表。 例如，如果只需要 and caches，请按如下方式设置该属性：cache-namescache1cache2cache-namesspring-doc.cn

spring.cache.cache-names=cache1,cache2
spring:
  cache:
    cache-names: "cache1,cache2"

如果您这样做，并且您的应用程序使用未列出的缓存，则它会在运行时需要缓存时失败，但在启动时不会失败。 这类似于使用未声明的缓存时“真实”缓存提供程序的行为方式。spring-doc.cn

没有

当 @EnableCaching 存在于您的配置中时，还需要合适的缓存配置。 如果你有一个自定义的' org.springframework.cache.CacheManager'，请考虑在单独的@Configuration类中定义它，以便你可以在必要时覆盖它。 None 使用在测试中有用的 no-op 实现，而 slice 测试默认通过 @AutoConfigureCache 使用它。spring-doc.cn

如果需要在特定环境中使用无操作缓存而不是自动配置的缓存管理器，请将缓存类型设置为 ，如以下示例所示：nonespring-doc.cn

spring.cache.type=none
spring:
  cache:
    type: "none"