输入输出

1. 缓存

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

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

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

Java

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

@Component
public class MyMathService {

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

}

Kotlin

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

@Component
class MyMathService {

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

}

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

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

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

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

1.1. 支持的缓存提供程序

缓存抽象不提供实际的存储，并且依赖于由和接口实现的抽象。org.springframework.cache.Cacheorg.springframework.cache.CacheManagerspring-doc.cn

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

通用 spring-doc.cn
JCache （JSR-107）（EhCache 3、Hazelcast、Infinispan 等）spring-doc.cn
EhCache 2.x 版本 spring-doc.cn
Hazelcast spring-doc.cn
Infinispan 无限 spring-doc.cn
Couchbase spring-doc.cn
Redis spring-doc.cn
咖啡因 spring-doc.cn
缓存2k spring-doc.cn
简单 spring-doc.cn

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

如果 Spring Boot 自动配置了，则可以通过设置属性来强制使用特定的缓存提供程序。如果需要在某些环境（例如测试）中使用无操作缓存，请使用此属性。CacheManagerspring.cache.type

使用 “Starter” 快速添加基本的缓存依赖项。首发球员带来了 . 如果您手动添加依赖项，则必须包含才能使用 JCache、EhCache 2.x 或 Caffeine 支持。spring-boot-starter-cachespring-context-supportspring-context-support

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

Java

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);
    }

}

Kotlin

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
        }
    }

}

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

1.1.1. 泛型

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

1.1.2. JCache （JSR-107）

JCache 是通过类路径上存在的 a 来引导的（即，类路径上存在符合 JSR-107 的缓存库），并且由“Starter”提供。可以使用各种兼容的库，并且 Spring Boot 为 Ehcache 3、Hazelcast 和 Infinispan 提供依赖项管理。也可以添加任何其他兼容的库。javax.cache.spi.CachingProviderJCacheCacheManagerspring-boot-starter-cachespring-doc.cn

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

性能

# Only necessary if more than one provider is present
spring.cache.jcache.provider=com.example.MyCachingProvider
spring.cache.jcache.config=classpath:example.xml

Yaml

# 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 的一般支持。如果 single 可用，则它也会自动重新用于，除非指定了该属性。HazelcastInstanceCacheManagerspring.cache.jcache.config

有两种方法可以自定义底层：javax.cache.cacheManagerspring-doc.cn

可以通过设置属性在启动时创建缓存。如果定义了自定义 Bean，则使用它来自定义它们。spring.cache.cache-namesjavax.cache.configuration.Configurationspring-doc.cn
org.springframework.boot.autoconfigure.cache.JCacheManagerCustomizerbean 是使用 for full customization.CacheManagerspring-doc.cn

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

1.1.3. EhCache 2.x

EhCache如果可以在 Classpath 的根目录中找到名为的文件，则使用 2.x。如果找到 EhCache 2.x，则使用 “Starter” 提供的 EhCache 来引导缓存管理器。还可以提供备用配置文件，如以下示例所示：ehcache.xmlEhCacheCacheManagerspring-boot-starter-cachespring-doc.cn

性能

spring.cache.ehcache.config=classpath:config/another-config.xml

Yaml

spring:
  cache:
    ehcache:
      config: "classpath:config/another-config.xml"

1.1.4. 黑泽尔广播

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

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

1.1.5. Infinispan

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

性能

spring.cache.infinispan.config=infinispan.xml

Yaml

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

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

Spring Boot 中对 Infinispan 的支持仅限于嵌入式模式，并且非常基本。如果你想要更多选项，你应该使用官方的 Infinispan Spring Boot Starters。有关更多详细信息，请参阅 Infinispan 的文档。

1.1.6. Couchbase

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

性能

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

Yaml

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

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

Java

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)));

    }

}

Kotlin

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))
                )
        }
    }

}

1.1.7. Redis

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

性能

spring.cache.cache-names=cache1,cache2
spring.cache.redis.time-to-live=10m

Yaml

spring:
  cache:
    cache-names: "cache1,cache2"
    redis:
      time-to-live: "10m"

默认情况下，会添加键前缀，这样，如果两个单独的缓存使用相同的键，Redis 没有重叠的键，也不会返回无效值。如果您创建自己的 .RedisCacheManager

您可以通过添加自己的来完全控制默认配置。如果您需要自定义默认序列化策略，这可能很有用。RedisCacheConfiguration@Bean

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

Java

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)));

    }

}

Kotlin

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))
                )
        }
    }

}

