Spring Boot支持以下嵌入式servlet容器：

您还可以将Spring Boot应用程序部署到任何Servlet 3.1+兼容容器。

您可以像使用任何标准Java库一样使用Spring Boot。为此，请在类路径中包含相应的spring-boot-*.jar文件。Spring Boot不需要任何特殊工具集成，因此您可以使用任何IDE或文本编辑器。此外，Spring Boot应用程序没有什么特别之处，因此您可以像运行任何其他Java程序一样运行和调试Spring引导应用程序。

虽然您可以复制Spring Boot罐，但我们通常建议您使用支持依赖关系管理的构建工具（例如Maven或Gradle）。

10.1.1 Maven安装

Spring Boot与Apache Maven 3.3或更高版本兼容。如果您尚未安装Maven，则可以按照maven.apache.org上的说明进行操作。

	提示
	在许多操作系统上，Maven可以与软件包管理器一起安装。如果您使用OSX Homebrew，请尝试brew install maven。Ubuntu用户可以运行sudo apt-get install maven。使用Chocolatey的 Windows用户可以从提升（管理员）提示符运行choco install maven。

Spring Boot依赖项使用org.springframework.boot groupId。通常，您的Maven POM文件继承自spring-boot-starter-parent项目，并声明对一个或多个“Starters”的依赖关系。Spring Boot还提供了一个可选的 Maven插件来创建可执行jar。

以下清单显示了典型的pom.xml文件：

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

	<!-- Inherit defaults from Spring Boot -->
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.1.1.RELEASE</version>
	</parent>

	<!-- Add typical dependencies for a web application -->
	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
	</dependencies>

	<!-- Package as an executable jar -->
	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>

</project>

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

Spring Boot CLI（命令行界面）是一个命令行工具，可用于使用Spring快速原型。它允许您运行Groovy脚本，这意味着您拥有熟悉的类似Java的语法，而没有太多的样板代码。

您不需要使用CLI来使用Spring Boot，但它绝对是实现Spring应用程序的最快方法。

$ sdk install springboot
$ spring --version
Spring Boot v2.1.1.RELEASE

$ sdk install springboot dev /path/to/spring-boot/spring-boot-cli/target/spring-boot-cli-2.1.1.RELEASE-bin/spring-2.1.1.RELEASE/
$ sdk default springboot dev
$ spring --version
Spring CLI v2.1.1.RELEASE

$ sdk ls springboot

================================================================================
Available Springboot Versions
================================================================================
> + dev
* 2.1.1.RELEASE

================================================================================
+ - local version
* - installed
> - currently in use
================================================================================

10.2.3 OSX Homebrew安装

如果您使用的是Mac并使用Homebrew，则可以使用以下命令安装Spring Boot CLI：

$ brew tap pivotal/tap
$ brew install springboot

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

	注意
	如果您没有看到公式，那么您的brew安装可能已过时。在这种情况下，运行brew update并再试一次。

$ sudo port install spring-boot-cli

10.2.5命令行完成

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

$ . ~/.sdkman/candidates/springboot/current/shell-completion/bash/spring
$ spring <HIT TAB HERE>
  grab  help  jar  run  test  version

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

10.2.6 Windows Scoop安装

如果您使用的是Windows并使用Scoop，则可以使用以下命令安装Spring Boot CLI：

> scoop bucket add extras
> scoop install springboot

Scoop安装spring到~/scoop/apps/springboot/current/bin。

	注意
	如果您没有看到应用清单，则您的scoop安装可能已过时。在这种情况下，请运行scoop update并重试。

10.2.7快速启动Spring CLI示例

您可以使用以下Web应用程序来测试您的安装。首先，创建一个名为app.groovy的文件，如下所示：

@RestController
class ThisWillActuallyRun {

	@RequestMapping("/")
	String home() {
		"Hello World!"
	}

}

然后从shell运行它，如下所示：

$ spring run app.groovy

	注意
	随着依赖项的下载，应用程序的第一次运行速度很慢。后续运行要快得多。

在您喜欢的网络浏览器中打开localhost:8080。您应该看到以下输出：

Hello World!

如果要从早期版本的Spring Boot升级，请查看 项目Wiki上的“迁移指南”， 其中提供了详细的升级说明。另请查看 “发行说明”，了解每个版本的“新的和值得注意的”功能列表。

升级到新功能版本时，某些属性可能已重命名或删除。Spring Boot提供了一种在启动时分析应用程序环境和打印诊断的方法，还可以在运行时临时迁移属性。要启用该功能，请将以下依赖项添加到项目中：

<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-properties-migrator</artifactId>
	<scope>runtime</scope>
</dependency>

	警告
	添加到环境后期的属性（例如使用@PropertySource时）将不会被考虑在内。

	注意
	完成迁移后，请确保从项目的依赖项中删除此模块。

要升级现有CLI安装，请使用相应的软件包管理器命令（例如，brew upgrade），或者，如果手动安装CLI，请按照 标准说明操作，记住更新PATH环境变量以删除任何旧版本引用。

我们需要先创建一个Maven pom.xml文件。pom.xml是用于构建项目的配方。打开您喜欢的文本编辑器并添加以下内容：

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

	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.1.1.RELEASE</version>
	</parent>

	<!-- Additional lines to be added here... -->

