作者

菲利普· 韦伯，戴夫 Syer，约什 长，斯特凡 尼科尔，罗布 绞车，安迪· 威尔金森，马塞尔 Overdijk，基督教 杜普伊斯，塞巴斯蒂安· 德勒兹，迈克尔· 西蒙斯，韦德兰Pavić

本文件的副本可供您自己使用和分发给他人，前提是您不对此类副本收取任何费用，并且每份副本均包含本版权声明，无论是以印刷版还是电子版分发。

第一部分Spring Boot文档

第二部分。入门

Spring Boot is compatible with Apache Maven 3.2 or above. If you don’t already have Maven installed you can follow the instructions at maven.apache.org.

	On many operating systems Maven can be installed via a package manager. If you’re an OSX Homebrew user try brew install maven. Ubuntu users can run sudo apt-get install maven. Windows users with Chocolatey can run choco install maven from an elevated prompt.

Spring Boot dependencies use the org.springframework.boot groupId. Typically your Maven POM file will inherit from the spring-boot-starter-parent project and declare dependencies to one or more “Starters”. Spring Boot also provides an optional Maven plugin to create executable jars.

Here is a typical pom.xml file:

<？xml version =“1.0”encoding =“UTF-8”？>

<project  xmlns = “http://maven.apache.org/POM/4.0.0”  xmlns：xsi = “http：//www.w3 .org / 2001 / XMLSchema-instance“

    xsi：schemaLocation = ”http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd“ >

    <modelVersion> 4.0.0 </ modelVersion>

    <groupId> com.example </ groupId>

    <artifactId> myproject </ artifactId>

    <version> 0.0.1-SNAPSHOT </ version>

    <！ - 继承默认值为Spring Boot  - >

    <parent>

        <groupId> org.springframework.boot </ groupId>

        <artifactId> spring-boot-starter-parent </ artifactId>

        <version> 2.0.0.M3 < / version>

    </ parent>

    <！ - 添加Web应用程序的典型依赖项 - >

    <dependencies>

        <dependency>

            <groupId> org.springframework.boot </ groupId>

            <artifactId> spring-boot-starter-web </ artifactId>

        </ dependency>

    </依赖>

    <！ - 打包为可执行jar  - >

    <build>

        <plugins>

            <plugin>

                <groupId> org.springframework.boot </ groupId>

                <artifactId> spring-boot-maven-plugin </ artifactId>

            </ plugin >

        </ plugins>

    </ build>

    <！ - 添加Spring存储库 - >

    <！ - （如果使用的是.RELEASE版本，则不需要这样） - >

    <存储库>

        <存储库>

            <id> spring-snapshots </ id>

            < url> http://repo.spring.io/snapshot </ url>

            <snapshots> <enabled> true </ enabled> </ snapshots>

        </ repository>

        <repository>

            <id> spring-milestones </ id>

            < url> http://repo.spring.io/milestone </ url>

        </ repository>

    </ repositories>

    <pluginRepositories>

        <pluginRepository>

            <id> spring-snapshots </ id>

            <url>http://repo.spring.io/snapshot </ url>

        </ pluginRepository>

        <pluginRepository>

            <id> spring-milestones </ id>

            <url> http://repo.spring.io/milestone </ url>

        </ pluginRepository>

    </ pluginRepositories>

</ project>

	这spring-boot-starter-parent是使用Spring Boot的好方法，但它可能并不适合所有时间。有时您可能需要从不同的父POM继承，或者您可能不喜欢我们的默认设置。有关使用 范围的替代解决方案，请参见 第13.2.2节“在没有父POM的情况下使用Spring Boot”import。

Spring Boot与Gradle 3（3.4或更高版本）兼容。如果您尚未安装Gradle，则可以按照www.gradle.org/上的说明进行操作。

Spring Boot依赖项可以使用org.springframework.boot group。通常，您的项目将声明依赖于一个或多个 “Starters”。Spring Boot提供了一个有用的Gradle插件 ，可用于简化依赖声明和创建可执行jar。

这是一个典型的build.gradle文件：

buildscript {

    存储库{

        jcenter（）

        maven {url'http ://repo.spring.io/snapshot' }

        maven {url'http ：//repo.spring.io/milestone' }

    }

    依赖{

        classpath'org.springframework.boot ：spring-boot-gradle-plugin：2.0.0.M3'

    }

}

apply plugin：' java'apply

plugin：'org.springframework.boot'apply

plugin：'io.spring.dependency-management'

jar {

    baseName = 'myproject'version

    =   '0.0.1-SNAPSHOT'

}