1.1.8. 咖啡因

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

由spring.cache.caffeine.specspring-doc.cn
定义了一个 beancom.github.benmanes.caffeine.cache.CaffeineSpecspring-doc.cn
定义了一个 beancom.github.benmanes.caffeine.cache.Caffeinespring-doc.cn

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

性能

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

Yaml

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

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

1.1.9. 缓存2k

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

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

Java

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);
    }

}

Kotlin

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)
        }
    }
}

1.1.10. 简单

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

性能

spring.cache.cache-names=cache1,cache2

Yaml

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

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

1.1.11. 无

当存在于您的配置中时，还需要合适的缓存配置。如果您有 custom ，请考虑在单独的类中定义它，以便在必要时可以覆盖它。 None 使用在测试中有用的无操作实现，而 slice 测试默认通过 .@EnableCachingCacheManager@Configuration@AutoConfigureCachespring-doc.cn

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

性能

spring.cache.type=none

Yaml

spring:
  cache:
    type: "none"

2. Hazelcast

如果 Hazelcast 在 Classpath 上并且找到了合适的配置，则 Spring Boot 会自动配置一个，你可以在应用程序中注入该配置。HazelcastInstancespring-doc.cn

Spring Boot 首先尝试通过检查以下配置选项来创建客户端：spring-doc.cn

Bean 的存在。com.hazelcast.client.config.ClientConfigspring-doc.cn
由属性定义的配置文件。spring.hazelcast.configspring-doc.cn
系统属性的存在。hazelcast.client.configspring-doc.cn
A 在工作目录中或 Classpath 的根目录中。hazelcast-client.xmlspring-doc.cn
工作目录中或 Classpath 的根目录中的 A（或）。hazelcast-client.yamlhazelcast-client.ymlspring-doc.cn

Hazelcast 3 支持已弃用。如果您仍然需要降级到 Hazelcast 3，则应将其添加到 Classpath 中以配置客户端。hazelcast-client

如果无法创建 Client 端，则 Spring Boot 将尝试配置嵌入式服务器。如果定义了一个 bean，Spring Boot 会使用它。如果您的配置定义了实例名称，则 Spring Boot 会尝试查找现有实例，而不是创建新实例。com.hazelcast.config.Configspring-doc.cn

您还可以指定要通过配置使用的 Hazelcast 配置文件，如以下示例所示：spring-doc.cn

性能

spring.hazelcast.config=classpath:config/my-hazelcast.xml

Yaml

spring:
  hazelcast:
    config: "classpath:config/my-hazelcast.xml"

否则， Spring Boot 会尝试从默认位置查找 Hazelcast 配置：在工作目录中或 Classpath 的根目录中，或者在同一位置的 YAML 对应项。我们还检查是否设置了 system 属性。有关更多详细信息，请参阅 Hazelcast 文档。hazelcast.xmlhazelcast.configspring-doc.cn

默认情况下，支持 on Hazelcast 组件。可以通过声明大于零的 bean 来覆盖。@SpringAwareManagementContextHazelcastConfigCustomizer@Order

Spring Boot 还具有对 Hazelcast 的显式缓存支持。如果启用了缓存，则会自动包装在 implementation 中。HazelcastInstanceCacheManager

3. Quartz 调度器

Spring Boot 为使用 Quartz 调度程序提供了多种便利，包括“Starter”。如果 Quartz 可用，则 a 是自动配置的（通过抽象）。spring-boot-starter-quartzSchedulerSchedulerFactoryBeanspring-doc.cn

以下类型的 bean 将被自动选取并与：Schedulerspring-doc.cn

JobDetail：定义特定的 Job。可以使用 API 构建实例。JobDetailJobBuilderspring-doc.cn
Calendar.spring-doc.cn
Trigger：定义何时触发特定作业。spring-doc.cn

默认情况下，使用 In-memory。但是，如果您的应用程序中有 Bean 可用并且该属性已相应地配置，则可以配置基于 JDBC 的存储，如以下示例所示：JobStoreDataSourcespring.quartz.job-store-typespring-doc.cn

性能

spring.quartz.job-store-type=jdbc

Yaml

spring:
  quartz:
    job-store-type: "jdbc"

使用 JDBC 存储时，可以在启动时初始化架构，如以下示例所示：spring-doc.cn

性能

spring.quartz.jdbc.initialize-schema=always

Yaml

spring:
  quartz:
    jdbc:
      initialize-schema: "always"