</project>

上面的清单应该为您提供有效的构建。您可以通过运行mvn package来测试它（现在，您可以忽略“jar将为空 - 没有内容被标记为包含！”警告）。

	注意
	此时，您可以将项目导入IDE（大多数现代Java IDE包含对Maven的内置支持）。为简单起见，我们继续为此示例使用纯文本编辑器。

Spring Boot提供了一些“Starters”，可让您将jar添加到类路径中。我们的示例应用程序已经在POM的parent部分使用了spring-boot-starter-parent。spring-boot-starter-parent是一个特殊的启动器，提供有用的Maven默认值。它还提供了一个 dependency-management 部分，以便您可以省略version标签中的“祝福”依赖项。

其他“Starters”提供了在开发特定类型的应用程序时可能需要的依赖项。由于我们正在开发Web应用程序，因此我们添加了spring-boot-starter-web依赖项。在此之前，我们可以通过运行以下命令来查看当前的内容：

$ mvn dependency:tree

[INFO] com.example:myproject:jar:0.0.1-SNAPSHOT

mvn dependency:tree命令打印项目依赖项的树表示。您可以看到spring-boot-starter-parent本身不提供依赖关系。要添加必要的依赖项，请编辑pom.xml并在parent部分下方添加spring-boot-starter-web依赖项：

<dependencies>
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-web</artifactId>
	</dependency>
</dependencies>

如果再次运行mvn dependency:tree，您会发现现在有许多其他依赖项，包括Tomcat Web服务器和Spring Boot本身。

要完成我们的应用程序，我们需要创建一个Java文件。默认情况下，Maven编译来自src/main/java的源，因此您需要创建该文件夹结构，然后添加名为src/main/java/Example.java的文件以包含以下代码：

import org.springframework.boot.*;
import org.springframework.boot.autoconfigure.*;
import org.springframework.web.bind.annotation.*;

@RestController
@EnableAutoConfiguration
public class Example {

	@RequestMapping("/")
	String home() {
		return "Hello World!";
	}

	public static void main(String[] args) throws Exception {
		SpringApplication.run(Example.class, args);
	}

}

虽然这里的代码不多，但还是有很多代码。我们将在接下来的几节中逐步介绍重要部分。

11.3.1 @RestController和@RequestMapping Annotations

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

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

	提示
	@RestController和@RequestMapping注释是Spring MVC注释。（它们不是Spring Boot特有的。）有关详细信息，请参阅Spring参考文档中的MVC部分。

此时，您的应用程序应该工作。由于您使用了spring-boot-starter-parent POM，因此您可以使用有用的run目标来启动应用程序。从根项目目录中键入mvn spring-boot:run以启动应用程序。您应该看到类似于以下内容的输出：

$ mvn spring-boot:run

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::  (v2.1.1.RELEASE)
....... . . .
....... . . . (log output here)
....... . . .
........ Started Example in 2.222 seconds (JVM running for 6.514)

如果您打开Web浏览器到localhost:8080，您应该看到以下输出：

Hello World!

要正常退出应用程序，请按ctrl-c。

我们通过创建一个完全自包含的可执行jar文件来完成我们的示例，我们可以在生产中运行它。可执行jar（有时称为“fat jar”）是包含已编译类以及代码需要运行的所有jar依赖项的归档。

要创建可执行jar，我们需要将spring-boot-maven-plugin添加到pom.xml。为此，请在dependencies部分下方插入以下行：

<build>
	<plugins>
		<plugin>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-maven-plugin</artifactId>
		</plugin>
	</plugins>
</build>

	注意
	spring-boot-starter-parent POM包含<executions>配置以绑定repackage目标。如果您不使用父POM，则需要自己声明此配置。有关详细信息，请参阅插件文档。

保存pom.xml并从命令行运行mvn package，如下所示：

$ mvn package

[INFO] Scanning for projects...
[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] Building myproject 0.0.1-SNAPSHOT
[INFO] ------------------------------------------------------------------------
[INFO] .... ..
[INFO] --- maven-jar-plugin:2.4:jar (default-jar) @ myproject ---
[INFO] Building jar: /Users/developer/example/spring-boot-example/target/myproject-0.0.1-SNAPSHOT.jar
[INFO]
[INFO] --- spring-boot-maven-plugin:2.1.1.RELEASE:repackage (default) @ myproject ---
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------

如果你查看target目录，你应该看到myproject-0.0.1-SNAPSHOT.jar。该文件大小应为10 MB左右。如果要查看内部，可以使用jar tvf，如下所示：

$ jar tvf target/myproject-0.0.1-SNAPSHOT.jar

您还应该在target目录中看到一个名为myproject-0.0.1-SNAPSHOT.jar.original的小文件。这是Maven在Spring Boot重新打包之前创建的原始jar文件。

要运行该应用程序，请使用java -jar命令，如下所示：

$ java -jar target/myproject-0.0.1-SNAPSHOT.jar

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::  (v2.1.1.RELEASE)
....... . . .
....... . . . (log output here)
....... . . .
........ Started Example in 2.536 seconds (JVM running for 2.864)