存储库{

    jcenter（）

    maven {url “http://repo.spring.io/snapshot” }

    maven {url “http://repo.spring.io/milestone” }

}

依赖{

    编译（“org.springframework.boot：spring-boot-starter-web”）

    testCompile（“org.springframework.boot：spring-boot-starter-test”）

}

您可以从Spring软件库下载Spring CLI发行版：

还提供最先进的快照分发。

下载完成后，请按照 解压缩的存档中的INSTALL.txt说明进行操作。总结：文件中的目录中有一个spring脚本（spring.bat对于Windows），或者您也可以使用该文件（脚本可以帮助您确保正确设置类路径）。bin/.zipjava -jar.jar

SDKMAN！（软件开发工具包管理器）可用于管理各种二进制SDK的多个版本，包括Groovy和Spring Boot CLI。获取SDKMAN！来自sdkman.io并安装Spring Boot

$ sdk install springboot

$ spring --version

Spring Boot v2.0.0.M3

如果您正在为CLI开发功能并希望轻松访问刚构建的版本，请遵循这些额外说明。

$ sdk install springboot dev /path/to/spring-boot/spring-boot-cli/target/spring-boot-cli-2.0.0.M3-bin/spring-2.0.0.M3/

$ sdk默认springboot dev

$ spring --version

Spring CLI v2.0.0.M3

这将安装一个spring名为dev实例的本地实例。它指向您的目标构建位置，因此每次重建Spring Boot时，spring都将是最新的。

你可以通过这样做看到它：

$ sdk ls springboot

================================================== ==============================

可用的Springboot版本

================================================== ==============================

> + dev

* 2.0.0.M3

================================================== ==============================

+  - 本地版本

*  - 已安装

>  - 目前正在使用中

================================================== ==============================

如果您使用的是Mac并使用Homebrew，那么安装Spring Boot CLI所需要做的就是：

$ brew tap pivotal / tap

$ brew install springboot

Homebrew将安装spring到/usr/local/bin。

	如果您没有看到公式，那么您的brew安装可能已过时。只需执行brew update并再试一次。

如果您使用的是Mac并使用MacPorts，那么安装Spring Boot CLI所需要做的就是：

$ sudo port install spring-boot-cli

Spring Boot CLI附带了为BASH和 zsh shell 提供命令完成的脚本 。您可以在任何shell中创建source脚本（也称为 spring），或者将其放在个人或系统范围的bash完成初始化中。在Debian系统上，系统范围的脚本都在，/shell-completion/bash 并且当新shell启动时，该目录中的所有脚本都会被执行。要手动运行脚本，例如，如果已使用SDKMAN安装！

$。〜/ .sdkman /候选人/ springboot /电流/壳完成/庆典/弹簧

$ spring <HIT TAB HERE>

  抓住帮助jar运行测试版

	如果使用Homebrew或MacPorts安装Spring Boot CLI，命令行完成脚本将自动注册到shell。

这是一个非常简单的Web应用程序，可用于测试您的安装。创建一个名为的文件app.groovy：

@RestController

类 ThisWillActuallyRun {

    @RequestMapping（ “/”）

    String home（）{

        “你好，世界！”

    }

}

然后只需从shell运行它：

$ spring run app.groovy

	首次运行应用程序时需要一些时间，因为下载了依赖项。后续运行会更快。

在您喜欢的Web浏览器中打开localhost：8080，您应该看到以下输出：

你好，世界！

我们Example班上的第一个注释是@RestController。这被称为 构造型注释。它为阅读代码的人提供了提示，对于Spring，该类扮演着特定的角色。在这种情况下，我们的类是一个Web，@Controller所以Spring在处理传入的Web请求时会考虑它。

该@RequestMapping注释提供“路由”的信息。它告诉Spring，任何带有路径“/”的HTTP请求都应该映射到该home方法。该 @RestController注解告诉Spring使得到的字符串直接返回给调用者。

	在@RestController与@RequestMapping注解是Spring MVC的注解（他们并不是专门针对春季启动）。有关更多详细信息，请参阅Spring参考文档中的MVC部分。

The second class-level annotation is @EnableAutoConfiguration. This annotation tells Spring Boot to “guess” how you will want to configure Spring, based on the jar dependencies that you have added. Since spring-boot-starter-web added Tomcat and Spring MVC, the auto-configuration will assume that you are developing a web application and setup Spring accordingly.

The final part of our application is the main method. This is just a standard method that follows the Java convention for an application entry point. Our main method delegates to Spring Boot’s SpringApplication class by calling run. SpringApplication will bootstrap our application, starting Spring which will in turn start the auto-configured Tomcat web server. We need to pass Example.class as an argument to the run method to tell SpringApplication which is the primary Spring component. The args array is also passed through to expose any command-line arguments.

Java没有提供任何标准方法来加载嵌套的jar文件（即jar文件本身包含在jar中）。如果您要分发自包含的应用程序，这可能会有问题。

为了解决这个问题，许多开发人员使用“超级”罐子。一个超级jar简单地将所有类中的所有类打包成一个存档。这种方法的问题在于，很难看到您在应用程序中实际使用的库。如果在多个罐子中使用相同的文件名（但具有不同的内容），也可能会有问题。

Spring Boot采用不同的方法，允许您直接嵌套jar。

第三部分。使用Spring Boot

• Java 1.8 as the default compiler level.
• UTF-8 source encoding.
• A Dependency Management section, allowing you to omit <version> tags for common dependencies, inherited from the spring-boot-dependencies POM.
• Sensible resource filtering.
• Sensible plugin configuration (exec plugin, surefire, Git commit ID, shade).
• Sensible resource filtering for application.properties and application.yml including profile-specific files (e.g. application-foo.properties and application-foo.yml)

To configure your project to inherit from the spring-boot-starter-parent simply set the parent:

<!-- Inherit defaults from Spring Boot -->

<parent>

    <groupId>org.springframework.boot</groupId>

    <artifactId>spring-boot-starter-parent</artifactId>

    <version>2.0.0.M3</version>

</parent>

	You should only need to specify the Spring Boot version number on this dependency. If you import additional starters, you can safely omit the version number.

With that setup, you can also override individual dependencies by overriding a property in your own project. For instance, to upgrade to another Spring Data release train you’d add the following to your pom.xml.

<properties>

    <spring-data-releasetrain.version>Fowler-SR2</spring-data-releasetrain.version>

</properties>

	Check the spring-boot-dependencies pom for a list of supported properties.

Not everyone likes inheriting from the spring-boot-starter-parent POM. You may have your own corporate standard parent that you need to use, or you may just prefer to explicitly declare all your Maven configuration.

If you don’t want to use the spring-boot-starter-parent, you can still keep the benefit of the dependency management (but not the plugin management) by using a scope=import dependency:

<dependencyManagement>

     <dependencies>

        <dependency>

            <!-- Import dependency management from Spring Boot -->

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-dependencies</artifactId>

            <version>2.0.0.M3</version>

            <type>pom</type>

            <scope>import</scope>

        </dependency>

    </dependencies>

</dependencyManagement>

That setup does not allow you to override individual dependencies using a property as explained above. To achieve the same result, you’d need to add an entry in thedependencyManagement of your project before the spring-boot-dependencies entry. For instance, to upgrade to another Spring Data release train you’d add the following to your pom.xml.

<dependencyManagement>

    <dependencies>

        <！ - 覆盖Spring Boot提供的Spring Data版本系列 - >

        <dependency>

            <groupId> org.springframework.data </ groupId>

            <artifactId> spring-data-releasetrain </ artifactId>

            < version> Fowler-SR2 </ version>

            <scope> import </ scope>

            <type> pom </ type>

        </ dependency>

        <dependency>

            <groupId> org.springframework.boot </ groupId>

            <artifactId> spring-boot -dependencies </ artifactId>

            <version>2.0.0.M3 </ version>

            <type> pom</ type>

            <scope> import </ scope>

        </ dependency>

    </ dependencies>

</ dependencyManagement>

	在上面的示例中，我们指定了BOM，但是可以通过这种方式覆盖任何依赖关系类型。

Spring Boot包含一个Maven插件 ，可以将项目打包为可执行jar。<plugins> 如果要使用它，请将插件添加到您的部分：

<build>

    <plugins>

        <plugin>

            <groupId> org.springframework.boot </ groupId>

            <artifactId> spring-boot-maven-plugin </ artifactId>

        </ plugin>

    </ plugins>

</ build>

	如果使用Spring Boot启动程序父pom，则只需添加插件，除非要更改父项中定义的设置，否则无需对其进行配置。

• 参考（HTML和 PDF）
• API

所有官方首发都遵循类似的命名模式; spring-boot-starter-*，哪里*是特定类型的应用程序。此命名结构旨在帮助您找到启动器。许多IDE中的Maven集成允许您按名称搜索依赖项。例如，安装了适当的Eclipse或STS插件后，您只需点击ctrl-spacePOM编辑器并输入“spring-boot-starter”即可获得完整列表。

正如创建自己的启动程序 部分所述，第三方启动程序不应该spring-boot以为官方Spring Boot工件保留的方式开头。acme通常会命名 第三方启动器acme-spring-boot-starter。

Table 13.1. Spring Boot application starters

Table 13.2. Spring Boot production starters

Table 13.3. Spring Boot technical starters

As DevTools monitors classpath resources, the only way to trigger a restart is to update the classpath. The way in which you cause the classpath to be updated depends on the IDE that you are using. In Eclipse, saving a modified file will cause the classpath to be updated and trigger a restart. In IntelliJ IDEA, building the project (Build -> Make Project) will have the same effect.

The restart technology provided by Spring Boot works by using two classloaders. Classes that don’t change (for example, those from third-party jars) are loaded into a base classloader. Classes that you’re actively developing are loaded into a restart classloader. When the application is restarted, the restart classloader is thrown away and a new one is created. This approach means that application restarts are typically much faster than “cold starts” since the base classloader is already available and populated.

If you find that restarts aren’t quick enough for your applications, or you encounter classloading issues, you could consider reloading technologies such as JRebelfrom ZeroTurnaround. These work by rewriting classes as they are loaded to make them more amenable to reloading.

Certain resources don’t necessarily need to trigger a restart when they are changed. For example, Thymeleaf templates can just be edited in-place. By default changing resources in /META-INF/maven, /META-INF/resources ,/resources ,/static ,/public or /templates will not trigger a restart but will trigger a live reload. If you want to customize these exclusions you can use the spring.devtools.restart.exclude property. For example, to exclude only /static and /public you would set the following:

spring.devtools.restart.exclude=static/**,public/**

	if you want to keep those defaults and add additional exclusions, use the spring.devtools.restart.additional-exclude property instead.

You may want your application to be restarted or reloaded when you make changes to files that are not on the classpath. To do so, use thespring.devtools.restart.additional-paths property to configure additional paths to watch for changes. You can use the spring.devtools.restart.excludeproperty described above to control whether changes beneath the additional paths will trigger a full restart or just a live reload.

If you don’t want to use the restart feature you can disable it using the spring.devtools.restart.enabled property. In most cases you can set this in yourapplication.properties (this will still initialize the restart classloader but it won’t watch for file changes).

If you need to completely disable restart support, for example, because it doesn’t work with a specific library, you need to set a System property before callingSpringApplication.run(…​). For example:

public static void main(String[] args) {

    System.setProperty("spring.devtools.restart.enabled", "false");

    SpringApplication.run(MyApp.class, args);

}

如果使用不断编译已更改文件的IDE，则可能更喜欢仅在特定时间触发重新启动。为此，您可以使用“触发器文件”，这是一个特殊文件，当您想要实际触发重新启动检查时，必须对其进行修改。更改文件只会触发检查，只有在Devtools检测到必须执行某些操作时才会重新启动。触发器文件可以手动更新，也可以通过IDE插件更新。

要使用触发器文件，请使用该spring.devtools.restart.trigger-file属性。

	您可能希望将其设置spring.devtools.restart.trigger-file为 全局设置，以便所有项目的行为方式相同。

如上面的Restart vs Reload部分所述，使用两个类加载器实现了重启功能。对于大多数应用程序，此方法很有效，但有时它可能会导致类加载问题。

默认情况下，IDE中的任何打开项目都将使用“restart”类加载器加载，任何常规.jar文件都将使用“base”类加载器加载。如果您处理多模块项目，而不是将每个模块导入IDE，则可能需要自定义项目。为此，您可以创建一个META-INF/spring-devtools.properties文件。

该spring-devtools.properties文件可以包含restart.exclude.和 restart.include.前缀属性。该include元素是应该被拉高到“重启”的类加载器的项目，以及exclude要素是应该向下推入“基地”类加载器的项目。属性的值是将应用于类路径的正则表达式模式。

例如：

restart.exclude.companycommonlibs = / MyCorp的共用- [\\瓦特- ]。+ \罐子

 restart.include.projectcommon = / MyCorp的-的Myproj - [\\瓦特- ]。+ \罐

	所有属性键必须是唯一的。只要房产开始 restart.include.或restart.exclude.将被考虑。

	META-INF/spring-devtools.properties将加载所有类路径。您可以将文件打包到项目中，也可以打包在项目使用的库中。

对于使用标准反序列化的对象，重新启动功能不起作用ObjectInputStream。如果你需要反序列化的数据，你可能需要使用Spring的ConfigurableObjectInputStream结合 Thread.currentThread().getContextClassLoader()。

不幸的是，几个第三方库反序列化而不考虑上下文类加载器。如果您发现此类问题，则需要向原始作者请求修复。

远程客户端应用程序旨在从IDE中运行。您需要org.springframework.boot.devtools.RemoteSpringApplication使用与要连接的远程项目相同的类路径运行 。传递给应用程序的非选项参数应该是您要连接的远程URL。

例如，如果您使用的是Eclipse或STS，并且您有一个名为my-app已部署到Cloud Foundry的项目，那么您将执行以下操作：

正在运行的远程客户端将如下所示：

  。____ _ __ _ _

 / \\ / ___'_ __ _ _（_）_ __ __ _ ___ _ \ \ \ \

（（）\ ___ |'_ |'_ ||'_ \ / _` | | _ \ ___ _ __ ___ | | _ ___ \ \ \ \

 \\ / ___）| | _）| | | | | || （_ | [] :::::: [] / -_）'\ / _ \ _ / -_））））））

  '  |____| .__|_| |_|_| |_\__, |        |_|_\___|_|_|_\___/\__\___|/ / / /

 =========|_|==============|___/===================================/_/_/_/

 :: Spring Boot Remote :: 2.0.0.M3

2015-06-10 18:25:06.632  INFO 14938 --- [           main] o.s.b.devtools.RemoteSpringApplication   : Starting RemoteSpringApplication on pwmbp with PID 14938 (/Users/pwebb/projects/spring-boot/code/spring-boot-devtools/target/classes started by pwebb in /Users/pwebb/projects/spring-boot/code/spring-boot-samples/spring-boot-sample-devtools)

2015-06-10 18:25:06.671  INFO 14938 --- [           main] s.c.a.AnnotationConfigApplicationContext : Refreshing org.springframework.context.annotation.AnnotationConfigApplicationContext@2a17b7b6: startup date [Wed Jun 10 18:25:06 PDT 2015]; root of context hierarchy

2015-06-10 18:25:07.043  WARN 14938 --- [           main] o.s.b.d.r.c.RemoteClientConfiguration    : The connection to http://localhost:8080 is insecure. You should use a URL starting with 'https://'.

2015-06-10 18:25:07.074  INFO 14938 --- [           main] o.s.b.d.a.OptionalLiveReloadServer       : LiveReload server is running on port 35729

2015-06-10 18:25:07.130  INFO 14938 --- [           main] o.s.b.devtools.RemoteSpringApplication   : Started RemoteSpringApplication in 0.74 seconds (JVM running for 1.105)

	Because the remote client is using the same classpath as the real application it can directly read application properties. This is how the spring.devtools.remote.secret property is read and passed to the server for authentication.

	It’s always advisable to use https:// as the connection protocol so that traffic is encrypted and passwords cannot be intercepted.

	If you need to use a proxy to access the remote application, configure the spring.devtools.remote.proxy.host and spring.devtools.remote.proxy.port properties.

The remote client will monitor your application classpath for changes in the same way as the local restart. Any updated resource will be pushed to the remote application and (if required) trigger a restart. This can be quite helpful if you are iterating on a feature that uses a cloud service that you don’t have locally. Generally remote updates and restarts are much quicker than a full rebuild and deploy cycle.

	Files are only monitored when the remote client is running. If you change a file before starting the remote client, it won’t be pushed to the remote server.

第四部分。Spring Boot功能

Table 23.1. Banner variables

1. 一个ApplicationStartingEvent是在一个运行开始发送，但除了听众和初始化的登记任何处理之前。
2. 一个ApplicationEnvironmentPreparedEvent当被发送Environment到在上下文已知被使用，但是在创建上下文之前。
3. 一个ApplicationPreparedEvent被发送刷新开始之前，但经过bean定义已经被加载。
4. ApplicationReadyEvent在刷新之后发送一个并且已经处理了任何相关的回调以指示应用程序已准备好服务请求。
5. 一个ApplicationFailedEvent如果在启动时异常发送。

1. 一个/config当前目录下的子目录。
2. 当前目录
3. 一个classpath /config包
4. 类路径根

1. file:./config/
2. file:./
3. classpath:/config/
4. classpath:/

1. file:./custom-config/
2. classpath:custom-config/
3. file:./config/
4. file:./
5. classpath:/config/
6. classpath:/

Spring Framework提供了两个方便的类，可用于加载YAML文档。在YamlPropertiesFactoryBean将加载YAML作为Properties和 YamlMapFactoryBean将加载YAML作为Map。

例如，以下YAML文档：

环境：

     dev：

         url：http：//dev.bar.com

         名称：Developer Setup

     prod：

         url：http：//foo.bar.com

         name：My Cool App

将转化为这些属性：

environments.dev.url = http://dev.bar.com

 environments.dev.name =开发人员设置

 environment.prod.url = http://foo.bar.com

 environments.prod.name =我的酷应用

YAML列表表示为具有[index]解除引用的属性键，例如此YAML：

我的：

    服务器：

       -  dev.bar.com

       -  foo.bar.com

将转化为这些属性：

my.servers [0] = dev.bar.com

 my.servers [1] = foo.bar.com

要使用Spring DataBinder实用程序绑定到类似的属性（这是什么 @ConfigurationProperties），您需要在类型java.util.List（或Set）的目标bean中具有属性， 并且您需要提供一个setter，或者使用可变值初始化它，例如this将绑定到上面的属性

@ConfigurationProperties（prefix =“my”）

 public  class Config {

    private List <String> servers = new ArrayList <String>（）;

    public List <String> getServers（）{

         return  this .servers;

    }

}

	配置列表时需要格外小心，因为覆盖将无法正常工作。在上面的示例中，当my.servers在多个位置重新定义时，各个元素的目标是覆盖，而不是列表。要确保 PropertySource具有更高优先级的a可以覆盖列表，您需要将其定义为单个属性： 我的： 服务器：dev.bar.com，foo.bar.com

本YamlPropertySourceLoader类可用于暴露YAML作为PropertySource 在春节Environment。这允许您使用熟悉的@Value注释和占位符语法来访问YAML属性。

您可以使用spring.profiles键指定文档何时适用，从而在单个文件中指定多个特定于配置文件的YAML文档。例如：

服务器：

     地址：192.168。1.100

---

spring：

     profiles：开发

 服务器：

     地址：127.0。0.1

---

spring：

     profiles：生产

 服务器：

     地址：192.168。1.120

在上面的示例中，如果 配置文件处于活动状态，则server.address属性为。如果未 启用和配置文件，则属性的值将为。127.0.0.1developmentdevelopmentproduction192.168.1.100

如果在应用程序上下文启动时没有显式活动，则激活默认配置文件。因此，在这个YAML我们设定的值security.user.password是 只可在“默认”的个人资料：

server：

   port：8000

---

spring：

   profiles：默认

 安全：

   user：

     密码：弱

whereas in this example, the password is always set because it isn’t attached to any profile, and it would have to be explicitly reset in all other profiles as necessary:

server:

  port: 8000

security:

  user:

    password: weak

Spring profiles designated using the "spring.profiles" element may optionally be negated using the ! character. If both negated and non-negated profiles are specified for a single document, at least one non-negated profile must match and no negated profiles may match.

YAML files can’t be loaded via the @PropertySource annotation. So in the case that you need to load values that way, you need to use a properties file.

As we have seen above, any YAML content is ultimately transformed to properties. That process may be counter intuitive when overriding “list” properties via a profile.

For example, assume a MyPojo object with name and description attributes that are null by default. Let’s expose a list of MyPojo from FooProperties:

@ConfigurationProperties("foo")

public class FooProperties {

    private final List<MyPojo> list = new ArrayList<>();

    public List<MyPojo> getList() {

        return this.list;

    }

}

Consider the following configuration:

foo：

   list：

     -  name：my name

       description：my description

 ---

spring：

   profiles：dev

 foo：

   list：

     -  name：my another name

如果dev配置文件未激活，FooProperties.list将包含一个MyPojo如上定义的条目。dev但是，如果启用了配置文件，list则仍将 只包含一个条目（名称为“我的另一个名称”和描述null）。此配置不会MyPojo向列表添加第二个实例，也不会合并项目。

在多个配置文件中指定集合时，将使用具有最高优先级的集合（并且仅使用该集合）：

foo：

   list：

     -  name：my name

       description：my description

     -  name：another name

       description：another description

 ---

spring：

   profiles：dev

 foo：

   list：

      -  name：my another name

在上面的示例中，考虑到dev配置文件处于活动状态，FooProperties.list 将包含一个 MyPojo条目（名称为“我的另一个名称”和描述null）。

• foo.enabled，false默认情况下
• foo.remote-address，具有可以强制的类型 String
• foo.security.username，带有嵌套的“安全性”，其名称由属性名称决定。特别是那里根本没有使用返回类型SecurityProperties
• foo.security.password
• foo.security.roles，收集 String

As well as using @ConfigurationProperties to annotate a class, you can also use it on public @Bean methods. This can be particularly useful when you want to bind properties to third-party components that are outside of your control.

To configure a bean from the Environment properties, add @ConfigurationProperties to its bean registration:

@ConfigurationProperties(prefix = "bar")
@Bean

public BarComponent barComponent() {

    ...

}

Any property defined with the bar prefix will be mapped onto that BarComponent bean in a similar manner as the FooProperties example above.

Spring Boot uses some relaxed rules for binding Environment properties to @ConfigurationProperties beans, so there doesn’t need to be an exact match between the Environment property name and the bean property name. Common examples where this is useful include dashed separated (e.g. context-path binds to contextPath), and capitalized (e.g. PORT binds to port) environment properties.

For example, given the following @ConfigurationProperties class:

@ConfigurationProperties（prefix =“person”）

 public  class OwnerProperties {

    private String firstName;

    public String getFirstName（）{

         return  this .firstName;

    }

    public  void setFirstName（String firstName）{

         this .firstName = firstName;

    }

}

可以使用以下属性名称：

	prefix注释的值必须是kebab-case，即小写并以其分隔-。

	我们建议，如果可能，属性以小写kebab格式存储。即my.property-name=foo

Spring will attempt to coerce the external application properties to the right type when it binds to the @ConfigurationProperties beans. If you need custom type conversion you can provide a ConversionService bean (with bean id conversionService) or custom property editors (via a CustomEditorConfigurer bean) or custom Converters (with bean definitions annotated as @ConfigurationPropertiesBinding).

As this bean is requested very early during the application lifecycle, make sure to limit the dependencies that your ConversionService is using. Typically, any dependency that you require may not be fully initialized at creation time. You may want to rename your custom ConversionService if it’s not required for configuration keys coercion and only rely on custom converters qualified with @ConfigurationPropertiesBinding.

Spring Boot will attempt to validate @ConfigurationProperties classes whenever they are annotated with Spring’s @Validated annotation. You can use JSR-303 javax.validation constraint annotations directly on your configuration class. Simply ensure that a compliant JSR-303 implementation is on your classpath, then add constraint annotations to your fields:

@ConfigurationProperties(prefix="foo")
@Validated

public class FooProperties {

    @NotNull

    private InetAddress remoteAddress;

    // ... getters and setters

}

In order to validate values of nested properties, you must annotate the associated field as @Valid to trigger its validation. For example, building upon the aboveFooProperties example:

@ConfigurationProperties(prefix="connection")
@Validated

public class FooProperties {

    @NotNull

    private InetAddress remoteAddress;

    @Valid

    private final Security security = new Security();

    // ... getters and setters

    public static class Security {

        @NotEmpty

        public String username;

        // ... getters and setters

    }

}

您还可以Validator通过创建名为的bean定义 来添加自定义Spring configurationPropertiesValidator。@Bean应声明该方法static。配置属性验证器是在应用程序生命周期的早期创建的，并将该@Bean方法声明为static，允许创建bean而无需实例化@Configuration该类。这避免了早期实例化可能导致的任何问题。有一个 属性验证示例，您可以看到如何设置。

	该spring-boot-actuator模块包括一个暴露所有@ConfigurationPropertiesbean 的端点 。只需将Web浏览器指向/configprops 或使用等效的JMX端点即可。请参阅 生产就绪功能。部分了解详情。

@Value是一个核心容器功能，它不提供与类型安全的配置属性相同的功能。下表汇总了支持的功能@ConfigurationProperties和@Value：

如果为自己的组件定义一组配置键，我们建议您将它们分组到带注释的POJO中@ConfigurationProperties。另请注意，由于@Value不支持宽松绑定，因此如果需要使用环境变量提供值，则不是一个很好的选择。

最后，虽然您可以编写SpEL表达式@Value，但不会从Application属性文件处理此类表达式。

• 日期和时间 - 毫秒精度，易于排序。
• 日志级别- ，  ERROR，，WARN 或。INFODEBUGTRACE
• 进程ID。
• 一个---分离器来区分实际日志消息的开始。
• 线程名称 - 括在方括号中（可能会截断控制台输出）。
• Logger name — This is usually the source class name (often abbreviated).
• The log message.

If your terminal supports ANSI, color output will be used to aid readability. You can set spring.output.ansi.enabled to a supported value to override the auto detection.

Color coding is configured using the %clr conversion word. In its simplest form the converter will color the output according to the log level, for example:

%clr(%5p)

The mapping of log level to a color is as follows:

Alternatively, you can specify the color or style that should be used by providing it as an option to the conversion. For example, to make the text yellow:

%clr(%d{yyyy-MM-dd HH:mm:ss.SSS}){yellow}

The following colors and styles are supported:

Table 26.1. Logging properties

该<springProfile>标签允许您有选择地包括或排除基于主动春型材配置的部分。在<configuration>元素内的任何位置都支持配置文件节。使用该name属性指定哪个配置文件接受配置。可以使用逗号分隔列表指定多个配置文件。

<springProfile  name = “staging” >

    <！ - “暂存”配置文件处于活动状态时启用的配置 - >

</ springProfile>

<springProfile  name = “dev，staging” >

    <！ - 在“dev”或“staging”配置文件处于活动状态时启用的配置 - >

</ springProfile>

<springProfile  name = “！production” >

    <！ - “生产”配置文件未激活时要启用的配置 - >

</ springProfile>

The <springProperty> tag allows you to surface properties from the Spring Environment for use within Logback. This can be useful if you want to access values from your application.properties file in your logback configuration. The tag works in a similar way to Logback’s standard <property> tag, but rather than specifying a direct value you specify the source of the property (from the Environment). You can use the scope attribute if you need to store the property somewhere other than in local scope. If you need a fallback value in case the property is not set in the Environment, you can use the defaultValue attribute.

<springProperty scope="context" name="fluentHost" source="myapp.fluentd.host"

        defaultValue="localhost"/>

<appender name="FLUENT" class="ch.qos.logback.more.appenders.DataFluentAppender">

    <remoteHost>${fluentHost}</remoteHost>

    ...

</appender>

	The source must be specified using kebab-case (my.property-name). However, properties can be added to the Environment using the relaxed rules.

Spring Boot为Spring MVC提供自动配置，适用于大多数应用程序。

自动配置在Spring的默认值之上添加了以下功能：

如果你想保留Spring Boot MVC功能，并且你只想添加额外的MVC配置（拦截器，格式化程序，视图控制器等），你可以添加自己的@Configuration类类型WebMvcConfigurer，但没有 @EnableWebMvc。如果您希望提供自定义实例RequestMappingHandlerMapping，RequestMappingHandlerAdapter或者ExceptionHandlerExceptionResolver您可以声明WebMvcRegistrationsAdapter 提供此类组件的实例。

如果您想完全控制Spring MVC，可以添加自己的@Configuration 注释@EnableWebMvc。

Spring MVC使用该HttpMessageConverter接口来转换HTTP请求和响应。灵敏的默认值包含在开箱即用中，例如，对象可以自动转换为JSON（使用Jackson库）或XML（如果可用则使用Jackson XML扩展，否则使用JAXB）。字符串UTF-8默认使用。

如果您需要添加或自定义转换器，可以使用Spring Boot的 HttpMessageConverters类：

import org.springframework.boot.autoconfigure.web.HttpMessageConverters;

import org.springframework.context.annotation。*;

import org.springframework.http.converter。*;

@Configuration

公共 类 MyConfiguration {

    @Bean

     public HttpMessageConverters customConverters（）{

        HttpMessageConverter<?> additional = ...

        HttpMessageConverter<?> another = ...

        return new HttpMessageConverters(additional, another);

    }

}

Any HttpMessageConverter bean that is present in the context will be added to the list of converters. You can also override default converters that way.

If you’re using Jackson to serialize and deserialize JSON data, you might want to write your own JsonSerializer and JsonDeserializer classes. Custom serializers are usually registered with Jackson via a Module, but Spring Boot provides an alternative @JsonComponent annotation which makes it easier to directly register Spring Beans.

You can use @JsonComponent directly on JsonSerializer or JsonDeserializer implementations. You can also use it on classes that contains serializers/deserializers as inner-classes. For example:

import java.io.*;

import com.fasterxml.jackson.core.*;

import com.fasterxml.jackson.databind.*;

import org.springframework.boot.jackson.*;

@JsonComponent

public class Example {

    public static class Serializer extends JsonSerializer<SomeObject> {

        // ...

    }

    public static class Deserializer extends JsonDeserializer<SomeObject> {

        // ...

    }

}

All @JsonComponent beans in the ApplicationContext will be automatically registered with Jackson, and since @JsonComponent is meta-annotated with @Component, the usual component-scanning rules apply.

Spring Boot also provides JsonObjectSerializer and JsonObjectDeserializer base classes which provide useful alternatives to the standard Jackson versions when serializing Objects. See the Javadoc for details.

Spring MVC has a strategy for generating error codes for rendering error messages from binding errors: MessageCodesResolver. Spring Boot will create one for you if you set the spring.mvc.message-codes-resolver.format property PREFIX_ERROR_CODE or POSTFIX_ERROR_CODE (see the enumeration in DefaultMessageCodesResolver.Format).

By default Spring Boot will serve static content from a directory called /static (or /public or /resources or /META-INF/resources) in the classpath or from the root of the ServletContext. It uses the ResourceHttpRequestHandler from Spring MVC so you can modify that behavior by adding your own WebMvcConfigurerand overriding the addResourceHandlers method.

In a stand-alone web application the default servlet from the container is also enabled, and acts as a fallback, serving content from the root of the ServletContext if Spring decides not to handle it. Most of the time this will not happen (unless you modify the default MVC configuration) because Spring will always be able to handle requests through the DispatcherServlet.

By default, resources are mapped on /** but you can tune that via spring.mvc.static-path-pattern. For instance, relocating all resources to /resources/**can be achieved as follows:

spring.mvc.static-path-pattern=/resources/**

You can also customize the static resource locations using spring.resources.static-locations (replacing the default values with a list of directory locations). If you do this the default welcome page detection will switch to your custom locations, so if there is an index.html in any of your locations on startup, it will be the home page of the application.

In addition to the ‘standard’ static resource locations above, a special case is made for Webjars content. Any resources with a path in /webjars/** will be served from jar files if they are packaged in the Webjars format.

	Do not use the src/main/webapp directory if your application will be packaged as a jar. Although this directory is a common standard, it will only work with war packaging and it will be silently ignored by most build tools if you generate a jar.

Spring Boot also supports advanced resource handling features provided by Spring MVC, allowing use cases such as cache busting static resources or using version agnostic URLs for Webjars.

To use version agnostic URLs for Webjars, simply add the webjars-locator dependency. Then declare your Webjar, taking jQuery for example, as "/webjars/jquery/dist/jquery.min.js" which results in "/webjars/jquery/x.y.z/dist/jquery.min.js" where x.y.z is the Webjar version.

	If you are using JBoss, you’ll need to declare the webjars-locator-jboss-vfs dependency instead of the webjars-locator; otherwise all Webjars resolve as a 404.

To use cache busting, the following configuration will configure a cache busting solution for all static resources, effectively adding a content hash in URLs, such as<link href="/css/spring-2a2d595e6ed9a0b24f027f2b63b134d6.css"/>:

spring.resources.chain.strategy.content.enabled=true

spring.resources.chain.strategy.content.paths=/**

	Links to resources are rewritten at runtime in template, thanks to a ResourceUrlEncodingFilter, auto-configured for Thymeleaf and FreeMarker. You should manually declare this filter when using JSPs. Other template engines aren’t automatically supported right now, but can be with custom template macros/helpers and the use of the ResourceUrlProvider.

When loading resources dynamically with, for example, a JavaScript module loader, renaming files is not an option. That’s why other strategies are also supported and can be combined. A "fixed" strategy will add a static version string in the URL, without changing the file name:

spring.resources.chain.strategy.content.enabled=true

spring.resources.chain.strategy.content.paths=/**

spring.resources.chain.strategy.fixed.enabled=true

spring.resources.chain.strategy.fixed.paths=/js/lib/

spring.resources.chain.strategy.fixed.version=v12

With this configuration, JavaScript modules located under "/js/lib/" will use a fixed versioning strategy "/v12/js/lib/mymodule.js" while other resources will still use the content one <link href="/css/spring-2a2d595e6ed9a0b24f027f2b63b134d6.css"/>.

有关ResourceProperties 更多支持的选项，请参阅。

	此功能已在专门的博客文章 和Spring Framework的参考文档中进行了详细描述 。

Spring Boot favicon.ico在配置的静态内容位置和类路径的根（按此顺序）中查找a 。如果存在此类文件，则会自动将其用作应用程序的favicon。

Spring MVC使用a WebBindingInitializer来初始化WebDataBinder特定请求。如果您自己创建ConfigurableWebBindingInitializer @Bean，Spring Boot将自动配置Spring MVC以使用它。

除REST Web服务外，您还可以使用Spring MVC来提供动态HTML内容。Spring MVC支持各种模板技术，包括Thymeleaf，FreeMarker和JSP。许多其他模板引擎也提供自己的Spring MVC集成。

Spring Boot包括对以下模板引擎的自动配置支持：

	如果可能，应该避免使用JSP，将它们与嵌入式servlet容器一起使用时有几个 已知的限制。

当您使用默认配置的其中一个模板引擎时，您的模板将自动从中获取src/main/resources/templates。

	IntelliJ IDEA根据您运行应用程序的方式对类路径进行不同的排序。通过主方法在IDE中运行应用程序将导致与使用Maven或Gradle或其打包的jar运行应用程序时的顺序不同。这可能导致Spring Boot无法在类路径中找到模板。如果您受此问题的影响，可以在IDE中重新排序类路径，以便首先放置模块的类和资源。或者，您可以配置模板前缀以搜索类路径上的每个模板目录：classpath*:/templates/。

Spring Boot /error默认提供映射，以合理的方式处理所有错误，并在servlet容器中注册为“全局”错误页面。对于机器客户端，它将生成一个JSON响应，其中包含错误，HTTP状态和异常消息的详细信息。对于浏览器客户端，有一个“whitelabel”错误视图，它以HTML格式呈现相同的数据（要自定义它，只需添加一个View解析为'错误'的数据）。要完全替换默认行为，您可以实现 ErrorController并注册该类型的bean定义，或者只是添加类型的bean ErrorAttributes以使用现有机制但替换内容。

	在BasicErrorController可以用作自定义基类ErrorController。如果要为新内容类型添加处理程序（默认情况下是text/html专门处理并为其他所有内容提供后备），这将特别有用。为此，只需扩展BasicErrorController并添加@RequestMapping具有produces属性的公共方法 ，并创建新类型的bean。

您还可以定义一个@ControllerAdvice自定义JSON文档以返回特定控制器和/或异常类型。

@ControllerAdvice（basePackageClasses = FooController.class）

公共 类 FooControllerAdvice扩展 ResponseEntityExceptionHandler {

    @ExceptionHandler（YourException.class）
@ResponseBody

    ResponseEntity <？> handleControllerException（HttpServletRequest request，Throwable ex）{

        HttpStatus status = getStatus（request）;

        返回 新的 ResponseEntity <>（new CustomErrorType（status.value（），ex.getMessage（）），status）;

    }

    private HttpStatus getStatus（HttpServletRequest request）{

        整数statusCode =（整数）request.getAttribute（“javax.servlet.error.status_code”）;

        if（statusCode == null）{

             return HttpStatus.INTERNAL_SERVER_ERROR;

        }

        return HttpStatus.valueOf（statusCode）;

    }

}

在上面的示例中，如果YourException由在同一个包中定义的控制器抛出，则将使用POJO FooController的json表示CustomerErrorType而不是ErrorAttributes表示。

SRC /

 +  - 主要/

     +  -  java /

     | + <源代码>

     +  - 资源/

         +  - 公共/

             +  - 错误/

             | +  -  404.html

             +  -  <其他公共资产>

SRC /

 +  - 主要/

     +  -  java /

     | + <源代码>

     +  - 资源/

         +  - 模板/

             +  - 错误/

             | +  -  5xx.ftl

             +  -  <其他模板>

公共 类 MyErrorViewResolver 实现 ErrorViewResolver {

    @覆盖

    公共的ModelAndView resolveErrorView（HttpServletRequest的请求，

            HttpStatus状态，Map <String，Object> model）{

        //使用请求或状态可选择返回ModelAndView

        返回 ...

    }

}

@Bean

 public ErrorPageRegistrar errorPageRegistrar（）{

     return  new MyErrorPageRegistrar（）;

}

// ...

私有 静态 类 MyErrorPageRegistrar 实现 ErrorPageRegistrar {

    @Override

     public  void registerErrorPages（ErrorPageRegistry registry）{

        registry.addErrorPages（new ErrorPage（HttpStatus.BAD_REQUEST，“/ 400”））;

    }

}

@Bean

 public FilterRegistrationBean myFilter（）{

    FilterRegistrationBean registration = new FilterRegistrationBean（）;

    registration.setFilter（new MyFilter（））;

    ...

    registration.setDispatcherTypes(EnumSet.allOf(DispatcherType.class));

    return registration;

}

如果您正在开发一个使用超媒体的RESTful API，Spring Boot为Spring HATEOAS提供了自动配置，适用于大多数应用程序。自动配置取代了使用@EnableHypermediaSupport和注册多个bean 的需要，以便于构建基于超媒体的应用程序，包括 LinkDiscoverers（用于客户端支持）和ObjectMapper配置为正确地将响应编组到所需表示中。在ObjectMapper将根据定制spring.jackson.*的属性或者Jackson2ObjectMapperBuilder如果存在豆。

您可以使用控制Spring HATEOAS的配置 @EnableHypermediaSupport。请注意，这将禁用上述ObjectMapper自定义。

跨源资源共享 （CORS）是大多数浏览器实现 的W3C规范，允许您以灵活的方式指定授权何种类型的跨域请求，而不是使用一些安全性较低且功能较弱的方法，如IFRAME或JSONP。

从版本4.2开始，Spring MVC 支持开箱即用的CORS。 在Spring Boot应用程序中使用带有 注释的控制器方法CORS配置@CrossOrigin不需要任何特定配置。 可以通过使用自定义 方法注册bean 来定义全局CORS配置：WebMvcConfigureraddCorsMappings(CorsRegistry)

@Configuration

公共 类 MyConfiguration {

    @Bean

     public WebMvcConfigurer corsConfigurer（）{

         return  new WebMvcConfigurer（）{
 @

             Override public  void addCorsMappings（CorsRegistry registry）{

                registry.addMapping（“/ api / **”）;

            }

        };

    }

}

Spring Boot provides auto-configuration for Spring WebFlux that works well with most applications.

The auto-configuration adds the following features on top of Spring’s defaults:

If you want to keep Spring Boot WebFlux features, and you just want to add additional WebFlux configuration you can add your own @Configuration class of type WebFluxConfigurer, but without @EnableWebFlux.

If you want to take complete control of Spring WebFlux, you can add your own @Configuration annotated with @EnableWebFlux.

Spring WebFlux uses the HttpMessageReader and HttpMessageWriter interface to convert HTTP requests and responses. They are configured with CodecConfigurer with sensible defaults, by looking at the libraries available in your classpath.

Spring Boot will apply further customization using CodecCustomizer instances. For example, spring.jackson.* configuration keys will be applied to the Jackson codec.

如果需要添加或自定义编解码器，可以创建自定义CodecCustomizer 组件：

import org.springframework.boot.web.codec.CodecCustomizer;

@Configuration

公共 类 MyConfiguration {

    @Bean

     public CodecCustomizer myCodecCustomizer（）{

         return codecConfigurer  - > {

             // ...

        }

    }

}

您还可以利用Boot的自定义JSON序列化程序和反序列化程序。

默认情况下，Spring Boot将从类路径中名为/static（ /public或/resources或/META-INF/resources）的目录中提供静态内容。它使用ResourceWebHandlerSpring WebFlux，因此您可以通过添加自己WebFluxConfigurer的addResourceHandlers方法来修改该行为并覆盖该 方法。

默认情况下，会映射资源，/**但您可以通过调整该 资源spring.mvc.static-path-pattern。例如，重新定位所有资源/resources/** 可以实现如下：

spring.mvc.static-path-pattern = / resources / **

您还可以使用spring.resources.static-locations（使用目录位置列表替换默认值）自定义静态资源位置 。如果您这样做，默认的欢迎页面检测将切换到您的自定义位置，因此如果index.html您在启动时的任何位置，它将是应用程序的主页。

除了上面的“标准”静态资源位置之外，还为Webjars内容制作了一个特例。具有路径的所有资源/webjars/** 如果以Webjars格式打包，将从jar文件中提供。

	Spring WebFlux应用程序并不严格依赖于Servlet API，因此不能将它们部署为war并且不使用该src/main/webapp目录。

除REST Web服务外，您还可以使用Spring WebFlux来提供动态HTML内容。Spring WebFlux支持各种模板技术，包括Thymeleaf，FreeMarker和Mustache。

Spring Boot包括对以下模板引擎的自动配置支持：

当您使用默认配置的其中一个模板引擎时，您的模板将自动从中获取src/main/resources/templates。

When using an embedded servlet container you can register Servlets, Filters and all the listeners from the Servlet spec (e.g. HttpSessionListener) either by using Spring beans or by scanning for Servlet components.

Embedded servlet containers will not directly execute the Servlet 3.0+ javax.servlet.ServletContainerInitializer interface, or Spring’sorg.springframework.web.WebApplicationInitializer interface. This is an intentional design decision intended to reduce the risk that 3rd party libraries designed to run inside a war will break Spring Boot applications.

If you need to perform servlet context initialization in a Spring Boot application, you should register a bean that implements theorg.springframework.boot.web.servlet.ServletContextInitializer interface. The single onStartup method provides access to the ServletContext, and can easily be used as an adapter to an existing WebApplicationInitializer if necessary.

Scanning for Servlets, Filters, and listeners

When using an embedded container, automatic registration of @WebServlet, @WebFilter, and @WebListener annotated classes can be enabled using @ServletComponentScan.

	@ServletComponentScan will have no effect in a standalone container, where the container’s built-in discovery mechanisms will be used instead.

Under the hood Spring Boot uses a new type of ApplicationContext for embedded servlet container support. The ServletWebServerApplicationContext is a special type of WebApplicationContext that bootstraps itself by searching for a single ServletWebServerFactory bean. Usually a TomcatServletWebServerFactory, JettyServletWebServerFactory, or UndertowServletWebServerFactory will have been auto-configured.

	You usually won’t need to be aware of these implementation classes. Most applications will be auto-configured and the appropriate ApplicationContextand ServletWebServerFactory will be created on your behalf.

Common servlet container settings can be configured using Spring Environment properties. Usually you would define the properties in your application.properties file.

Common server settings include:

Spring Boot tries as much as possible to expose common settings but this is not always possible. For those cases, dedicated namespaces offer server-specific customizations (see server.tomcat and server.undertow). For instance, access logs can be configured with specific features of the embedded servlet container.

	See the ServerProperties class for a complete list.

import org.springframework.boot.web.server.WebServerFactoryCustomizer;

import org.springframework.boot.web.servlet.server.ConfigurableServletWebServerFactory;

import org.springframework.stereotype.Component;

@Component

公共 类 CustomizationBean实现 WebServerFactoryCustomizer <ConfigurableServletWebServerFactory> {

    @Override

     public  void customize（ConfigurableServletWebServerFactory server）{

        server.setPort（9000）;

    }

}

@Bean

 public ConfigurableServletWebServerFactory webServerFactory（）{

    TomcatServletWebServerFactory factory = new TomcatServletWebServerFactory（）;

    factory.setPort（9000）;

    factory.setSessionTimeout（10，TimeUnit.MINUTES）;

    factory.addErrorPages（new ErrorPage（HttpStatus.NOT_FOUND，“/ notfound.html”））;

    返回工厂;

}

运行使用嵌入式servlet容器的Spring Boot应用程序（并打包为可执行存档）时，JSP支持存在一些限制。

有一个JSP示例，您可以看到如何设置。

要创建授权服务器并授予访问令牌，您需要使用 @EnableAuthorizationServer和提供security.oauth2.client.client-id和security.oauth2.client.client-secret]属性。客户端将在内存存储库中为您注册。

完成后，您将能够使用客户端凭据创建访问令牌，例如：

$ curl client：secret @ localhost ：8080 / oauth / token -d grant_type = password -d username = user -d password = pwd

/token端点的基本身份验证凭据是client-id和 client-secret。用户凭据是正常的Spring Security用户详细信息（在Spring Boot中默认为“user”和随机密码）。

要关闭自动配置并自行配置授权服务器功能，只需添加一种@Bean类型AuthorizationServerConfigurer。

To use the access token you need a Resource Server (which can be the same as the Authorization Server). Creating a Resource Server is easy, just add@EnableResourceServer and provide some configuration to allow the server to decode access tokens. If your application is also an Authorization Server it already knows how to decode tokens, so there is nothing else to do. If your app is a standalone service then you need to give it some more configuration, one of the following options:

If you specify both the user-info-uri and the token-info-uri then you can set a flag to say that one is preferred over the other (prefer-token-info=true is the default).

Alternatively (instead of user-info-uri or token-info-uri) if the tokens are JWTs you can configure a security.oauth2.resource.jwt.key-value to decode them locally (where the key is a verification key). The verification key value is either a symmetric secret or PEM-encoded RSA public key. If you don’t have the key and it’s public you can provide a URI where it can be downloaded (as a JSON object with a “value” field) with security.oauth2.resource.jwt.key-uri. E.g. on PWS:

$ curl https://uaa.run.pivotal.io/token_key

{"alg":"SHA256withRSA","value":"-----BEGIN PUBLIC KEY-----\nMIIBI...\n-----END PUBLIC KEY-----\n"}

	If you use the security.oauth2.resource.jwt.key-uri the authorization server needs to be running when your application starts up. It will log a warning if it can’t find the key, and tell you what to do to fix it.

OAuth2 resources are protected by a filter chain with order security.oauth2.resource.filter-order and the default is after the filter protecting the actuator endpoints by default (so actuator endpoints will stay on HTTP Basic unless you change the order).

To make your web-app into an OAuth2 client you can simply add @EnableOAuth2Client and Spring Boot will create a OAuth2ClientContext and OAuth2ProtectedResourceDetails that are necessary to create an OAuth2RestOperations. Spring Boot does not automatically create such bean but you can easily create your own:

@Bean

public OAuth2RestTemplate oauth2RestTemplate(OAuth2ClientContext oauth2ClientContext,

        OAuth2ProtectedResourceDetails details) {

    return new OAuth2RestTemplate(details, oauth2ClientContext);

}

	You may want to add a qualifier and review your configuration as more than one RestTemplate may be defined in your application.

This configuration uses security.oauth2.client.* as credentials (the same as you might be using in the Authorization Server), but in addition it will need to know the authorization and token URIs in the Authorization Server. For example:

application.yml. 

security:

    oauth2:

        client:

            clientId: bd1c0a783ccdd1c9b9e4

            clientSecret: 1a9030fbca47a5b2c28e92f19050bb77824b5ad1

            accessTokenUri: https://github.com/login/oauth/access_token

            userAuthorizationUri: https://github.com/login/oauth/authorize

            clientAuthenticationScheme: form

An application with this configuration will redirect to Github for authorization when you attempt to use the OAuth2RestTemplate. If you are already signed into Github you won’t even notice that it has authenticated. These specific credentials will only work if your application is running on port 8080 (register your own client app in Github or other provider for more flexibility).

To limit the scope that the client asks for when it obtains an access token you can set security.oauth2.client.scope (comma separated or an array in YAML). By default the scope is empty and it is up to Authorization Server to decide what the defaults should be, usually depending on the settings in the client registration that it holds.

	There is also a setting for security.oauth2.client.client-authentication-scheme which defaults to “header” (but you might need to set it to “form” if, like Github for instance, your OAuth2 provider doesn’t like header authentication). In fact, the security.oauth2.client.* properties are bound to an instance of AuthorizationCodeResourceDetails so all its properties can be specified.

In a non-web application you can still create an OAuth2RestOperations and it is still wired into the security.oauth2.client.* configuration. In this case it is a “client credentials token grant” you will be asking for if you use it (and there is no need to use @EnableOAuth2Client or @EnableOAuth2Sso). To prevent that infrastructure to be defined, just remove the security.oauth2.client.client-id from your configuration (or make it the empty string).

An OAuth2 Client can be used to fetch user details from the provider (if such features are available) and then convert them into an Authentication token for Spring Security. The Resource Server above support this via the user-info-uri property This is the basis for a Single Sign On (SSO) protocol based on OAuth2, and Spring Boot makes it easy to participate by providing an annotation @EnableOAuth2Sso. The Github client above can protect all its resources and authenticate using the Github /user/ endpoint, by adding that annotation and declaring where to find the endpoint (in addition to the security.oauth2.client.* configuration already listed above):

application.yml. 

security:

    oauth2:

...

    resource:

        userInfoUri: https://api.github.com/user

        preferTokenInfo: false

Since all paths are secure by default, there is no “home” page that you can show to unauthenticated users and invite them to login (by visiting the /login path, or the path specified by security.oauth2.sso.login-path).

To customize the access rules or paths to protect, so you can add a “home” page for instance, @EnableOAuth2Sso can be added to a WebSecurityConfigurerAdapter and the annotation will cause it to be decorated and enhanced with the necessary pieces to get the /login path working. For example, here we simply allow unauthenticated access to the home page at "/" and keep the default for everything else:

@Configuration

static class WebSecurityConfiguration extends WebSecurityConfigurerAdapter {

    @Override

    public void init(WebSecurity web) {

        web.ignoring().antMatchers("/");

    }

    @Override

    protected void configure(HttpSecurity http) throws Exception {

        http.antMatcher("/**").authorizeRequests().anyRequest().authenticated();

    }

}

• The management endpoints are secure even if the application endpoints are insecure.
• Security events are transformed into AuditEvent instances and published to the AuditEventRepository.
• The default user will have the ACTUATOR role as well as the USER role.

It’s often convenient to develop applications using an in-memory embedded database. Obviously, in-memory databases do not provide persistent storage; you will need to populate your database when your application starts and be prepared to throw away data when your application ends.

	The ‘How-to’ section includes a section on how to initialize a database

Spring Boot can auto-configure embedded H2, HSQL and Derby databases. You don’t need to provide any connection URLs, simply include a build dependency to the embedded database that you want to use.

	If you are using this feature in your tests, you may notice that the same database is reused by your whole test suite regardless of the number of application contexts that you use. If you want to make sure that each context has a separate embedded database, you should set spring.datasource.generate-unique-name to true.

For example, typical POM dependencies would be:

<dependency>

    <groupId>org.springframework.boot</groupId>

    <artifactId>spring-boot-starter-data-jpa</artifactId>

</dependency>

<dependency>

    <groupId>org.hsqldb</groupId>

    <artifactId>hsqldb</artifactId>

    <scope>runtime</scope>

</dependency>

	You need a dependency on spring-jdbc for an embedded database to be auto-configured. In this example it’s pulled in transitively viaspring-boot-starter-data-jpa.

If, for whatever reason, you do configure the connection URL for an embedded database, care should be taken to ensure that the database’s automatic shutdown is disabled. If you’re using H2 you should use DB_CLOSE_ON_EXIT=FALSE to do so. If you’re using HSQLDB, you should ensure that shutdown=true is not used. Disabling the database’s automatic shutdown allows Spring Boot to control when the database is closed, thereby ensuring that it happens once access to the database is no longer needed.

Production database connections can also be auto-configured using a pooling DataSource. Here’s the algorithm for choosing a specific implementation:

If you use the spring-boot-starter-jdbc or spring-boot-starter-data-jpa ‘starters’ you will automatically get a dependency to HikariCP.

	You can bypass that algorithm completely and specify the connection pool to use via the spring.datasource.type property. This is especially important if you are running your application in a Tomcat container as tomcat-jdbc is provided by default.

	Additional connection pools can always be configured manually. If you define your own DataSource bean, auto-configuration will not occur.

DataSource configuration is controlled by external configuration properties in spring.datasource.*. For example, you might declare the following section inapplication.properties:

spring.datasource.url=jdbc:mysql://localhost/test

spring.datasource.username=dbuser

spring.datasource.password=dbpass

spring.datasource.driver-class-name=com.mysql.jdbc.Driver

	You should at least specify the url using the spring.datasource.url property or Spring Boot will attempt to auto-configure an embedded database.

	You often won’t need to specify the driver-class-name since Spring boot can deduce it for most databases from the url.

	For a pooling DataSource to be created we need to be able to verify that a valid Driver class is available, so we check for that before doing anything. I.e. if you set spring.datasource.driver-class-name=com.mysql.jdbc.Driver then that class has to be loadable.

See DataSourceProperties for more of the supported options. These are the standard options that work regardless of the actual implementation. It is also possible to fine-tune implementation-specific settings using their respective prefix (spring.datasource.hikari.*, spring.datasource.tomcat.*, and spring.datasource.dbcp2.*). Refer to the documentation of the connection pool implementation you are using for more details.

For instance, if you are using the Tomcat connection pool you could customize many additional settings:

＃如果没有可用连接，则在抛出异常之前要等待的ms数。

spring.datasource.tomcat.max-wait = 10000

＃可以同时从该池分配的最大活动连接数。

spring.datasource.tomcat.max-active = 50

＃在从池中借用连接之前验证连接。

spring.datasource.tomcat.test-on-borrow = true

如果要将Spring Boot应用程序部署到Application Server，则可能需要使用Application Server内置功能配置和管理DataSource，并使用JNDI访问它。

该spring.datasource.jndi-name属性可以被用作一个替代 spring.datasource.url，spring.datasource.username和spring.datasource.password 属性来访问DataSource从一个特定的JNDI位置。例如，以下部分application.properties显示了如何访问定义的JBoss AS DataSource：

spring.datasource.jndi-name = java：jboss / datasources / customers

• Hibernate - 最受欢迎的JPA实现之一。
• Spring Data JPA - 使实现基于JPA的存储库变得容易。
• Spring ORMs - 来自Spring Framework的核心ORM支持。

传统上，JPA“实体”类在persistence.xml文件中指定。使用Spring Boot，此文件不是必需的，而是使用“实体扫描”。默认情况下，将搜索主配置类下面的所有包（用@EnableAutoConfigurationor 注释 @SpringBootApplication）。

任何类注释用@Entity，@Embeddable或@MappedSuperclass将予以考虑。典型的实体类看起来像这样：

package com.example.myapp.domain;

import java.io.Serializable;

import javax.persistence。*;

@Entity

公共 类 City实现 Serializable {

    @Id 
@GeneratedValue

     private Long id;

    @Column（nullable = false）

    私有 String名称;

    @Column（nullable = false）

    私有 String状态;

    // ...其他成员，通常包括@OneToMany映射

    protected City（）{

         // JPA规范要求的no-args构造函数

        //这个是受保护的，因为它不应该直接使用

    }

    public City（String name，String state）{

         this .name = name;

        这个 .country = country;

    }

    public String getName（）{

         return  this .name;

    }

    public String getState（）{

         return  this .state;

    }

    //等等

}

	您可以使用@EntityScan注释自定义实体扫描位置。请参见第78.4节“从Spring配置中分离@Entity定义”操作方法。

Spring Data JPA存储库是您可以定义以访问数据的接口。JPA查询是从您的方法名称自动创建的。例如，CityRepository 接口可能会声明一种findAllByState(String state)方法来查找给定状态中的所有城市。

对于更复杂的查询，您可以使用Spring Data的Query注释来注释您的方法 。

Spring Data存储库通常从Repository或 CrudRepository接口扩展 。如果您使用的是自动配置，则将从包含主配置类（带有@EnableAutoConfiguration或标注的类）的软件包中搜索存储库 @SpringBootApplication。

这是一个典型的Spring Data存储库：

package com.example.myapp.domain;

import org.springframework.data.domain。*;

import org.springframework.data.repository。*;

公共 接口 CityRepository 扩展了 Repository <City，Long> {

    Page <City> findAll（可分页可分页）;

    City findByNameAndCountryAllIgnoringCase（String name，String country）;

}

	我们几乎没有涉及Spring Data JPA的表面。有关详细信息，请查看其参考文档。

默认情况下，仅当您使用嵌入式数据库（H2，HSQL或Derby）时，才会自动创建JPA数据库。您可以使用spring.jpa.*属性显式配置JPA设置 。例如，要创建和删除表，您可以将以下内容添加到您的表中application.properties。

spring.jpa.hibernate.ddl-AUTO =创造降

	Hibernate自己的内部属性名称（如果你碰巧记得更好）是hibernate.hbm2ddl.auto。您可以使用spring.jpa.properties.*（在将它们添加到实体管理器之前剥离前缀）来设置它以及其他Hibernate本机属性。例：

spring.jpa.properties.hibernate.globally_quoted_identifiers =真

传递hibernate.globally_quoted_identifiers给Hibernate实体管理器。

默认情况下，DDL执行（或验证）将延迟到ApplicationContext 启动。还有一个spring.jpa.generate-ddl标志，但如果Hibernate autoconfig处于活动状态，则不会使用该标志，因为ddl-auto设置更精细。

如果您正在运行Web应用程序，Spring Boot将默认注册 OpenEntityManagerInViewInterceptor 以应用“在视图中打开EntityManager”模式，即允许在Web视图中进行延迟加载。如果你不希望这种行为，你应该设置spring.jpa.open-in-view到 false你application.properties。

• 您正在开发Web应用程序
• com.h2database:h2 在类路径上
• 您正在使用Spring Boot的开发人员工具

默认情况下，控制台将在/h2-console。您可以使用spring.h2.console.path属性自定义控制台的路径。

当Spring Security在类路径上并且启用了基本身份验证时，H2控制台将使用基本身份验证自动保护。以下属性可用于自定义安全性配置：

In order to use jOOQ type-safe queries, you need to generate Java classes from your database schema. You can follow the instructions in the jOOQ user manual. If you are using the jooq-codegen-maven plugin (and you also use the spring-boot-starter-parent “parent POM”) you can safely omit the plugin’s <version> tag. You can also use Spring Boot defined version variables (e.g. h2.version) to declare the plugin’s database dependency. Here’s an example:

<plugin>

    <groupId>org.jooq</groupId>

    <artifactId>jooq-codegen-maven</artifactId>

    <executions>

        ...

    </executions>

    <dependencies>

        <dependency>

            <groupId>com.h2database</groupId>

            <artifactId>h2</artifactId>

            <version>${h2.version}</version>

        </dependency>

    </dependencies>

    <configuration>

        <jdbc>

            <driver>org.h2.Driver</driver>

            <url>jdbc:h2:~/yourdatabase</url>

        </jdbc>

        <generator>

            ...

        </generator>

    </configuration>

</plugin>

The fluent API offered by jOOQ is initiated via the org.jooq.DSLContext interface. Spring Boot will auto-configure a DSLContext as a Spring Bean and connect it to your application DataSource. To use the DSLContext you can just @Autowire it:

@Component

public class JooqExample implements CommandLineRunner {

    private final DSLContext create;

    @Autowired

    public JooqExample(DSLContext dslContext) {

        this.create = dslContext;

    }

}

	The jOOQ manual tends to use a variable named create to hold the DSLContext, we’ve done the same for this example.

You can then use the DSLContext to construct your queries:

public List<GregorianCalendar> authorsBornAfter1980() {

    return this.create.selectFrom(AUTHOR)

        .where(AUTHOR.DATE_OF_BIRTH.greaterThan(new GregorianCalendar(1980, 0, 1)))

        .fetch(AUTHOR.DATE_OF_BIRTH);

}

Spring Boot determines the SQL dialect to use for your datasource unless the spring.jooq.sql-dialect property has been configured. If the dialect couldn’t be detected, DEFAULT is used.

	Spring Boot can only auto-configure dialects supported by the open source version of jOOQ.

More advanced customizations can be achieved by defining your own @Bean definitions which will be used when the jOOQ Configuration is created. You can define beans for the following jOOQ Types:

You can also create your own org.jooq.Configuration @Bean if you want to take complete control of the jOOQ configuration.

You can inject an auto-configured RedisConnectionFactory, StringRedisTemplate or vanilla RedisTemplate instance as you would any other Spring Bean. By default the instance will attempt to connect to a Redis server using localhost:6379:

@Component

public class MyBean {

    私有 StringRedisTemplate模板;

    @Autowired

     public MyBean（StringRedisTemplate template）{

         this .template = template;

    }

    // ...

}

	您还可以注册任意数量的bean，以实现 JedisClientConfigurationBuilderCustomizer更高级的自定义。如果您正在使用生菜，LettuceClientConfigurationBuilderCustomizer也可以。

如果您添加@Bean自己的任何自动配置类型，它将替换默认值（除非RedisTemplate排除是基于bean名称'redisTemplate'而不是其类型）。如果commons-pool2在类路径上，默认情况下您将获得池连接工厂。

您可以注入自动配置org.springframework.data.mongodb.MongoDbFactory以访问Mongo数据库。默认情况下，实例将尝试使用URL连接到MongoDB服务器mongodb://localhost/test：

import org.springframework.data.mongodb.MongoDbFactory;

import com.mongodb.DB;

@Component

公共 类 MyBean {

    私人 决赛 MongoDbFactory mongo;

    @Autowired

     public MyBean（MongoDbFactory mongo）{

         this .mongo = mongo;

    }

    // ...

    public  void example（）{

        DB db = mongo.getDb（）;

        // ...

    }

}

您可以设置spring.data.mongodb.uri属性以更改URL并配置其他设置，例如副本集：

spring.data.mongodb.uri = mongodb：// user：secret@mongo1.example.com ：12345，mongo2.example.com：23456 / test

或者，只要您使用Mongo 2.x，请指定host/ port。例如，您可以在以下内容中声明以下内容application.properties：

spring.data.mongodb.host = mongoserver

 spring.data.mongodb.port = 27017

	spring.data.mongodb.hostspring.data.mongodb.port如果您使用的是Mongo 3.0 Java驱动程序，则不受支持。在这种情况下，spring.data.mongodb.uri应该用于提供所有配置。

	如果spring.data.mongodb.port未指定，27017则使用默认值。您可以从上面的示例中删除此行。

	如果您不使用Spring Data Mongo，则可以注入com.mongodb.Mongobean而不是使用MongoDbFactory。

如果要完全控制建立MongoDB连接，也可以声明自己的bean MongoDbFactory或Mongobean。

Spring Data Mongo提供了一个MongoTemplate与Spring的设计非常相似的 类JdbcTemplate。与JdbcTemplateSpring Boot一样，自动配置一个bean，只需注入：

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.data.mongodb.core.MongoTemplate;

import org.springframework.stereotype.Component;

@Component

公共 类 MyBean {

    私人 决赛 MongoTemplate mongoTemplate;

    @Autowired

     public MyBean（MongoTemplate mongoTemplate）{

         this .mongoTemplate = mongoTemplate;

    }

    // ...

}

有关MongoOperations完整的详细信息，请参阅Javadoc。

Spring Data包括MongoDB的存储库支持。与前面讨论的JPA存储库一样，基本原则是根据方法名称自动为您构建查询。

事实上，Spring Data JPA和Spring Data MongoDB共享相同的通用基础架构; 所以你可以从前面拿到JPA示例，假设它City 现在是一个Mongo数据类而不是JPA @Entity，它将以相同的方式工作。

package com.example.myapp.domain;

import org.springframework.data.domain。*;

import org.springframework.data.repository。*;

公共 接口 CityRepository 扩展了 Repository <City，Long> {

    Page <City> findAll（可分页可分页）;

    City findByNameAndCountryAllIgnoringCase（String name，String country）;

}

	有关Spring Data MongoDB的完整详细信息，包括其丰富的对象映射技术，请参阅其参考文档。

Spring Boot为Embedded Mongo提供自动配置 。要在Spring Boot应用程序中使用它，请添加依赖项 de.flapdoodle.embed:de.flapdoodle.embed.mongo。

可以使用该spring.data.mongodb.port 属性配置Mongo将侦听的端口。要使用随机分配的空闲端口，请使用零值。在MongoClient 由创建MongoAutoConfiguration将被自动配置为使用随机分配的端口。

	如果您不配置自定义端口，则默认情况下嵌入式支持将使用随机端口（而不是27017）。

如果类路径上有SLF4J，Mongo生成的输出将自动路由到名为的记录器org.springframework.boot.autoconfigure.mongo.embedded.EmbeddedMongo。

您可以声明自己的bean IMongodConfig和IRuntimeConfigbean来控制Mongo实例的配置和日志记录路由。

你可以注入的自动配置Neo4jSession，Session或者Neo4jOperations，就像任何其他的Spring Bean实例。默认情况下，实例将尝试使用以下命令连接到Neo4j服务器localhost:7474：

@Component

公共 类 MyBean {

    private final Neo4jTemplate neo4jTemplate;

    @Autowired

    public MyBean(Neo4jTemplate neo4jTemplate) {

        this.neo4jTemplate = neo4jTemplate;

    }

    // ...

}

You can take full control of the configuration by adding a org.neo4j.ogm.config.Configuration @Bean of your own. Also, adding a @Bean of typeNeo4jOperations disables the auto-configuration.

You can configure the user and credentials to use via the spring.data.neo4j.* properties:

spring.data.neo4j.uri=http://my-server:7474

spring.data.neo4j.username=neo4j

spring.data.neo4j.password=secret

如果添加org.neo4j:neo4j-ogm-embedded-driver到应用程序的依赖项，Spring Boot将自动配置Neo4j的进程内嵌入式实例，在应用程序关闭时不会保留任何数据。您可以使用显式禁用该模式spring.data.neo4j.embedded.enabled=false。您还可以为嵌入模式启用持久性：

	spring.data.neo4j.uri =文件：//var/tmp/graph.db

	Neo4j OGM嵌入式驱动程序不提供Neo4j内核。用户需要手动提供此依赖关系， 有关详细信息，请参阅 文档。

默认情况下，如果您正在运行Web应用程序，则会话将绑定到线程以进行整个请求处理（即“在视图中打开会话”模式）。如果您不想要此行为，请将以下内容添加到您的application.properties：

	spring.data.neo4j.open式视=假

Spring Data包含对Neo4j的存储库支持。

事实上，Spring Data JPA和Spring Data Neo4j共享相同的通用基础架构; 所以你可以从前面拿到JPA例子，假设City 现在是Neo4j OGM @NodeEntity而不是JPA @Entity，它将以相同的方式工作。

	您可以使用@EntityScan注释自定义实体扫描位置。

要启用存储库支持（以及可选的支持@Transactional），请在Spring配置中添加以下两个注释：

@ EnableNeo4jRepositories（basePackages =“com.example.myapp.repository”）

@EnableTransactionManagement

package com.example.myapp.domain;

import org.springframework.data.domain。*;

import org.springframework.data.repository。*;

公共 接口 CityRepository 扩展了 GraphRepository <City> {

    Page <City> findAll（可分页可分页）;

    City findByNameAndCountry（String name，String country）;

}

	有关Spring Data Neo4j的完整详细信息，包括其丰富的对象映射技术，请参阅其参考文档。

You can inject an auto-configured SolrClient instance as you would any other Spring bean. By default the instance will attempt to connect to a server usinglocalhost:8983/solr:

@Component

public class MyBean {

    private SolrClient solr;

    @Autowired

    public MyBean(SolrClient solr) {

        this.solr = solr;

    }

    // ...

}

If you add a @Bean of your own of type SolrClient it will replace the default.

Spring Data includes repository support for Apache Solr. As with the JPA repositories discussed earlier, the basic principle is that queries are constructed for you automatically based on method names.

In fact, both Spring Data JPA and Spring Data Solr share the same common infrastructure; so you could take the JPA example from earlier and, assuming that City is now a @SolrDocument class rather than a JPA @Entity, it will work in the same way.

	For complete details of Spring Data Solr, refer to their reference documentation.