默认情况下，使用 Quartz 库提供的标准脚本检测和初始化数据库。这些脚本会删除现有表，并在每次重启时删除所有触发器。还可以通过设置 property 来提供自定义脚本。spring.quartz.jdbc.schema

要让 Quartz 使用应用程序的 main 以外的其他，请声明一个 bean，并用 . 这样做可确保 Quartz 特定的和用于架构初始化。同样，要让 Quartz 使用应用程序 main 以外的 a，请声明一个 bean，并用 .DataSourceDataSourceDataSource@Bean@QuartzDataSourceDataSourceSchedulerFactoryBeanTransactionManagerTransactionManagerTransactionManager@Bean@QuartzTransactionManagerspring-doc.cn

默认情况下，通过配置创建的作业不会覆盖已从持久性作业存储中读取的已注册作业。要启用覆盖现有作业定义，请设置该属性。spring.quartz.overwrite-existing-jobsspring-doc.cn

Quartz Scheduler 配置可以使用属性和 bean 进行自定义，这允许以编程方式进行自定义。高级 Quartz 配置属性可使用进行自定义。spring.quartzSchedulerFactoryBeanCustomizerSchedulerFactoryBeanspring.quartz.properties.*spring-doc.cn

特别是，bean 不与调度程序关联，因为 Quartz 提供了一种通过配置调度程序的方法。如果需要自定义任务执行程序，请考虑实施 .Executorspring.quartz.propertiesSchedulerFactoryBeanCustomizer

Job 可以定义 setter 来注入数据映射属性。常规 bean 也可以以类似的方式注入，如以下示例所示：spring-doc.cn

Java

import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

import org.springframework.scheduling.quartz.QuartzJobBean;

public class MySampleJob extends QuartzJobBean {

    // fields ...

    private MyService myService;

    private String name;

    // Inject "MyService" bean
    public void setMyService(MyService myService) {
        this.myService = myService;
    }

    // Inject the "name" job data property
    public void setName(String name) {
        this.name = name;
    }

    @Override
    protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
        this.myService.someMethod(context.getFireTime(), this.name);
    }

}

Kotlin

import org.quartz.JobExecutionContext
import org.springframework.scheduling.quartz.QuartzJobBean

class MySampleJob : QuartzJobBean() {

    // fields ...

    private var myService: MyService? = null

    private var name: String? = null

    // Inject "MyService" bean
    fun setMyService(myService: MyService?) {
        this.myService = myService
    }

    // Inject the "name" job data property
    fun setName(name: String?) {
        this.name = name
    }

    override fun executeInternal(context: JobExecutionContext) {
        myService!!.someMethod(context.fireTime, name)
    }

}

4. 发送电子邮件

Spring Framework 通过使用接口提供了发送电子邮件的抽象，而 Spring Boot 为其提供了自动配置以及 starter 模块。JavaMailSenderspring-doc.cn

有关如何使用的详细说明，请参阅参考文档。JavaMailSender

如果相关库（定义由）可用，则如果不存在，则创建默认值。 sender 可以通过命名空间中的配置项进一步自定义。有关更多详细信息，请参阅 MailProperties 。spring.mail.hostspring-boot-starter-mailJavaMailSenderspring.mailspring-doc.cn

特别是，某些默认超时值是无限的，您可能希望更改该值以避免线程被无响应的邮件服务器阻止，如以下示例所示：spring-doc.cn

性能

spring.mail.properties[mail.smtp.connectiontimeout]=5000
spring.mail.properties[mail.smtp.timeout]=3000
spring.mail.properties[mail.smtp.writetimeout]=5000

Yaml

spring:
  mail:
    properties:
      "[mail.smtp.connectiontimeout]": 5000
      "[mail.smtp.timeout]": 3000
      "[mail.smtp.writetimeout]": 5000

也可以使用 JNDI 中的现有配置 a：JavaMailSenderSessionspring-doc.cn

性能

spring.mail.jndi-name=mail/Session

Yaml

spring:
  mail:
    jndi-name: "mail/Session"

设置 a 后，它优先于所有其他与 Session 相关的设置。jndi-namespring-doc.cn

5. 验证

只要 JSR-303 实现（例如 Hibernate 验证器）在 Classpath 上，Bean Validation 1.1 支持的方法验证功能就会自动启用。这允许 bean 方法使用其参数和/或返回值的约束进行 Comments。具有此类 Comments 方法的目标类需要在类型级别使用 Comments 进行 Comments，以便搜索其方法的内联约束 Comments。javax.validation@Validatedspring-doc.cn