和以前一样，要退出应用程序，请按ctrl-c。

Spring Boot的每个版本都提供了它支持的依赖项的策划列表。实际上，您不需要为构建配置中的任何这些依赖项提供版本，因为Spring Boot会为您管理。升级Spring引导时，这些依赖项也会以一致的方式升级。

	注意
	如果需要，您仍然可以指定版本并覆盖Spring Boot的建议。

精选列表包含您可以使用Spring Boot的所有spring modules以及精选的第三方库列表。该列表以标准 物料清单（spring-boot-dependencies）的形式提供 ，可与Maven和 Gradle一起使用。

	警告
	Spring Boot的每个版本都与Spring框架的基本版本相关联。我们强烈建议您不要指定其版本。

Maven用户可以继承spring-boot-starter-parent项目以获得合理的默认值。父项目提供以下功能：

请注意，由于application.properties和application.yml文件接受Spring样式占位符（${…​}），因此Maven过滤更改为使用@..@占位符。（您可以通过设置名为resource.delimiter的Maven属性来覆盖它。）

13.2.1继承Starter Parent

要将项目配置为从spring-boot-starter-parent继承，请按以下方式设置parent：

<!-- Inherit defaults from Spring Boot -->
<parent>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-parent</artifactId>
	<version>2.1.1.RELEASE</version>
</parent>

	注意
	您应该只需要在此依赖项上指定Spring Boot版本号。如果导入其他启动器，则可以安全地省略版本号。

通过该设置，您还可以通过覆盖自己项目中的属性来覆盖单个依赖项。例如，要升级到另一个Spring数据发布列表，您可以将以下内容添加到pom.xml：

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

	提示
	检查 spring-boot-dependencies pom 以获取支持的属性列表。

13.2.2在没有父POM的情况下使用Spring Boot

不是每个人都喜欢继承spring-boot-starter-parent POM。您可能拥有自己需要使用的公司标准父级，或者您可能希望明确声明所有Maven配置。

如果您不想使用spring-boot-starter-parent，您仍然可以通过使用scope=import依赖项来保持依赖项管理（但不是插件管理）的好处，如下所示：

<dependencyManagement>
		<dependencies>
		<dependency>
			<!-- Import dependency management from Spring Boot -->
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-dependencies</artifactId>
			<version>2.1.1.RELEASE</version>
			<type>pom</type>
			<scope>import</scope>
		</dependency>
	</dependencies>
</dependencyManagement>

如上所述，前面的示例设置不允许您使用属性覆盖单个依赖项。要获得相同的结果，您需要在spring-boot-dependencies条目之前在项目的dependencyManagement中添加条目。例如，要升级到另一个Spring数据发布列，您可以将以下元素添加到pom.xml：

<dependencyManagement>
	<dependencies>
		<!-- Override Spring Data release train provided by Spring Boot -->
		<dependency>
			<groupId>org.springframework.data</groupId>
			<artifactId>spring-data-releasetrain</artifactId>
			<version>Fowler-SR2</version>
			<type>pom</type>
			<scope>import</scope>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-dependencies</artifactId>
			<version>2.1.1.RELEASE</version>
			<type>pom</type>
			<scope>import</scope>
		</dependency>
	</dependencies>
</dependencyManagement>

	注意
	在前面的示例中，我们指定了BOM，但是可以以相同的方式覆盖任何依赖关系类型。

13.2.3使用Spring Boot Maven插件

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，则只需添加插件。除非您要更改父级中定义的设置，否则无需对其进行配置。

要了解如何将Spring Boot与Gradle一起使用，请参阅Spring Boot的Gradle插件的文档：

可以使用Apache Ant + Ivy构建一个Spring Boot项目。spring-boot-antlib“AntLib”模块也可用于帮助Ant创建可执行jar。

要声明依赖项，典型的ivy.xml文件类似于以下示例：

<ivy-module version="2.0">
	<info organisation="org.springframework.boot" module="spring-boot-sample-ant" />
	<configurations>
		<conf name="compile" description="everything needed to compile this module" />
		<conf name="runtime" extends="compile" description="everything needed to run this module" />
	</configurations>
	<dependencies>
		<dependency org="org.springframework.boot" name="spring-boot-starter"
			rev="${spring-boot.version}" conf="compile" />
	</dependencies>
</ivy-module>

典型的build.xml类似于以下示例：

<project
	xmlns:ivy="antlib:org.apache.ivy.ant"
	xmlns:spring-boot="antlib:org.springframework.boot.ant"
	name="myapp" default="build">

	<property name="spring-boot.version" value="2.1.1.RELEASE" />

	<target name="resolve" description="--> retrieve dependencies with ivy">
		<ivy:retrieve pattern="lib/[conf]/[artifact]-[type]-[revision].[ext]" />
	</target>

	<target name="classpaths" depends="resolve">
		<path id="compile.classpath">
			<fileset dir="lib/compile" includes="*.jar" />
		</path>
	</target>

	<target name="init" depends="classpaths">
		<mkdir dir="build/classes" />
	</target>

	<target name="compile" depends="init" description="compile">
		<javac srcdir="src/main/java" destdir="build/classes" classpathref="compile.classpath" />
	</target>

	<target name="build" depends="compile">
		<spring-boot:exejar destfile="build/myapp.jar" classes="build/classes">
			<spring-boot:lib>
				<fileset dir="lib/runtime" />
			</spring-boot:lib>
		</spring-boot:exejar>
	</target>
</project>

	提示
	如果您不想使用spring-boot-antlib模块，请参见 第91.9节“从Ant构建可执行文件，而不使用spring-boot-antlib” “操作方法”。

Starters是一组方便的依赖描述符，您可以在应用程序中包含这些描述符。您可以获得所需的所有Spring和相关技术的一站式服务，而无需搜索示例代码和复制粘贴依赖描述符的负载。例如，如果要开始使用Spring和JPA进行数据库访问，请在项目中包含spring-boot-starter-data-jpa依赖项。

启动器包含许多依赖项，这些依赖项是使项目快速启动和运行所需的依赖项，以及一组受支持的托管传递依赖项。

以下应用程序启动程序由org.springframework.boot组下的Spring Boot提供：

除应用程序启动器外，还可以使用以下启动器添加 生产就绪功能：

最后，Spring Boot还包括以下可用于排除或交换特定技术方面的启动器：

	提示
	有关其他社区贡献的启动器的列表，请参阅GitHub上spring-boot-starters模块中的 README文件。

当一个类不包含package声明时，它被认为是在“默认包”中。通常不鼓励使用“默认包”，应该避免使用。对于使用@ComponentScan，@EntityScan或@SpringBootApplication注释的Spring Boot应用程序，它可能会导致特定问题，因为每个jar中的每个类都被读取。

	提示
	我们建议您遵循Java推荐的包命名约定并使用反向域名（例如，com.example.project）。

我们通常建议您将主应用程序类放在其他类之上的根包中。的@SpringBootApplication注释往往放在主类，它隐式地定义某些项目碱“的搜索包”。例如，如果您正在编写JPA应用程序，则使用@SpringBootApplication带注释类的包来搜索@Entity项。使用根包还允许组件扫描仅应用于您的项目。

	提示
	如果您不想使用@SpringBootApplication，它导入的@EnableAutoConfiguration和@ComponentScan注释会定义该行为，因此您也可以使用它。

以下清单显示了典型的布局：

com
 +- example
     +- myapplication
         +- Application.java
         |
         +- customer
         |   +- Customer.java
         |   +- CustomerController.java
         |   +- CustomerService.java
         |   +- CustomerRepository.java
         |
         +- order
             +- Order.java
             +- OrderController.java
             +- OrderService.java
             +- OrderRepository.java

Application.java文件将声明main方法以及基本@SpringBootApplication，如下所示：

package com.example.myapplication;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Application {

	public static void main(String[] args) {
		SpringApplication.run(Application.class, args);
	}

}

你不需要将所有@Configuration放入一个班级。@Import注释可用于导入其他配置类。或者，您可以使用@ComponentScan自动选取所有Spring组件，包括@Configuration类。

如果您绝对必须使用基于XML的配置，我们建议您仍然使用@Configuration类。然后，您可以使用@ImportResource注释来加载XML配置文件。

自动配置是非侵入性的。在任何时候，您都可以开始定义自己的配置以替换自动配置的特定部分。例如，如果添加自己的DataSource bean，则默认的嵌入式数据库支持会退回。

如果您需要了解当前正在应用的自动配置以及原因，请使用--debug开关启动您的应用程序。这样做可以为选择的核心记录器启用调试日志，并将条件报告记录到控制台。

如果发现正在应用您不需要的特定自动配置类，则可以使用@EnableAutoConfiguration的exclude属性禁用它们，如以下示例所示：

import org.springframework.boot.autoconfigure.*;
import org.springframework.boot.autoconfigure.jdbc.*;
import org.springframework.context.annotation.*;

@Configuration
@EnableAutoConfiguration(exclude={DataSourceAutoConfiguration.class})
public class MyConfiguration {
}

如果类不在类路径上，则可以使用注释的excludeName属性并指定完全限定名称。最后，您还可以使用spring.autoconfigure.exclude属性控制要排除的自动配置类列表。

	提示
	您可以在注释级别和使用属性定义排除项。

您可以从IDE运行Spring Boot应用程序作为简单的Java应用程序。但是，您首先需要导入项目。导入步骤因IDE和构建系统而异。大多数IDE可以直接导入Maven项目。例如，Eclipse用户可以从File菜单中选择Import…​→Existing Maven Projects。

如果无法将项目直接导入IDE，则可以使用构建插件生成IDE元数据。Maven包括Eclipse和 IDEA的插件 。Gradle提供各种IDE的插件 。

	提示
	如果您不小心运行了两次Web应用程序，则会看到“端口已在使用中”错误。STS用户可以使用Relaunch按钮而不是Run按钮来确保关闭任何现有实例。

如果您使用Spring Boot Maven或Gradle插件创建可执行jar，则可以使用java -jar运行应用程序，如以下示例所示：

$ java -jar target/myapplication-0.0.1-SNAPSHOT.jar

也可以运行启用了远程调试支持的打包应用程序。这样做可以将调试器附加到打包的应用程序，如以下示例所示：