例如，以下服务触发第一个参数的验证，确保其大小介于 8 和 10 之间：spring-doc.cn

Java

import javax.validation.constraints.Size;

import org.springframework.stereotype.Service;
import org.springframework.validation.annotation.Validated;

@Service
@Validated
public class MyBean {

    public Archive findByCodeAndAuthor(@Size(min = 8, max = 10) String code, Author author) {
        return ...
    }

}

Kotlin

import org.springframework.stereotype.Service
import org.springframework.validation.annotation.Validated
import javax.validation.constraints.Size

@Service
@Validated
class MyBean {

    fun findByCodeAndAuthor(code: @Size(min = 8, max = 10) String?, author: Author?): Archive? {
        return null
    }

}

在 constraint 消息中解析时使用应用程序的 s。这允许您将应用程序的 messages.properties 文件用于 Bean 验证消息。解析参数后，将使用 Bean Validation 的默认插值器完成消息插值。MessageSource{parameters}spring-doc.cn

6. 调用 REST 服务

如果您的应用程序调用远程 REST 服务，Spring Boot 使用 a 或 a 可以非常方便地实现这一点。RestTemplateWebClientspring-doc.cn

6.1. RestTemplate

如果需要从应用程序调用远程 REST 服务，可以使用 Spring Framework 的 RestTemplate 类。由于实例通常需要在使用之前进行自定义，因此 Spring Boot 不提供任何单个自动配置的 bean。但是，它会自动配置，该可用于在需要时创建实例。 auto-configured 确保将 sensible 应用于实例。RestTemplateRestTemplateRestTemplateBuilderRestTemplateRestTemplateBuilderHttpMessageConvertersRestTemplatespring-doc.cn

以下代码显示了一个典型的示例：spring-doc.cn

Java

import org.springframework.boot.web.client.RestTemplateBuilder;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

@Service
public class MyService {

    private final RestTemplate restTemplate;

    public MyService(RestTemplateBuilder restTemplateBuilder) {
        this.restTemplate = restTemplateBuilder.build();
    }

    public Details someRestCall(String name) {
        return this.restTemplate.getForObject("/{name}/details", Details.class, name);
    }

}

Kotlin

import org.springframework.boot.web.client.RestTemplateBuilder
import org.springframework.stereotype.Service
import org.springframework.web.client.RestTemplate

@Service
class MyService(restTemplateBuilder: RestTemplateBuilder) {

    private val restTemplate: RestTemplate

    init {
        restTemplate = restTemplateBuilder.build()
    }

    fun someRestCall(name: String): Details {
        return restTemplate.getForObject(
            "/{name}/details",
            Details::class.java, name
        )!!
    }

}

RestTemplateBuilder包括许多有用的方法，可用于快速配置 . 例如，要添加 BASIC 身份验证支持，您可以使用 .RestTemplatebuilder.basicAuthentication("user", "password").build()

6.1.1. RestTemplate HTTP 客户端

Spring Boot 将根据应用程序 Classpath 上可用的库自动检测要使用的 HTTP 客户端。按优先顺序，支持以下客户端：RestTemplatespring-doc.cn

Apache HttpClientspring-doc.cn
OkHttpspring-doc.cn
简单 JDK 客户端（HttpURLConnection)spring-doc.cn

如果 Classpath 上有多个 Client 端可用，则将使用最首选的 Client 端。spring-doc.cn

6.1.2. RestTemplate 自定义

自定义有三种主要方法，具体取决于您希望自定义应用的范围。RestTemplatespring-doc.cn

要使任何自定义的范围尽可能窄，请注入 auto-configured，然后根据需要调用其方法。每个方法调用都会返回一个新实例，因此自定义项仅影响生成器的这种使用。RestTemplateBuilderRestTemplateBuilderspring-doc.cn

要进行应用程序范围的附加定制，请使用 Bean。所有这些 bean 都会自动注册到自动配置的 bean 中，并应用于使用它构建的任何模板。RestTemplateCustomizerRestTemplateBuilderspring-doc.cn

以下示例显示了一个定制器，该定制器为除以下主机之外的所有主机配置代理的使用：192.168.0.5spring-doc.cn

Java

import org.apache.http.HttpException;
import org.apache.http.HttpHost;
import org.apache.http.HttpRequest;
import org.apache.http.client.HttpClient;
import org.apache.http.conn.routing.HttpRoutePlanner;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.impl.conn.DefaultProxyRoutePlanner;
import org.apache.http.protocol.HttpContext;

import org.springframework.boot.web.client.RestTemplateCustomizer;
import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
import org.springframework.web.client.RestTemplate;

public class MyRestTemplateCustomizer implements RestTemplateCustomizer {

    @Override
    public void customize(RestTemplate restTemplate) {
        HttpRoutePlanner routePlanner = new CustomRoutePlanner(new HttpHost("proxy.example.com"));
        HttpClient httpClient = HttpClientBuilder.create().setRoutePlanner(routePlanner).build();
        restTemplate.setRequestFactory(new HttpComponentsClientHttpRequestFactory(httpClient));
    }

    static class CustomRoutePlanner extends DefaultProxyRoutePlanner {

        CustomRoutePlanner(HttpHost proxy) {
            super(proxy);
        }

        @Override
        public HttpHost determineProxy(HttpHost target, HttpRequest request, HttpContext context) throws HttpException {
            if (target.getHostName().equals("192.168.0.5")) {
                return null;
            }
            return super.determineProxy(target, request, context);
        }

    }

}

Kotlin

import org.apache.http.HttpException
import org.apache.http.HttpHost
import org.apache.http.HttpRequest
import org.apache.http.client.HttpClient
import org.apache.http.conn.routing.HttpRoutePlanner
import org.apache.http.impl.client.HttpClientBuilder
import org.apache.http.impl.conn.DefaultProxyRoutePlanner
import org.apache.http.protocol.HttpContext
import org.springframework.boot.web.client.RestTemplateCustomizer
import org.springframework.http.client.HttpComponentsClientHttpRequestFactory
import org.springframework.web.client.RestTemplate
import kotlin.jvm.Throws

class MyRestTemplateCustomizer : RestTemplateCustomizer {

    override fun customize(restTemplate: RestTemplate) {
        val routePlanner: HttpRoutePlanner = CustomRoutePlanner(HttpHost("proxy.example.com"))
        val httpClient: HttpClient = HttpClientBuilder.create().setRoutePlanner(routePlanner).build()
        restTemplate.requestFactory = HttpComponentsClientHttpRequestFactory(httpClient)
    }

    internal class CustomRoutePlanner(proxy: HttpHost?) : DefaultProxyRoutePlanner(proxy) {

        @Throws(HttpException::class)
        public override fun determineProxy(target: HttpHost, request: HttpRequest, context: HttpContext): HttpHost? {
            if (target.hostName == "192.168.0.5") {
                return null
            }
            return  super.determineProxy(target, request, context)
        }

    }

}

最后，您可以定义自己的 Bean。这样做将替换自动配置的生成器。如果您希望将任何 bean 应用于自定义构建器，就像自动配置所做的那样，请使用 . 下面的示例公开了一个与 Spring Boot 的自动配置相匹配的操作，只是还指定了自定义连接和读取超时：RestTemplateBuilderRestTemplateCustomizerRestTemplateBuilderConfigurerRestTemplateBuilderspring-doc.cn

Java

import java.time.Duration;

import org.springframework.boot.autoconfigure.web.client.RestTemplateBuilderConfigurer;
import org.springframework.boot.web.client.RestTemplateBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration(proxyBeanMethods = false)
public class MyRestTemplateBuilderConfiguration {

    @Bean
    public RestTemplateBuilder restTemplateBuilder(RestTemplateBuilderConfigurer configurer) {
        return configurer.configure(new RestTemplateBuilder())
            .setConnectTimeout(Duration.ofSeconds(5))
            .setReadTimeout(Duration.ofSeconds(2));
    }

}

Kotlin

import org.springframework.boot.autoconfigure.web.client.RestTemplateBuilderConfigurer
import org.springframework.boot.web.client.RestTemplateBuilder
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import java.time.Duration

@Configuration(proxyBeanMethods = false)
class MyRestTemplateBuilderConfiguration {

    @Bean
    fun restTemplateBuilder(configurer: RestTemplateBuilderConfigurer): RestTemplateBuilder {
        return configurer.configure(RestTemplateBuilder()).setConnectTimeout(Duration.ofSeconds(5))
            .setReadTimeout(Duration.ofSeconds(2))
    }

}

最极端（也很少使用）的选项是在不使用配置器的情况下创建自己的 bean。除了替换自动配置的构建器之外，这还会阻止使用任何 bean。RestTemplateBuilderRestTemplateCustomizerspring-doc.cn

6.2. Web客户端