$ java -Xdebug -Xrunjdwp:server=y,transport=dt_socket,address=8000,suspend=n \
       -jar target/myapplication-0.0.1-SNAPSHOT.jar

Spring Boot Maven插件包含run目标，可用于快速编译和运行您的应用程序。应用程序以分解形式运行，就像在IDE中一样。以下示例显示了运行Spring Boot应用程序的典型Maven命令：

$ mvn spring-boot:run

您可能还想使用MAVEN_OPTS操作系统环境变量，如以下示例所示：

$ export MAVEN_OPTS=-Xmx1024m

Spring Boot Gradle插件还包含bootRun任务，可用于以爆炸形式运行您的应用程序。每当您应用org.springframework.boot和java插件时，都会添加bootRun任务，如以下示例所示：

$ gradle bootRun

您可能还想使用JAVA_OPTS操作系统环境变量，如以下示例所示：

$ export JAVA_OPTS=-Xmx1024m

由于Spring Boot应用程序只是普通的Java应用程序，因此JVM热交换应该是开箱即用的。JVM热交换在某种程度上受限于它可以替换的字节码。要获得更完整的解决方案， 可以使用JRebel。

spring-boot-devtools模块还包括对快速应用程序重启的支持。有关详细信息，请参阅本章后面的第20章“ 开发人员工具”部分和 热交换“操作方法”。

Spring Boot支持的几个库使用缓存来提高性能。例如，模板引擎缓存已编译的模板以避免重复解析模板文件。此外，Spring MVC可以在提供静态资源时为响应添加HTTP缓存头。

虽然缓存在生产中非常有用，但在开发过程中可能会适得其反，从而使您无法看到刚刚在应用程序中进行的更改。因此，spring-boot-devtools默认禁用缓存选项。

缓存选项通常由application.properties文件中的设置配置。例如，Thymeleaf提供spring.thymeleaf.cache财产。spring-boot-devtools模块不需要手动设置这些属性，而是自动应用合理的开发时配置。

由于在开发Spring MVC和Spring WebFlux应用程序时需要有关Web请求的更多信息，因此开发人员工具将为web日志记录组启用DEBUG日志记录。这将为您提供有关传入请求，处理程序正在处理它，响应结果等的信息。如果您希望记录所有请求详细信息（包括可能的敏感信息），您可以打开spring.http.log-request-details配置属性。

	注意
	如果您不希望应用属性默认值，则可以在application.properties中将spring.devtools.add-properties设置为false。

	提示
	有关devtools应用的属性的完整列表，请参阅 DevToolsPropertyDefaultsPostProcessor。

只要类路径上的文件发生更改，使用spring-boot-devtools的应用程序就会自动重新启动。在IDE中工作时，这可能是一个有用的功能，因为它为代码更改提供了非常快速的反馈循环。默认情况下，将监视类路径上指向文件夹的任何条目的更改。请注意，某些资源（如静态资产和视图模板）无需重新启动应用程序。

	注意
	只要启用了分叉，您也可以使用支持的构建插件（Maven和Gradle）启动应用程序，因为DevTools需要一个独立的应用程序类加载器才能正常运行。默认情况下，Gradle和Maven在类路径上检测到DevTools时会这样做。

	提示
	与LiveReload一起使用时，自动重启非常有效。 有关详细信息，请参阅LiveReload部分。如果使用JRebel，则禁用自动重新启动以支持动态类重新加载。其他devtools功能（例如LiveReload和属性覆盖）仍然可以使用。

	注意
	DevTools依赖于应用程序上下文的关闭钩子来在重启期间关闭它。如果禁用了关闭挂钩（SpringApplication.setRegisterShutdownHook(false)），它将无法正常工作。

	注意
	在确定类路径上的条目是否应在更改时触发重新启动时，DevTools会自动忽略名为spring-boot，spring-boot-devtools，spring-boot-autoconfigure，spring-boot-actuator和spring-boot-starter的项目。

	注意
	DevTools需要自定义ApplicationContext使用的ResourceLoader。如果您的应用程序已经提供了一个，它将被包装。不支持直接覆盖ApplicationContext上的getResource方法。

spring.devtools.restart.log-condition-evaluation-delta=false

20.2.2不包括资源

某些资源在更改时不一定需要触发重启。例如，可以就地编辑Thymeleaf模板。默认情况下，更改/META-INF/maven，/META-INF/resources，/resources，/static，/public或/templates中的资源不会触发重新启动，但会触发 实时重新加载。如果要自定义这些排除项，可以使用spring.devtools.restart.exclude属性。例如，要仅排除/static和/public，您需要设置以下属性：

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

	提示
	如果要保留这些默认值并添加其他排除项，请改用spring.devtools.restart.additional-exclude属性。

public static void main(String[] args) {
	System.setProperty("spring.devtools.restart.enabled", "false");
	SpringApplication.run(MyApp.class, args);
}

20.2.5使用触发文件

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

要使用触发器文件，请将spring.devtools.restart.trigger-file属性设置为触发器文件的路径。

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

20.2.6自定义重启类加载器

如前面在Restart vs Reload部分中所述，使用两个类加载器实现了重启功能。对于大多数应用程序，此方法运行良好。但是，它有时会导致类加载问题。

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