如果你的 Classpath 上有 Spring WebFlux，你也可以选择用于调用远程 REST 服务。与相比，这个客户端具有更多的功能感并且完全反应性。您可以在 Spring Framework 文档的专用部分中了解更多信息。WebClientRestTemplateWebClientspring-doc.cn

Spring Boot 为您创建并预配置一个。强烈建议将其注入到您的组件中并使用它来创建实例。 Spring Boot 正在配置该构建器以共享 HTTP 资源，以与服务器相同的方式反映编解码器设置（参见 WebFlux HTTP 编解码器自动配置）等等。WebClient.BuilderWebClientspring-doc.cn

以下代码显示了一个典型的示例：spring-doc.cn

Java

import org.neo4j.cypherdsl.core.Relationship.Details;
import reactor.core.publisher.Mono;

import org.springframework.stereotype.Service;
import org.springframework.web.reactive.function.client.WebClient;

@Service
public class MyService {

    private final WebClient webClient;

    public MyService(WebClient.Builder webClientBuilder) {
        this.webClient = webClientBuilder.baseUrl("https://example.org").build();
    }

    public Mono<Details> someRestCall(String name) {
        return this.webClient.get().uri("/{name}/details", name).retrieve().bodyToMono(Details.class);
    }

}

Kotlin

import org.neo4j.cypherdsl.core.Relationship
import org.springframework.stereotype.Service
import org.springframework.web.reactive.function.client.WebClient
import reactor.core.publisher.Mono

@Service
class MyService(webClientBuilder: WebClient.Builder) {

    private val webClient: WebClient

    init {
        webClient = webClientBuilder.baseUrl("https://example.org").build()
    }

    fun someRestCall(name: String?): Mono<Relationship.Details> {
        return webClient.get().uri("/{name}/details", name).retrieve().bodyToMono(
            Relationship.Details::class.java
        )
    }

}

6.2.1. WebClient 运行时

Spring Boot 将根据应用程序 Classpath 上可用的库自动检测使用哪个来驱动。按优先顺序，支持以下客户端：ClientHttpConnectorWebClientspring-doc.cn

Reactor Nettyspring-doc.cn
Jetty RS 客户端spring-doc.cn
Apache HttpClientspring-doc.cn
JDK HttpClientspring-doc.cn

如果 Classpath 上有多个 Client 端可用，则将使用最首选的 Client 端。spring-doc.cn

starter 依赖于 by default，它带来了 server 和 client 实现。如果您选择使用 Jetty 作为反应式服务器，则应添加对 Jetty 反应式 HTTP 客户端库的依赖项。对服务器和客户端使用相同的技术有其优势，因为它会自动在客户端和服务器之间共享 HTTP 资源。spring-boot-starter-webfluxio.projectreactor.netty:reactor-nettyorg.eclipse.jetty:jetty-reactive-httpclientspring-doc.cn

开发人员可以通过提供自定义或 bean 来覆盖 Jetty 和 Reactor Netty 的资源配置——这将应用于客户端和服务器。ReactorResourceFactoryJettyResourceFactoryspring-doc.cn

如果您希望为 Client 端覆盖该选择，则可以定义自己的 Bean 并完全控制 Client 端配置。ClientHttpConnectorspring-doc.cn

您可以在 Spring Framework 参考文档中了解有关 WebClient 配置选项的更多信息。spring-doc.cn

6.2.2. WebClient 自定义

自定义有三种主要方法，具体取决于您希望自定义应用的范围。WebClientspring-doc.cn

要使任何自定义的范围尽可能窄，请注入 auto-configured，然后根据需要调用其方法。实例是有状态的：生成器上的任何更改都会反映在随后使用它创建的所有客户端中。如果要使用同一生成器创建多个客户端，还可以考虑使用克隆生成器。WebClient.BuilderWebClient.BuilderWebClient.Builder other = builder.clone();spring-doc.cn

要对所有实例进行应用程序范围的附加自定义，您可以声明 bean 并在注入点本地更改。WebClient.BuilderWebClientCustomizerWebClient.Builderspring-doc.cn

最后，您可以回退到原始 API 并使用 . 在这种情况下，不会应用任何自动配置 or。WebClient.create()WebClientCustomizerspring-doc.cn

7. Web 服务

Spring Boot 提供 Web 服务自动配置，因此您只需定义 .Endpointsspring-doc.cn

Spring Web Services 功能可以通过该模块轻松访问。spring-boot-starter-webservicesspring-doc.cn

SimpleWsdl11Definition并且可以分别为 WSDL 和 XSD 自动创建 bean。为此，请配置其位置，如以下示例所示：SimpleXsdSchemaspring-doc.cn