spring-devtools.properties文件可以包含前缀为restart.exclude和restart.include的属性。include元素是应该被拉入“restart”类加载器的项目，exclude元素是应该被下推到“基础”类加载器中的项目。该属性的值是应用于类路径的正则表达式模式，如以下示例所示：

restart.exclude.companycommonlibs=/mycorp-common-[\\w-]+\.jar
restart.include.projectcommon=/mycorp-myproj-[\\w-]+\.jar

	注意
	所有属性键必须是唯一的。只要属性以restart.include.或restart.exclude.开头，就会被考虑。

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

spring-boot-devtools模块包括一个嵌入式LiveReload服务器，可用于在更改资源时触发浏览器刷新。LiveReload浏览器扩展程序可从livereload.com免费用于Chrome，Firefox和Safari 。

如果您不想在应用程序运行时启动LiveReload服务器，则可以将spring.devtools.livereload.enabled属性设置为false。

	注意
	您一次只能运行一个LiveReload服务器。在启动应用程序之前，请确保没有其他LiveReload服务器正在运行。如果从IDE启动多个应用程序，则只有第一个具有LiveReload支持。

您可以通过将名为.spring-boot-devtools.properties的文件添加到$HOME文件夹来配置全局devtools设置（请注意，文件名以“。”开头）。添加到此文件的任何属性都适用于计算机上使用devtools的所有 Spring Boot应用程序。例如，要将restart配置为始终使用 触发器文件，您需要添加以下属性：

〜/ .spring引导-devtools.properties。 

spring.devtools.reload.trigger-file=.reloadtrigger

	注意
	在.spring-boot-devtools.properties中激活的配置文件不会影响特定于配置文件的配置文件的加载。

Spring Boot开发人员工具不仅限于本地开发。远程运行应用程序时，您还可以使用多个功能。远程支持是选择加入。要启用它，您需要确保重新打包的存档中包含devtools，如下面的清单所示：

<build>
	<plugins>
		<plugin>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-maven-plugin</artifactId>
			<configuration>
				<excludeDevtools>false</excludeDevtools>
			</configuration>
		</plugin>
	</plugins>
</build>

然后，您需要设置spring.devtools.remote.secret属性，如以下示例所示：

spring.devtools.remote.secret=mysecret

	警告
	在远程应用程序上启用spring-boot-devtools存在安全风险。您永远不应该在生产部署上启用支持。

远程devtools支持由两部分组成：一个接受连接的服务器端端点和一个在IDE中运行的客户端应用程序。设置spring.devtools.remote.secret属性后，将自动启用服务器组件。必须手动启动客户端组件。

20.5.1运行远程客户端应用程序

远程客户端应用程序旨在从IDE中运行。您需要使用与连接到的远程项目相同的类路径运行org.springframework.boot.devtools.RemoteSpringApplication。应用程序的单个必需参数是它连接的远程URL。

例如，如果您使用的是Eclipse或STS，并且已经部署到Cloud Foundry的项目名为my-app，则可以执行以下操作：

• 从Run菜单中选择Run Configurations…​。
• 创建一个新的Java Application“启动配置”。
• 浏览my-app项目。
• 使用org.springframework.boot.devtools.RemoteSpringApplication作为主类。
• 将https://myapp.cfapps.io添加到Program arguments（或任何远程URL）。