性能

spring.webservices.wsdl-locations=classpath:/wsdl

Yaml

spring:
  webservices:
    wsdl-locations: "classpath:/wsdl"

7.1. 使用 WebServiceTemplate 调用 Web 服务

如果需要从应用程序调用远程 Web 服务，可以使用 WebServiceTemplate 类。由于实例通常需要在使用之前进行自定义，因此 Spring Boot 不提供任何单个自动配置的 bean。但是，它会自动配置，该可用于在需要时创建实例。WebServiceTemplateWebServiceTemplateWebServiceTemplateBuilderWebServiceTemplatespring-doc.cn

以下代码显示了一个典型的示例：spring-doc.cn

Java

import org.springframework.boot.webservices.client.WebServiceTemplateBuilder;
import org.springframework.stereotype.Service;
import org.springframework.ws.client.core.WebServiceTemplate;
import org.springframework.ws.soap.client.core.SoapActionCallback;

@Service
public class MyService {

    private final WebServiceTemplate webServiceTemplate;

    public MyService(WebServiceTemplateBuilder webServiceTemplateBuilder) {
        this.webServiceTemplate = webServiceTemplateBuilder.build();
    }

    public SomeResponse someWsCall(SomeRequest detailsReq) {
        return (SomeResponse) this.webServiceTemplate.marshalSendAndReceive(detailsReq,
                new SoapActionCallback("https://ws.example.com/action"));
    }

}

Kotlin

import org.springframework.boot.webservices.client.WebServiceTemplateBuilder
import org.springframework.stereotype.Service
import org.springframework.ws.client.core.WebServiceTemplate
import org.springframework.ws.soap.client.core.SoapActionCallback

@Service
class MyService(webServiceTemplateBuilder: WebServiceTemplateBuilder) {

    private val webServiceTemplate: WebServiceTemplate

    init {
        webServiceTemplate = webServiceTemplateBuilder.build()
    }

    fun someWsCall(detailsReq: SomeRequest?): SomeResponse {
        return webServiceTemplate.marshalSendAndReceive(
            detailsReq,
            SoapActionCallback("https://ws.example.com/action")
        ) as SomeResponse
    }

}

默认情况下，使用 Classpath 上可用的 HTTP 客户端库检测合适的基于 HTTP 的 HTTP。您还可以自定义读取和连接超时，如下所示：WebServiceTemplateBuilderWebServiceMessageSenderspring-doc.cn

Java

import java.time.Duration;

import org.springframework.boot.webservices.client.HttpWebServiceMessageSenderBuilder;
import org.springframework.boot.webservices.client.WebServiceTemplateBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.ws.client.core.WebServiceTemplate;
import org.springframework.ws.transport.WebServiceMessageSender;

@Configuration(proxyBeanMethods = false)
public class MyWebServiceTemplateConfiguration {

    @Bean
    public WebServiceTemplate webServiceTemplate(WebServiceTemplateBuilder builder) {
        WebServiceMessageSender sender = new HttpWebServiceMessageSenderBuilder()
                .setConnectTimeout(Duration.ofSeconds(5))
                .setReadTimeout(Duration.ofSeconds(2))
                .build();
        return builder.messageSenders(sender).build();
    }

}

Kotlin

import org.springframework.boot.webservices.client.HttpWebServiceMessageSenderBuilder
import org.springframework.boot.webservices.client.WebServiceTemplateBuilder
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import org.springframework.ws.client.core.WebServiceTemplate
import java.time.Duration

@Configuration(proxyBeanMethods = false)
class MyWebServiceTemplateConfiguration {

    @Bean
    fun webServiceTemplate(builder: WebServiceTemplateBuilder): WebServiceTemplate {
        val sender = HttpWebServiceMessageSenderBuilder()
            .setConnectTimeout(Duration.ofSeconds(5))
            .setReadTimeout(Duration.ofSeconds(2))
            .build()
        return builder.messageSenders(sender).build()
    }

}

8. 使用 JTA 进行分布式事务

Spring Boot 通过使用 Atomikos 嵌入式事务管理器支持跨多个 XA 资源的分布式 JTA 事务。部署到合适的 Java EE Application Server 时，也支持 JTA 事务。spring-doc.cn

当检测到 JTA 环境时， Spring 的用于管理事务。自动配置的 JMS、DataSource 和 JPA bean 已升级以支持 XA 事务。您可以使用标准的 Spring 惯用语（如）来参与分布式事务。如果您在 JTA 环境中，并且仍希望使用本地事务，则可以将该属性设置为以禁用 JTA 自动配置。JtaTransactionManager@Transactionalspring.jta.enabledfalsespring-doc.cn

8.1. 使用 Atomikos 事务管理器

Atomikos 是一种流行的开源事务管理器，可以嵌入到 Spring Boot 应用程序中。您可以使用 starter 拉入相应的 Atomikos 库。 Spring Boot 会自动配置 Atomikos 并确保将适当的设置应用于 Spring bean，以实现正确的启动和关闭顺序。spring-boot-starter-jta-atomikosdepends-onspring-doc.cn

默认情况下，Atomikos 事务日志将写入应用程序主目录（应用程序 jar 文件所在的目录）中的目录。您可以通过在文件中设置属性来自定义此目录的位置。以开头的属性也可用于自定义 Atomikos 。有关完整详细信息，请参阅 AtomikosProperties Javadoc。transaction-logsspring.jta.log-dirapplication.propertiesspring.jta.atomikos.propertiesUserTransactionServiceImpspring-doc.cn

为了确保多个事务管理器可以安全地协调相同的资源管理器，必须为每个 Atomikos 实例配置一个唯一的 ID。默认情况下，此 ID 是运行 Atomikos 的计算机的 IP 地址。为了确保生产中的唯一性，您应该为应用程序的每个实例配置具有不同值的属性。spring.jta.transaction-manager-id

8.2. 使用 Java EE Managed Transaction Manager

如果将 Spring Boot 应用程序打包为 or 文件并将其部署到 Java EE 应用程序服务器，则可以使用应用程序服务器的内置事务管理器。 Spring Boot 尝试通过查看常见的 JNDI 位置（、、等）来自动配置事务 Management 器。如果使用应用程序服务器提供的事务服务，则通常还希望确保所有资源都由服务器管理并通过 JNDI 公开。 Spring Boot 尝试通过在 JNDI 路径（或）中查找 a 来自动配置 JMS，您可以使用 spring.datasource.jndi-name 属性来配置您的 .warearjava:comp/UserTransactionjava:comp/TransactionManagerConnectionFactoryjava:/JmsXAjava:/XAConnectionFactoryDataSourcespring-doc.cn

8.3. 混合 XA 和非 XA JMS 连接

使用 JTA 时，主 JMS Bean 是 XA 感知的，并参与分布式事务。您可以注入到 bean 中，而无需使用任何：ConnectionFactory@Qualifierspring-doc.cn

Java

public MyBean(ConnectionFactory connectionFactory) {
    // ...
}

Kotlin

在某些情况下，您可能希望使用 non-XA 来处理某些 JMS 消息。例如，您的 JMS 处理逻辑可能比 XA 超时花费的时间更长。ConnectionFactoryspring-doc.cn

如果要使用非 XA ，则可以将 bean ：ConnectionFactorynonXaJmsConnectionFactoryspring-doc.cn

Java

public MyBean(@Qualifier("nonXaJmsConnectionFactory") ConnectionFactory connectionFactory) {
    // ...
}

Kotlin

为了保持一致性，还通过使用 bean alias 来提供 bean：jmsConnectionFactoryxaJmsConnectionFactoryspring-doc.cn

Java

public MyBean(@Qualifier("xaJmsConnectionFactory") ConnectionFactory connectionFactory) {
    // ...
}

Kotlin

8.4. 支持替代的嵌入式事务管理器

XAConnectionFactoryWrapper 和 XADataSourceWrapper 接口可用于支持替代的嵌入式事务管理器。这些接口负责包装 bean 并将它们公开为 regular 和 bean，它们透明地注册到分布式事务中。 DataSource 和 JMS 自动配置使用 JTA 变体，前提是您在 .XAConnectionFactoryXADataSourceConnectionFactoryDataSourceJtaTransactionManagerApplicationContextspring-doc.cn

AtomikosXAConnectionFactoryWrapper 和 AtomikosXADataSourceWrapper 提供了如何编写 XA 包装器的良好示例。spring-doc.cn

9. 接下来要读什么

现在，您应该对 Spring Boot 的核心功能以及 Spring Boot 通过自动配置提供支持的各种技术有了很好的了解。spring-doc.cn

接下来的几节详细介绍了如何将应用程序部署到云平台。您可以在下一节中阅读有关构建容器映像的信息，也可以跳至生产就绪功能部分。spring-doc.cn