正在运行的远程客户端可能类似于以下列表：

  .   ____          _                                              __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _          ___               _      \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` |        | _ \___ _ __  ___| |_ ___ \ \ \ \
 \\/  ___)| |_)| | | | | || (_| []::::::[]   / -_) '  \/ _ \  _/ -_) ) ) ) )
  '  |____| .__|_| |_|_| |_\__, |        |_|_\___|_|_|_\___/\__\___|/ / / /
 =========|_|==============|___/===================================/_/_/_/
 :: Spring Boot Remote :: 2.1.1.RELEASE

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)

	注意
	因为远程客户端使用与真实应用程序相同的类路径，所以它可以直接读取应用程序属性。这是spring.devtools.remote.secret属性的读取方式并传递给服务器进行身份验证。

	提示
	始终建议使用https://作为连接协议，以便加密流量并且不会截获密码。

	提示
	如果需要使用代理来访问远程应用程序，请配置spring.devtools.remote.proxy.host和spring.devtools.remote.proxy.port属性。

20.5.2远程更新

远程客户端以与本地重新启动相同的方式监视应用程序类路径以进行更改 。任何更新的资源都会被推送到远程应用程序，并且（如果需要）会触发重新启动。如果您迭代使用本地没有的云服务的功能，这将非常有用。通常，远程更新和重新启动比完全重建和部署周期快得多。

	注意
	仅在远程客户端运行时监视文件。如果在启动远程客户端之前更改文件，则不会将其推送到远程服务器。

如果您的应用程序无法启动，则已注册FailureAnalyzers有机会提供专用错误消息和具体操作来解决问题。例如，如果您在端口8080上启动Web应用程序并且该端口已在使用中，您应该会看到类似于以下消息的内容：

***************************
APPLICATION FAILED TO START
***************************

Description:

Embedded servlet container failed to start. Port 8080 was already in use.

Action:

Identify and stop the process that's listening on port 8080 or configure this application to listen on another port.

	注意
	Spring Boot提供了许多FailureAnalyzer实现，您可以 添加自己的实现。

如果没有故障分析器能够处理异常，您仍然可以显示完整的条件报告，以便更好地了解出现了什么问题。为此，您需要 启用debug属性或 为org.springframework.boot.autoconfigure.logging.ConditionEvaluationReportLoggingListener 启用DEBUG日志记录。

例如，如果使用java -jar运行应用程序，则可以启用debug属性，如下所示：

$ java -jar myproject-0.0.1-SNAPSHOT.jar --debug

通过将banner.txt文件添加到类路径或将spring.banner.location属性设置为此类文件的位置，可以更改启动时打印的横幅。如果文件的编码不是UTF-8，则可以设置spring.banner.charset。除了文本文件，您还可以将banner.gif，banner.jpg或banner.png图像文件添加到类路径或设置spring.banner.image.location属性。图像将转换为ASCII艺术表示，并打印在任何文本横幅上方。

在banner.txt文件中，您可以使用以下任何占位符：

	提示
	如果要以编程方式生成横幅，可以使用SpringApplication.setBanner(…​)方法。使用org.springframework.boot.Banner接口并实现您自己的printBanner()方法。

您还可以使用spring.main.banner-mode属性来确定是否必须在System.out（console）上打印横幅，发送到配置的记录器（log），或者根本不产生横幅（off）。

打印的横幅以下列名称注册为单身bean：springBootBanner。

	注意
	YAML将off映射到false，因此如果要在应用程序中禁用横幅，请务必添加引号，如以下示例所示： spring: main: banner-mode: "off"

如果SpringApplication默认值不符合您的口味，您可以改为创建本地实例并对其进行自定义。例如，要关闭横幅，您可以写：

public static void main(String[] args) {
	SpringApplication app = new SpringApplication(MySpringConfiguration.class);
	app.setBannerMode(Banner.Mode.OFF);
	app.run(args);
}

	注意
	传递给SpringApplication的构造函数参数是Spring beans的配置源。在大多数情况下，这些是对@Configuration类的引用，但它们也可以是对XML配置或应扫描的包的引用。

也可以使用application.properties文件配置SpringApplication。有关详细信息，请参见第24章，外部化配置。

有关配置选项的完整列表，请参阅 SpringApplication Javadoc。

如果您需要构建ApplicationContext层次结构（具有父/子关系的多个上下文）或者您更喜欢使用“流畅”构建器API，则可以使用SpringApplicationBuilder。

SpringApplicationBuilder允许您将多个方法调用链接在一起，并包含允许您创建层次结构的parent和child方法，如以下示例所示：

new SpringApplicationBuilder()
		.sources(Parent.class)
		.child(Application.class)
		.bannerMode(Banner.Mode.OFF)
		.run(args);

	注意
	创建ApplicationContext层次结构时存在一些限制。例如，Web组件必须包含在子上下文中，并且父/子上下文使用相同的Environment。有关详细信息，请参阅 SpringApplicationBuilder Javadoc。

除了通常的Spring框架事件之外，例如 ContextRefreshedEvent，SpringApplication还会发送一些其他应用程序事件。

	注意
	某些事件实际上是在创建ApplicationContext之前触发的，因此您无法在@Bean上注册侦听器。您可以使用SpringApplication.addListeners(…​)方法或SpringApplicationBuilder.listeners(…​)方法注册它们。 如果您希望自动注册这些侦听器，无论应用程序的创建方式如何，您都可以将META-INF/spring.factories文件添加到项目中并使用org.springframework.context.ApplicationListener键引用您的侦听器，如下所示：以下示例： org.springframework.context.ApplicationListener=com.example.project.MyListener

应用程序运行时，应按以下顺序发送应用程序事件：

	提示
	您经常不需要使用应用程序事件，但知道它们存在可能很方便。在内部，Spring Boot使用事件来处理各种任务。

应用程序事件使用Spring Framework的事件发布机制发送。此机制的一部分确保在子上下文中发布给侦听器的事件也会在任何祖先上下文中发布给侦听器。因此，如果您的应用程序使用SpringApplication实例的层次结构，则侦听器可能会收到相同类型的应用程序事件的多个实例。

为了允许侦听器区分其上下文的事件和后代上下文的事件，它应该请求注入其应用程序上下文，然后将注入的上下文与事件的上下文进行比较。可以通过实现ApplicationContextAware或者如果监听器是bean，使用@Autowired来注入上下文。

SpringApplication试图代表您创建正确类型的ApplicationContext。用于确定WebApplicationType的算法非常简单：

这意味着如果您在同一个应用程序中使用Spring MVC和来自Spring WebFlux的新WebClient，默认情况下将使用Spring MVC。您可以通过调用setWebApplicationType(WebApplicationType)轻松覆盖它。

也可以通过调用setApplicationContextClass(…​)来完全控制使用的ApplicationContext类型。

	提示
	在JUnit测试中使用SpringApplication时，通常需要调用setWebApplicationType(WebApplicationType.NONE)。

如果您需要访问传递给SpringApplication.run(…​)的应用程序参数，则可以注入org.springframework.boot.ApplicationArguments bean。ApplicationArguments接口提供对原始String[]参数以及解析的option和non-option参数的访问，如以下示例所示：

import org.springframework.boot.*;
import org.springframework.beans.factory.annotation.*;
import org.springframework.stereotype.*;

@Component
public class MyBean {

	@Autowired
	public MyBean(ApplicationArguments args) {
		boolean debug = args.containsOption("debug");
		List<String> files = args.getNonOptionArgs();
		// if run with "--debug logfile.txt" debug=true, files=["logfile.txt"]
	}

}

	提示
	Spring Boot还注册CommandLinePropertySource和Spring Environment。这使您还可以使用@Value注释注入单个应用程序参数。

如果您需要在SpringApplication启动后运行某些特定代码，则可以实现ApplicationRunner或CommandLineRunner接口。两个接口以相同的方式工作，并提供单个run方法，该方法在SpringApplication.run(…​)完成之前调用。

CommandLineRunner接口提供对应用程序参数的访问，作为简单的字符串数组，而ApplicationRunner使用前面讨论的ApplicationArguments接口。以下示例显示CommandLineRunner和run方法：

import org.springframework.boot.*;
import org.springframework.stereotype.*;

@Component
public class MyBean implements CommandLineRunner {

	public void run(String... args) {
		// Do something...
	}

}

如果定义了必须按特定顺序调用的多个CommandLineRunner或ApplicationRunner beans，则可以另外实现org.springframework.core.Ordered接口或使用org.springframework.core.annotation.Order注释。

每个SpringApplication都会向JVM注册一个关闭钩子，以确保ApplicationContext在退出时正常关闭。可以使用所有标准Spring生命周期回调（例如DisposableBean接口或@PreDestroy注释）。

此外，beans如果希望在调用SpringApplication.exit()时返回特定的退出代码，则可以实现org.springframework.boot.ExitCodeGenerator接口。然后可以将此退出代码传递给System.exit()以将其作为状态代码返回，如以下示例所示：

@SpringBootApplication
public class ExitCodeApplication {

	@Bean
	public ExitCodeGenerator exitCodeGenerator() {
		return () -> 42;
	}

	public static void main(String[] args) {
		System.exit(SpringApplication
				.exit(SpringApplication.run(ExitCodeApplication.class, args)));
	}

}

此外，ExitCodeGenerator接口可以通过例外来实现。遇到这样的异常时，Spring Boot返回实现的getExitCode()方法提供的退出代码。

通过指定spring.application.admin.enabled属性，可以为应用程序启用与管理相关的功能。这暴露了 SpringApplicationAdminMXBean 平台MBeanServer。您可以使用此功能远程管理您的Spring Boot应用程序。此功能对于任何服务包装器实现也很有用。

	提示
	如果您想知道应用程序正在运行的HTTP端口，请使用local.server.port的密钥获取该属性。

	警告
	启用此功能时要小心，因为MBean公开了一种关闭应用程序的方法。

RandomValuePropertySource对于注入随机值（例如，进入秘密或测试用例）非常有用。它可以生成整数，长整数，uuids或字符串，如以下示例所示：

my.secret=${random.value}
my.number=${random.int}
my.bignumber=${random.long}
my.uuid=${random.uuid}
my.number.less.than.ten=${random.int(10)}
my.number.in.range=${random.int[1024,65536]}

random.int*语法为OPEN value (,max) CLOSE，其中OPEN,CLOSE为任意字符，value,max为整数。如果提供max，那么value是最小值，max是最大值（不包括）。

默认情况下，SpringApplication将任何命令行选项参数（即以--开头的参数，例如--server.port=9000）转换为property，并将它们添加到Spring Environment。如前所述，命令行属性始终优先于其他属性源。

如果您不希望将命令行属性添加到Environment，则可以使用SpringApplication.setAddCommandLineProperties(false)禁用它们。

SpringApplication从以下位置的application.properties文件加载属性，并将它们添加到Spring Environment：

列表按优先级排序（在列表中较高位置定义的属性将覆盖在较低位置中定义的属性）。

	注意
	您还可以使用YAML（'。mil'）文件替代'.properties'。

如果您不喜欢application.properties作为配置文件名，则可以通过指定spring.config.name环境属性来切换到另一个文件名。您还可以使用spring.config.location环境属性（以逗号分隔的目录位置或文件路径列表）来引用显式位置。以下示例显示如何指定其他文件名：

$ java -jar myproject.jar --spring.config.name=myproject

以下示例显示如何指定两个位置：

$ java -jar myproject.jar --spring.config.location=classpath:/default.properties,classpath:/override.properties

	警告
	很早就使用spring.config.name和spring.config.location来确定必须加载哪些文件，因此必须将它们定义为环境属性（通常是OS环境变量，系统属性或命令行参数）。

如果spring.config.location包含目录（而不是文件），则它们应以/结束（并且在运行时，在加载之前附加从spring.config.name生成的名称，包括特定于配置文件的文件名） 。spring.config.location中指定的文件按原样使用，不支持特定于配置文件的变体，并且被任何特定于配置文件的属性覆盖。