spring boot学习1

转：https://blog.csdn.net/jsyxcjw/article/details/46763639

1 开始

1.1 spring介绍

Spring Boot使开发独立的，产品级别的基于Spring的应用变得非常简单，你只需"just run"。 我们为Spring平台及第三方库提供开箱即用的设置，这样你就可以有条不紊地开始。多数Spring Boot应用需要很少的Spring配置。

你可以使用Spring Boot创建Java应用，并使用java -jar启动它或采用传统的war部署方式。

1.2 系统要求

默认情况下，Spring Boot 1.3.0.BUILD-SNAPSHOT 需要Java7和Spring框架4.1.3或以上。你可以在Java6下使用Spring Boot，不过需要添加额外配置。具体参考Section 73.9, “How to use Java 6” 。构建环境明确支持的有Maven（3.2+）和Gradle（1.12+）。

Servlet容器 下列内嵌容器支持开箱即用（out of the box）：

1.  
   名称 Servlet版本 Java版本
2.  
   Tomcat 8 3.1 Java 7+
3.  
   Tomcat 7 3.0 Java 6+
4.  
   Jetty 9 3.1 Java 7+
5.  
   Jetty 8 3.0 Java 6+
6.  
   Undertow 1.1 3.1 Java 7+

你也可以将Spring Boot应用部署到任何兼容Servlet 3.0+的容器。

1.3 第一个spring boot应用

在开始前，你需要打开一个终端，检查是否安装可用的Java版本和Maven：

1.  
   $ mvn -v
2.  
   Apache Maven 3.2.3 (33f8c3e1027c3ddde99d3cdebad2656a31e8fdf4; 2014-08-11T13:58:10-07:00)
3.  
   Maven home: /Users/user/tools/apache-maven-3.1.1
4.  
   Java version: 1.7.0_51, vendor: Oracle Corporation

创建pom.xml文件

1.  
   <?xml version="1.0" encoding="UTF-8"?>
2.  
   <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
3.  
   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
4.  
   <modelVersion>4.0.0</modelVersion>
5.  
    
6.  
   <groupId>com.example</groupId>
7.  
   <artifactId>myproject</artifactId>
8.  
   <version>0.0.1-SNAPSHOT</version>
9.  
    
10.  
    <parent>
11.  
    <groupId>org.springframework.boot</groupId>
12.  
    <artifactId>spring-boot-starter-parent</artifactId>
13.  
    <version>1.3.0.BUILD-SNAPSHOT</version>
14.  
    </parent>
15.  
     
16.  
    <!-- Additional lines to be added here... -->
17.  
     
18.  
    <!-- (you don't need this if you are using a .RELEASE version) -->
19.  
    <repositories>
20.  
    <repository>
21.  
    <id>spring-snapshots</id>
22.  
    <url>http://repo.spring.io/snapshot</url>
23.  
    <snapshots><enabled>true</enabled></snapshots>
24.  
    </repository>
25.  
    <repository>
26.  
    <id>spring-milestones</id>
27.  
    <url>http://repo.spring.io/milestone</url>
28.  
    </repository>
29.  
    </repositories>
30.  
    <pluginRepositories>
31.  
    <pluginRepository>
32.  
    <id>spring-snapshots</id>
33.  
    <url>http://repo.spring.io/snapshot</url>
34.  
    </pluginRepository>
35.  
    <pluginRepository>
36.  
    <id>spring-milestones</id>
37.  
    <url>http://repo.spring.io/milestone</url>
38.  
    </pluginRepository>
39.  
    </pluginRepositories>
40.  
    </project>

添加classpath依赖：

Spring Boot提供很多"Starter POMs"，这能够让你轻松的将jars添加到你的classpath下。我们的示例程序已经在POM的partent节点使用了spring-boot-starter-parent。spring-boot-starter-parent是一个特殊的starter，它提供了有用的Maven默认设置。同时，它也提供了一个dependency-management节点，这样对于”blessed“依赖你可以省略version标记。

1.  
   <dependencies>
2.  
   <dependency>
3.  
   <groupId>org.springframework.boot</groupId>
4.  
   <artifactId>spring-boot-starter-web</artifactId>
5.  
   </dependency>
6.  
   </dependencies>

如果再次运行mvn dependency:tree，你将看到现在有了一些其他依赖，包括Tomcat web服务器和Spring Boot自身。

编写代码：

为了完成应用程序，我们需要创建一个单独的Java文件。Maven默认会编译src/main/java下的源码，所以你需要创建那样的文件结构，然后添加一个名为src/main/java/Example.java的文件：

1.  
   import org.springframework.boot.*;
2.  
   import org.springframework.boot.autoconfigure.*;
3.  
   import org.springframework.stereotype.*;
4.  
   import org.springframework.web.bind.annotation.*;
5.  
    
6.  
   @RestController
7.  
   @EnableAutoConfiguration
8.  
   public class Example {
9.  
    
10.  
    @RequestMapping("/")
11.  
    String home() {
12.  
    return "Hello World!";
13.  
    }
14.  
     
15.  
    public static void main(String[] args) throws Exception {
16.  
    SpringApplication.run(Example.class, args);
17.  
    }
18.  
    }

@RestController和@RequestMapping说明：

@RestController。这被称为一个构造型（stereotype）注解。它为阅读代码的人们提供建议。对于Spring，该类扮演了一个特殊角色。在本示例中，我们的类是一个web @Controller，所以当处理进来的web请求时，Spring会询问它。

@RequestMapping注解提供路由信息。它告诉Spring任何来自"/"路径的HTTP请求都应该被映射到home方法。@RestController注解告诉Spring以字符串的形式渲染结果，并直接返回给调用者。

@EnableAutoConfiguration。这个注解告诉Spring Boot根据添加的jar依赖猜测你想如何配置Spring。由于spring-boot-starter-web添加了Tomcat和Spring MVC，所以auto-configuration将假定你正在开发一个web应用并相应地对Spring进行设置。

main方法。这只是一个标准的方法，它遵循Java对于一个应用程序入口点的约定。我们的main方法通过调用run，将业务委托给了Spring Boot的SpringApplication类。SpringApplication将引导我们的应用，启动Spring，相应地启动被自动配置的Tomcat web服务器。我们需要将Example.class作为参数传递给run方法来告诉SpringApplication谁是主要的Spring组件。

运行：

 mvn spring-boot:run

如果使用一个浏览器打开 localhost:8080，以下输出：

Hello World!

创建可执行jar

为了创建可执行的jar，需要将spring-boot-maven-plugin添加到我们的pom.xml中。在dependencies节点下插入以下内容：

1.  
   <build>
2.  
   <plugins>
3.  
   <plugin>
4.  
   <groupId>org.springframework.boot</groupId>
5.  
   <artifactId>spring-boot-maven-plugin</artifactId>
6.  
   </plugin>
7.  
   </plugins>
8.  
   </build>

注：spring-boot-starter-parent POM包含用于绑定repackage目标的配置。如果你不使用parent POM，你将需要自己声明该配置。具体参考插件文档。

保存你的pom.xml，然后从命令行运行mvn package：

 mvn package

如果查看target目录，你应该看到myproject-0.0.1-SNAPSHOT.jar。该文件应该有10Mb左右的大小。如果想偷看内部结构，你可以运行jar tvf：

 jar tvf target/myproject-0.0.1-SNAPSHOT.jar

在target目录下，你应该也能看到一个很小的名为myproject-0.0.1-SNAPSHOT.jar.original的文件。这是在Spring Boot重新打包前Maven创建的原始jar文件。

为了运行该应用程序，你可以使用java -jar命令：

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

2. 使用Spring Boot

2.1 maven

Maven用户可以继承spring-boot-starter-parent项目来获取合适的默认设置。该父项目提供以下特性：

1.  
   默认编译级别为Java 1.6
2.  
   源码编码为UTF-8
3.  
   一个依赖管理节点，允许你省略普通依赖的<version>标签，继承自spring-boot-dependencies POM。
4.  
   合适的资源过滤
5.  
   合适的插件配置（exec插件，surefire，Git commit ID，shade）
6.  
   针对application.properties和application.xml的资源过滤

最后一点：由于默认配置文件接收Spring风格的占位符（${...}），Maven filtering改用@..@占位符（你可以使用Maven属性resource.delimiter来覆盖它）。

想配置你的项目继承spring-boot-starter-parent只需要简单地设置parent为：

1.  
   <!-- Inherit defaults from Spring Boot -->
2.  
   <parent>
3.  
   <groupId>org.springframework.boot</groupId>
4.  
   <artifactId>spring-boot-starter-parent</artifactId>
5.  
   <version>1.3.0.BUILD-SNAPSHOT</version>
6.  
   </parent>

注：你应该只需要在该依赖上指定Spring Boot版本。如果导入其他的starters，你可以放心的省略版本号。

使用没有父POM的Spring Boot

不是每个人都喜欢继承spring-boot-starter-parent POM。你可能需要使用公司标准parent，或你可能倾向于显式声明所有Maven配置。

如果你不使用spring-boot-starter-parent，通过使用一个scope=import的依赖，你仍能获取到依赖管理的好处：

1.  
   <dependencyManagement>
2.  
   <dependencies>
3.  
   <dependency>
4.  
   <!-- Import dependency management from Spring Boot -->
5.  
   <groupId>org.springframework.boot</groupId>
6.  
   <artifactId>spring-boot-dependencies</artifactId>
7.  
   <version>1.3.0.BUILD-SNAPSHOT</version>
8.  
   <type>pom</type>
9.  
   <scope>import</scope>
10.  
    </dependency>
11.  
    </dependencies>
12.  
    </dependencyManagement>

改变Java版本

spring-boot-starter-parent选择相当保守的Java兼容策略。如果你遵循我们的建议，使用最新的Java版本，你可以添加一个java.version属性：

1.  
   <properties>
2.  
   <java.version>1.8</java.version>
3.  
   </properties>

** 使用Spring Boot Maven插件**

Spring Boot包含一个Maven插件，它可以将项目打包成一个可执行jar。如果想使用它，你可以将该插件添加到节点处：

1.  
   <build>
2.  
   <plugins>
3.  
   <plugin>
4.  
   <groupId>org.springframework.boot</groupId>
5.  
   <artifactId>spring-boot-maven-plugin</artifactId>
6.  
   </plugin>
7.  
   </plugins>
8.  
   </build>

注：如果使用Spring Boot starter parent pom，你只需要添加该插件而无需配置它，除非你想改变定义在partent中的设置。

2.2 组织代码

Spring Boot不需要使用任何特殊的代码结构，然而，这里有一些有用的最佳实践。

使用"default"包

当类没有包含package声明时，它被认为处于default package下。通常不推荐使用default package，并应该避免使用它。因为对于使用@ComponentScan，@EntityScan或@SpringBootApplication注解的Spring Boot应用来说，来自每个jar的类都会被读取，这会造成一定的问题。

定位main应用类

我们通常建议你将main应用类放在位于其他类上面的根包（root package）中。通常使用@EnableAutoConfiguration注解你的main类，并且暗地里为某些项定义了一个基础“search package”。例如，如果你正在编写一个JPA应用，被@EnableAutoConfiguration注解的类所在包将被用来搜索@Entity项。

使用根包允许你使用@ComponentScan注解而不需要定义一个basePackage属性。如果main类位于根包中，你也可以使用@SpringBootApplication注解。

下面是一个典型的结构：

1.  
   com
2.  
   +- example
3.  
   +- myproject
4.  
   +- Application.java
5.  
   |
6.  
   +- domain
7.  
   | +- Customer.java
8.  
   | +- CustomerRepository.java
9.  
   |
10.  
    +- service
11.  
    | +- CustomerService.java
12.  
    |
13.  
    +- web
14.  
    +- CustomerController.java

Application.java文件将声明main方法，还有基本的@Configuration。

1.  
   package com.example.myproject;
2.  
    
3.  
   import org.springframework.boot.SpringApplication;
4.  
   import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
5.  
   import org.springframework.context.annotation.ComponentScan;
6.  
   import org.springframework.context.annotation.Configuration;
7.  
    
8.  
   @Configuration
9.  
   @EnableAutoConfiguration
10.  
    @ComponentScan
11.  
    public class Application {
12.  
     
13.  
    public static void main(String[] args) {
14.  
    SpringApplication.run(Application.class, args);
15.  
    }
16.  
     
17.  
    }

2.3 配置类

Spring Boot提倡基于Java的配置。尽管你可以使用一个XML源来调用SpringApplication.run()，我们通常建议你使用@Configuration类作为主要源。一般定义main方法的类也是主要@Configuration的一个很好候选。

1、导入其他配置类

你不需要将所有的@Configuration放进一个单独的类。@Import注解可以用来导入其他配置类。另外，你也可以使用@ComponentScan注解自动收集所有的Spring组件，包括@Configuration类。

2、导入XML配置

如果你绝对需要使用基于XML的配置，我们建议你仍旧从一个@Configuration类开始。你可以使用附加的@ImportResource注解加载XML配置文件。

2.4 自动配置

Spring Boot自动配置（auto-configuration）尝试根据你添加的jar依赖自动配置你的Spring应用。例如，如果你的classpath下存在HSQLDB，并且你没有手动配置任何数据库连接beans，那么我们将自动配置一个内存型（in-memory）数据库。

你可以通过将@EnableAutoConfiguration或@SpringBootApplication注解添加到一个@Configuration类上来选择自动配置。

注：你只需要添加一个@EnableAutoConfiguration注解。我们建议你将它添加到主@Configuration类上。

禁用特定的自动配置

如果发现应用了你不想要的特定自动配置类，你可以使用@EnableAutoConfiguration注解的排除属性来禁用它们。

1.  
   import org.springframework.boot.autoconfigure.*;
2.  
   import org.springframework.boot.autoconfigure.jdbc.*;
3.  
   import org.springframework.context.annotation.*;
4.  
    
5.  
   @Configuration
6.  
   @EnableAutoConfiguration(exclude={DataSourceAutoConfiguration.class})
7.  
   public class MyConfiguration {
8.  
   }

2.5 Spring Beans和依赖注入

你可以自由地使用任何标准的Spring框架技术去定义beans和它们注入的依赖。简单起见，我们经常使用@ComponentScan注解搜索beans，并结合@Autowired构造器注入。

如果使用上面建议的结构组织代码（将应用类放到根包下），你可以添加@ComponentScan注解而不需要任何参数。你的所有应用程序组件（@Component, @Service, @Repository, @Controller等）将被自动注册为Spring Beans。

下面是一个@Service Bean的示例，它使用构建器注入获取一个需要的RiskAssessor bean。

1.  
   package com.example.service;
2.  
    
3.  
   import org.springframework.beans.factory.annotation.Autowired;
4.  
   import org.springframework.stereotype.Service;
5.  
    
6.  
   @Service
7.  
   public class DatabaseAccountService implements AccountService {
8.  
    
9.  
   private final RiskAssessor riskAssessor;
10.  
     
11.  
    @Autowired
12.  
    public DatabaseAccountService(RiskAssessor riskAssessor) {
13.  
    this.riskAssessor = riskAssessor;
14.  
    }
15.  
     
16.  
    // ...
17.  
    }

注：注意如何使用构建器注入来允许riskAssessor字段被标记为final，这意味着riskAssessor后续是不能改变的。

2.6 使用@SpringBootApplication注解

很多Spring Boot开发者总是使用@Configuration，@EnableAutoConfiguration和@ComponentScan注解他们的main类。由于这些注解被如此频繁地一块使用（特别是你遵循以上最佳实践时），Spring Boot提供一个方便的@SpringBootApplication选择。

该@SpringBootApplication注解等价于以默认属性使用@Configuration，@EnableAutoConfiguration和@ComponentScan。

1.  
   package com.example.myproject;
2.  
   import org.springframework.boot.SpringApplication;
3.  
   import org.springframework.boot.autoconfigure.SpringBootApplication;
4.  
    
5.  
   @SpringBootApplication // same as @Configuration @EnableAutoConfiguration @ComponentScan
6.  
   public class Application {
7.  
    
8.  
   public static void main(String[] args) {
9.  
   SpringApplication.run(Application.class, args);
10.  
    }
11.  
     
12.  
    }

2.7 作为一个打包后的应用运行

如果使用Spring Boot Maven或Gradle插件创建一个可执行jar，你可以使用java -jar运行你的应用。例如：

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

运行一个打包的程序并开启远程调试支持是可能的，这允许你将调试器附加到打包的应用程序上：

1.  
   java -Xdebug -Xrunjdwp:server=y,transport=dt_socket,address=8000,suspend=n
2.  
   -jar target/myproject-0.0.1-SNAPSHOT.jar

2.8 使用Maven插件运行

Spring Boot Maven插件包含一个run目标，它可以用来快速编译和运行应用程序。应用程序以一种暴露的方式运行，由于即时"热"加载，你可以编辑资源。

 mvn spring-boot:run

你可能想使用有用的操作系统环境变量：

 export MAVEN_OPTS=-Xmx1024m -XX:MaxPermSize=128M -Djava.security.egd=file:/dev/./urandom

3 Spring Boot特性

3.1 SpringApplication

SpringApplication类提供了一种从main()方法启动Spring应用的便捷方式。在很多情况下，你只需委托给SpringApplication.run这个静态方法：

1.  
   public static void main(String[] args){
2.  
   SpringApplication.run(MySpringConfiguration.class, args);
3.  
   }

当应用启动时，你应该会看到类似下面的东西（这是何方神兽？？）：

1.  
   . ____ _ __ _ _
2.  
   /\ / ___'_ __ _ _(_)_ __ __ _
3.  
   ( ( )\___ | '_ | '_| | '_ / _` |
4.  
   \/ ___)| |_)| | | | | || (_| | ) ) ) )
5.  
   ' |____| .__|_| |_|_| |_\__, | / / / /
6.  
   =========|_|==============|___/=/_/_/_/
7.  
   :: Spring Boot :: v1.2.2.BUILD-SNAPSHOT
8.  
    
9.  
   2013-07-31 00:08:16.117 INFO 56603 --- [ main] o.s.b.s.app.SampleApplication : Starting SampleApplication v0.1.0 on mycomputer with PID 56603 (/apps/myapp.jar started by pwebb)
10.  
    2013-07-31 00:08:16.166 INFO 56603 --- [ main] ationConfigEmbeddedWebApplicationContext : Refreshing org.springframework.boot.context.embedded.AnnotationConfigEmbeddedWebApplicationContext@6e5a8246: startup date [Wed Jul 31 00:08:16 PDT 2013]; root of context hierarchy
11.  
    2014-03-04 13:09:54.912 INFO 41370 --- [ main] .t.TomcatEmbeddedServletContainerFactory : Server initialized with port: 8080
12.  
    2014-03-04 13:09:56.501 INFO 41370 --- [ main] o.s.b.s.app.SampleApplication : S
13.  
     

默认情况下会显示INFO级别的日志信息，包括一些相关的启动详情，比如启动应用的用户等。

3.1.1 自定义Banner

通过在classpath下添加一个banner.txt或设置banner.location来指定相应的文件可以改变启动过程中打印的banner。如果这个文件有特殊的编码，你可以使用banner.encoding设置它（默认为UTF-8）。

在banner.txt中可以使用如下的变量：

1.  
   变量 描述
2.  
   ${application.version} MANIFEST.MF中声明的应用版本号，例如1.0
3.  
   ${application.formatted-version} MANIFEST.MF中声明的被格式化后的应用版本号（被括号包裹且以v作为前缀），用于显示，例如(v1.0)
4.  
   ${spring-boot.version} 正在使用的Spring Boot版本号，例如1.2.2.BUILD-SNAPSHOT
5.  
   ${spring-boot.formatted-version} 正在使用的Spring Boot被格式化后的版本号（被括号包裹且以v作为前缀）, 用于显示，例如(v1.2.2.BUILD-SNAPSHOT)

注：如果想以编程的方式产生一个banner，可以使用SpringBootApplication.setBanner(…)方法。使用org.springframework.boot.Banner接口，实现你自己的printBanner()方法。

3.1.2 自定义SpringApplication

如果默认的SpringApplication不符合你的口味，你可以创建一个本地的实例并自定义它。例如，关闭banner你可以这样写：

1.  
   public static void main(String[] args){
2.  
   SpringApplication app = new SpringApplication(MySpringConfiguration.class);
3.  
   app.setShowBanner(false);
4.  
   app.run(args);
5.  
   }

注：传递给SpringApplication的构造器参数是spring beans的配置源。在大多数情况下，这些将是@Configuration类的引用，但它们也可能是XML配置或要扫描包的引用。

3.1.3 流畅的构建API

如果你需要创建一个分层的ApplicationContext（多个具有父子关系的上下文），或你只是喜欢使用流畅的构建API，你可以使用SpringApplicationBuilder。SpringApplicationBuilder允许你以链式方式调用多个方法，包括可以创建层次结构的parent和child方法。

1.  
   new SpringApplicationBuilder()
2.  
   .showBanner(false)
3.  
   .sources(Parent.class)
4.  
   .child(Application.class)
5.  
   .run(args);

注：创建ApplicationContext层次时有些限制，比如，Web组件(components)必须包含在子上下文(child context)中，且相同的Environment即用于父上下文也用于子上下文中。

3.1.4 Application事件和监听器

除了常见的Spring框架事件，比如ContextRefreshedEvent，一个SpringApplication也发送一些额外的应用事件。一些事件实际上是在ApplicationContext被创建前触发的。

你可以使用多种方式注册事件监听器，最普通的是使用SpringApplication.addListeners(…)方法。在你的应用运行时，应用事件会以下面的次序发送：

1.  
   在运行开始，但除了监听器注册和初始化以外的任何处理之前，会发送一个ApplicationStartedEvent。
2.  
    
3.  
   在Environment将被用于已知的上下文，但在上下文被创建前，会发送一个ApplicationEnvironmentPreparedEvent。
4.  
    
5.  
   在refresh开始前，但在bean定义已被加载后，会发送一个ApplicationPreparedEvent。
6.  
    
7.  
   启动过程中如果出现异常，会发送一个ApplicationFailedEvent。

注：你通常不需要使用应用程序事件，但知道它们的存在会很方便（在某些场合可能会使用到）。在Spring内部，Spring Boot使用事件处理各种各样的任务。

3.1.5 Web环境

一个SpringApplication将尝试为你创建正确类型的ApplicationContext。在默认情况下，使用AnnotationConfigApplicationContext或AnnotationConfigEmbeddedWebApplicationContext取决于你正在开发的是否是web应用。

用于确定一个web环境的算法相当简单（基于是否存在某些类）。如果需要覆盖默认行为，你可以使用setWebEnvironment(boolean webEnvironment)。通过调用setApplicationContextClass(…)，你可以完全控制ApplicationContext的类型。

注：当JUnit测试里使用SpringApplication时，调用setWebEnvironment(false)是可取的。

3.1.6 命令行启动器

如果你想获取原始的命令行参数，或一旦SpringApplication启动，你需要运行一些特定的代码，你可以实现CommandLineRunner接口。在所有实现该接口的Spring beans上将调用run(String… args)方法。

1.  
   import org.springframework.boot.*
2.  
   import org.springframework.stereotype.*
3.  
    
4.  
   @Component
5.  
   public class MyBean implements CommandLineRunner {
6.  
   public void run(String... args) {
7.  
   // Do something...
8.  
   }
9.  
   }

如果一些CommandLineRunner beans被定义必须以特定的次序调用，你可以额外实现org.springframework.core.Ordered接口或使用org.springframework.core.annotation.Order注解。

3.1.7 Application退出

每个SpringApplication在退出时为了确保ApplicationContext被优雅的关闭，将会注册一个JVM的shutdown钩子。所有标准的Spring生命周期回调（比如，DisposableBean接口或@PreDestroy注解）都能使用。

此外，如果beans想在应用结束时返回一个特定的退出码（exit code），可以实现org.springframework.boot.ExitCodeGenerator接口。

4 外化配置

Spring Boot允许外化（externalize）你的配置，这样你能够在不同的环境下使用相同的代码。你可以使用properties文件，YAML文件，环境变量和命令行参数来外化配置。使用@Value注解，可以直接将属性值注入到你的beans中，并通过Spring的Environment抽象或绑定到结构化对象来访问。

Spring Boot使用一个非常特别的PropertySource次序来允许对值进行合理的覆盖，需要以下面的次序考虑属性：

1.  
   命令行参数
2.  
   来自于java:comp/env的JNDI属性
3.  
   Java系统属性（System.getProperties()）
4.  
   操作系统环境变量
5.  
   只有在random.*里包含的属性会产生一个RandomValuePropertySource
6.  
   在打包的jar外的应用程序配置文件（application.properties，包含YAML和profile变量）
7.  
   在打包的jar内的应用程序配置文件（application.properties，包含YAML和profile变量）
8.  
   在@Configuration类上的@PropertySource注解
9.  
   默认属性（使用SpringApplication.setDefaultProperties指定）

下面是一个具体的示例（假设你开发一个使用name属性的@Component）：

1.  
   import org.springframework.stereotype.*
2.  
   import org.springframework.beans.factory.annotation.*
3.  
    
4.  
   @Component
5.  
   public class MyBean {
6.  
   @Value("${name}")
7.  
   private String name;
8.  
   // ...
9.  
   }

你可以将一个application.properties文件捆绑到jar内，用来提供一个合理的默认name属性值。当运行在生产环境时，可以在jar外提供一个application.properties文件来覆盖name属性。对于一次性的测试，你可以使用特定的命令行开关启动（比如，java -jar app.jar --name="Spring"）。

4.1 配置随机值

RandomValuePropertySource在注入随机值（比如，密钥或测试用例）时很有用。它能产生整数，longs或字符串，比如：

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

random.int*语法是OPEN value (,max) CLOSE，此处OPEN，CLOSE可以是任何字符，并且value，max是整数。如果提供max，那么value是最小的值，max是最大的值（不包含在内）。

4.2访问命令行属性

默认情况下，SpringApplication将任何可选的命令行参数（以'--'开头，比如，--server.port=9000）转化为property，并将其添加到Spring Environment中。如上所述，命令行属性总是优先于其他属性源。

如果你不想将命令行属性添加到Environment里，你可以使用SpringApplication.setAddCommandLineProperties(false)来禁止它们。

4.3 Application属性文件

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

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

这个列表是按优先级排序的（列表中位置高的将覆盖位置低的）。

注：你可以使用YAML（'.yml'）文件替代'.properties'。

如果不喜欢将application.properties作为配置文件名，你可以通过指定spring.config.name环境属性来切换其他的名称。你也可以使用spring.config.location环境属性来引用一个明确的路径（目录位置或文件路径列表以逗号分割）。

1.  
   $ java -jar myproject.jar --spring.config.name=myproject
2.  
   //or
3.  
   $ java -jar myproject.jar --spring.config.location=classpath:/default.properties,classpath:/override.properties

如果spring.config.location包含目录（相对于文件），那它们应该以/结尾（在加载前，spring.config.name产生的名称将被追加到后面）。不管spring.config.location是什么值，默认的搜索路径classpath:,classpath:/config,file:,file:config/总会被使用。以这种方式，你可以在application.properties中为应用设置默认值，然后在运行的时候使用不同的文件覆盖它，同时保留默认配置。

注：如果你使用环境变量而不是系统配置，大多数操作系统不允许以句号分割（period-separated）的key名称，但你可以使用下划线（underscores）代替（比如，使用SPRINGCONFIGNAME代替spring.config.name）。如果你的应用运行在一个容器中，那么JNDI属性（java:comp/env）或servlet上下文初始化参数可以用来取代环境变量或系统属性，当然也可以使用环境变量或系统属性。

4.4 特定的Profile属性

除了application.properties文件，特定配置属性也能通过命令惯例application-{profile}.properties来定义。特定Profile属性从跟标准application.properties相同的路径加载，并且特定profile文件会覆盖默认的配置。

4.5 属性占位符

当application.properties里的值被使用时，它们会被存在的Environment过滤，所以你能够引用先前定义的值（比如，系统属性）。

1.  
   app.name=MyApp
2.  
   app.description=${app.name} is a Spring Boot application

4.6 使用YAML代替Properties

YAML是JSON的一个超集，也是一种方便的定义层次配置数据的格式。无论你何时将SnakeYAML 库放到classpath下，SpringApplication类都会自动支持YAML作为properties的替换。

注：如果你使用'starter POMs'，spring-boot-starter会自动提供SnakeYAML。

4.6.1. 加载YAML

Spring框架提供两个便利的类用于加载YAML文档，YamlPropertiesFactoryBean会将YAML作为Properties来加载，YamlMapFactoryBean会将YAML作为Map来加载。

示例：

1.  
   environments:
2.  
   dev:
3.  
   url: http://dev.bar.com
4.  
   name: Developer Setup
5.  
   prod:
6.  
   url: http://foo.bar.com
7.  
   name: My Cool App

上面的YAML文档会被转化到下面的属性中：

1.  
   environments.dev.url=http://dev.bar.com
2.  
   environments.dev.name=Developer Setup
3.  
   environments.prod.url=http://foo.bar.com
4.  
   environments.prod.name=My Cool App

YAML列表被表示成使用[index]间接引用作为属性keys的形式，例如下面的YAML：

1.  
   my:
2.  
   servers:
3.  
   - dev.bar.com
4.  
   - foo.bar.com

将会转化到下面的属性中:

1.  
   my.servers[0]=dev.bar.com
2.  
   my.servers[1]=foo.bar.com

使用Spring DataBinder工具绑定那样的属性（这是@ConfigurationProperties做的事），你需要确定目标bean中有个java.util.List或Set类型的属性，并且需要提供一个setter或使用可变的值初始化它，比如，下面的代码将绑定上面的属性：

1.  
   @ConfigurationProperties(prefix="my")
2.  
   public class Config {
3.  
   private List<String> servers = new ArrayList<String>();
4.  
   public List<String> getServers() {
5.  
   return this.servers;
6.  
   }
7.  
   }

4.6.2. 在Spring环境中使用YAML暴露属性

YamlPropertySourceLoader类能够用于将YAML作为一个PropertySource导出到Sprig Environment。这允许你使用熟悉的@Value注解和占位符语法访问YAML属性。

4.6.3. Multi-profile YAML文档

你可以在单个文件中定义多个特定配置（profile-specific）的YAML文档，并通过一个spring.profiles key标示应用的文档。例如：

1.  
   server:
2.  
   address: 192.168.1.100
3.  
   ---
4.  
   spring:
5.  
   profiles: development
6.  
   server:
7.  
   address: 127.0.0.1
8.  
   ---
9.  
   spring:
10.  
    profiles: production
11.  
    server:
12.  
    address: 192.168.1.120

在上面的例子中，如果development配置被激活，那server.address属性将是127.0.0.1。如果development和production配置（profiles）没有启用，则该属性的值将是192.168.1.100。

YAML缺点

YAML文件不能通过@PropertySource注解加载。所以，在这种情况下，如果需要使用@PropertySource注解的方式加载值，那就要使用properties文件。

4.7. 类型安全的配置属性

使用@Value("${property}")注解注入配置属性有时可能比较笨重，特别是需要使用多个properties或你的数据本身有层次结构。为了控制和校验你的应用配置，Spring Boot提供一个允许强类型beans的替代方法来使用properties。

示例：

1.  
   @Component
2.  
   @ConfigurationProperties(prefix="connection")
3.  
   public class ConnectionSettings {
4.  
   private String username;
5.  
   private InetAddress remoteAddress;
6.  
   // ... getters and setters
7.  
   }

当@EnableConfigurationProperties注解应用到你的@Configuration时，任何被@ConfigurationProperties注解的beans将自动被Environment属性配置。这种风格的配置特别适合与SpringApplication的外部YAML配置进行配合使用。

1.  
   # application.yml
2.  
   connection:
3.  
   username: admin
4.  
   remoteAddress: 192.168.1.1
5.  
   # additional configuration as required

为了使用@ConfigurationProperties beans，你可以使用与其他任何bean相同的方式注入它们。

1.  
   @Service
2.  
   public class MyService {
3.  
   @Autowired
4.  
   private ConnectionSettings connection;
5.  
   //...
6.  
   @PostConstruct
7.  
   public void openConnection() {
8.  
   Server server = new Server();
9.  
   this.connection.configure(server);
10.  
    }
11.  
    }

你可以通过在@EnableConfigurationProperties注解中直接简单的列出属性类来快捷的注册@ConfigurationProperties bean的定义。

1.  
   @Configuration
2.  
   @EnableConfigurationProperties(ConnectionSettings.class)
3.  
   public class MyConfiguration {
4.  
   }

注：使用@ConfigurationProperties能够产生可被IDEs使用的元数据文件。具体参考Appendix B, Configuration meta-data。

4.7.1. 第三方配置

正如使用@ConfigurationProperties注解一个类，你也可以在@Bean方法上使用它。当你需要绑定属性到不受你控制的第三方组件时，这种方式非常有用。

为了从Environment属性配置一个bean，将@ConfigurationProperties添加到它的bean注册过程：

1.  
   @ConfigurationProperties(prefix = "foo")
2.  
   @Bean
3.  
   public FooComponent fooComponent() {
4.  
   ...
5.  
   }

和上面ConnectionSettings的示例方式相同，任何以foo为前缀的属性定义都会被映射到FooComponent上。

4.7.2. 松散的绑定（Relaxed binding）

Spring Boot使用一些宽松的规则用于绑定Environment属性到@ConfigurationProperties beans，所以Environment属性名和bean属性名不需要精确匹配。常见的示例中有用的包括虚线分割（比如，context--path绑定到contextPath）和将环境属性转为大写字母（比如，PORT绑定port）。

示例：

1.  
   @Component
2.  
   @ConfigurationProperties(prefix="person")
3.  
   public class ConnectionSettings {
4.  
   private String firstName;
5.  
   }

下面的属性名都能用于上面的@ConfigurationProperties类：

1.  
   属性 说明
2.  
   person.firstName 标准驼峰规则
3.  
   person.first-name 虚线表示，推荐用于.properties和.yml文件中
4.  
   PERSON_FIRST_NAME 大写形式，使用系统环境变量时推荐

Spring会尝试强制外部的应用属性在绑定到@ConfigurationProperties beans时类型是正确的。如果需要自定义类型转换，你可以提供一个ConversionService bean（bean id为conversionService）或自定义属性编辑器（通过一个CustomEditorConfigurer bean）。

4.7.3. @ConfigurationProperties校验

Spring Boot将尝试校验外部的配置，默认使用JSR-303（如果在classpath路径中）。你可以轻松的为你的@ConfigurationProperties类添加JSR-303 javax.validation约束注解：

1.  
   @Component
2.  
   @ConfigurationProperties(prefix="connection")
3.  
   public class ConnectionSettings {
4.  
   @NotNull
5.  
   private InetAddress remoteAddress;
6.  
   // ... getters and setters
7.  
   }

你也可以通过创建一个叫做configurationPropertiesValidator的bean来添加自定义的Spring Validator。

注：spring-boot-actuator模块包含一个暴露所有@ConfigurationProperties beans的端点。

5 Profiles

Spring Profiles提供了一种隔离应用程序配置的方式，并让这些配置只能在特定的环境下生效。任何@Component或@Configuration都能被@Profile标记，从而限制加载它的时机。

1.  
   @Configuration
2.  
   @Profile("production")
3.  
   public class ProductionConfiguration {
4.  
   // ...
5.  
   }

以正常的Spring方式，你可以使用一个spring.profiles.active的Environment属性来指定哪个配置生效。你可以使用平常的任何方式来指定该属性，例如，可以将它包含到你的application.properties中：

1.  
   spring.profiles.active=dev,hsqldb
2.  
   或使用命令行开关：
3.  
    
4.  
   --spring.profiles.active=dev,hsqldb

5.1. 添加激活的配置(profiles)

spring.profiles.active属性和其他属性一样都遵循相同的排列规则，最高的PropertySource获胜。也就是说，你可以在application.properties中指定生效的配置，然后使用命令行开关替换它们。

有时，将特定的配置属性添加到生效的配置中而不是替换它们是有用的。spring.profiles.include属性可以用来无条件的添加生效的配置。SpringApplication的入口点也提供了一个用于设置额外配置的Java API（比如，在那些通过spring.profiles.active属性生效的配置之上）：参考setAdditionalProfiles()方法。

示例：当一个应用使用下面的属性，并用--spring.profiles.active=prod开关运行，那proddb和prodmq配置也会生效：

1.  
   ---
2.  
   my.property: fromyamlfile
3.  
   ---
4.  
   spring.profiles: prod
5.  
   spring.profiles.include: proddb,prodmq

注：spring.profiles属性可以定义到一个YAML文档中，用于决定什么时候该文档被包含进配置中。

5.2.以编程方式设置profiles

在应用运行前，你可以通过调用SpringApplication.setAdditionalProfiles(…)方法，以编程的方式设置生效的配置。使用Spring的ConfigurableEnvironment接口激动配置也是可行的。

5.3. Profile特定配置文件

application.properties（或application.yml）和通过@ConfigurationProperties引用的文件这两种配置特定变种都被当作文件来加载的，具体参考Section 23.3, “Profile specific properties”。

6 日志

Spring Boot内部日志系统使用的是Commons Logging，但开放底层的日志实现。默认为会Java Util Logging, Log4J, Log4J2和Logback提供配置。每种情况下都会预先配置使用控制台输出，也可以使用可选的文件输出。

默认情况下，如果你使用'Starter POMs'，那么就会使用Logback记录日志。为了确保那些使用Java Util Logging, Commons Logging, Log4J或SLF4J的依赖库能够正常工作，正确的Logback路由也被包含进来。

注：如果上面的列表看起来令人困惑，不要担心，Java有很多可用的日志框架。通常，你不需要改变日志依赖，Spring Boot默认的就能很好的工作。

6.1. 日志格式

Spring Boot默认的日志输出格式如下：

1.  
   2014-03-05 10:57:51.112 INFO 45469 --- [ main] org.apache.catalina.core.StandardEngine : Starting Servlet Engine: Apache Tomcat/7.0.52
2.  
   2014-03-05 10:57:51.253 INFO 45469 --- [ost-startStop-1] o.a.c.c.C.[Tomcat].[localhost].[/] : Initializing Spring embedded WebApplicationContext
3.  
   2014-03-05 10:57:51.253 INFO 45469 --- [ost-startStop-1] o.s.web.context.ContextLoader : Root WebApplicationContext: initialization completed in 1358 ms
4.  
   2014-03-05 10:57:51.698 INFO 45469 --- [ost-startStop-1] o.s.b.c.e.ServletRegistrationBean : Mapping servlet: 'dispatcherServlet' to [/]
5.  
   2014-03-05 10:57:51.702 INFO 45469 --- [ost-startStop-1] o.s.b.c.embedded.FilterRegistrationBean : Mapping filter: 'hiddenHttpMethodFilter' to: [/*]
6.  
    

输出的节点（items）如下：

1.  
   日期和时间 - 精确到毫秒，且易于排序。
2.  
   日志级别 - ERROR, WARN, INFO, DEBUG 或 TRACE。
3.  
   Process ID。
4.  
   一个用于区分实际日志信息开头的---分隔符。
5.  
   线程名 - 包括在方括号中（控制台输出可能会被截断）。
6.  
   日志名 - 通常是源class的类名（缩写）。
7.  
   日志信息。

5.2. 控制台输出

默认的日志配置会在写日志消息时将它们回显到控制台。默认，ERROR, WARN和INFO级别的消息会被记录。可以在启动应用时，通过--debug标识开启控制台的DEBUG级别日志记录。

 java -jar myapp.jar --debug

如果你的终端支持ANSI，为了增加可读性将会使用彩色的日志输出。你可以设置spring.output.ansi.enabled为一个支持的值来覆盖自动检测。

5.3. 文件输出

默认情况下，Spring Boot只会将日志记录到控制台而不会写进日志文件。如果除了输出到控制台你还想写入到日志文件，那你需要设置logging.file或logging.path属性（例如在你的application.properties中）。

下表显示如何组合使用logging.*：

1.  
   logging.file logging.path 示例 描述
2.  
   (none) (none) 只记录到控制台
3.  
   Specific file (none) my.log 写到特定的日志文件里，名称可以是一个精确的位置或相对于当前目录
4.  
   (none) Specific folder /var/log 写到特定文件夹下的spring.log里，名称可以是一个精确的位置或相对于当前目录

日志文件每达到10M就会被轮换（分割），和控制台一样，默认记录ERROR, WARN和INFO级别的信息。

5.4. 日志级别

所有支持的日志系统在Spring的Environment（例如在application.properties里）都有通过'logging.level.*=LEVEL'（'LEVEL'是TRACE, DEBUG, INFO, WARN, ERROR, FATAL, OFF中的一个）设置的日志级别。

示例：application.properties

1.  
   logging.level.org.springframework.web: DEBUG
2.  
   logging.level.org.hibernate: ERROR

5.5. 自定义日志配置

通过将适当的库添加到classpath，可以激活各种日志系统。然后在classpath的根目录(root)或通过Spring Environment的logging.config属性指定的位置提供一个合适的配置文件来达到进一步的定制（注意由于日志是在ApplicationContext被创建之前初始化的，所以不可能在Spring的@Configuration文件中，通过@PropertySources控制日志。系统属性和平常的Spring Boot外部配置文件能正常工作）。

根据你的日志系统，下面的文件会被加载：

1.  
   日志系统 定制
2.  
   Logback logback.xml
3.  
   Log4j log4j.properties或log4j.xml
4.  
   Log4j2 log4j2.xml
5.  
   JDK (Java Util Logging) logging.properties

为了帮助定制一些其他的属性，从Spring的Envrionment转换到系统属性：

1.  
   Spring Environment System Property 评价
2.  
   logging.file LOG_FILE 如果定义，在默认的日志配置中使用
3.  
   logging.path LOG_PATH 如果定义，在默认的日志配置中使用
4.  
   PID PID 当前的处理进程(process)ID（如果能够被发现且还没有作为操作系统环境变量被定义）

所有支持的日志系统在解析它们的配置文件时都能查询系统属性。具体可以参考spring-boot.jar中的默认配置。

注：在运行可执行的jar时，Java Util Logging有类加载问题，我们建议你尽可能避免使用它。

6 开发Web应用

Spring Boot非常适合开发web应用程序。你可以使用内嵌的Tomcat，Jetty或Undertow轻轻松松地创建一个HTTP服务器。大多数的web应用都使用spring-boot-starter-web模块进行快速搭建和运行。

6.1. Spring Web MVC框架

Spring Web MVC框架（通常简称为"Spring MVC"）是一个富"模型，视图，控制器"的web框架。 Spring MVC允许你创建特定的@Controller或@RestController beans来处理传入的HTTP请求。 使用@RequestMapping注解可以将控制器中的方法映射到相应的HTTP请求。

示例：

1.  
   @RestController
2.  
   @RequestMapping(value="/users")
3.  
   public class MyRestController {
4.  
    
5.  
   @RequestMapping(value="/{user}", method=RequestMethod.GET)
6.  
   public User getUser(@PathVariable Long user) {
7.  
   // ...
8.  
   }
9.  
    
10.  
    @RequestMapping(value="/{user}/customers", method=RequestMethod.GET)
11.  
    List<Customer> getUserCustomers(@PathVariable Long user) {
12.  
    // ...
13.  
    }
14.  
     
15.  
    @RequestMapping(value="/{user}", method=RequestMethod.DELETE)
16.  
    public User deleteUser(@PathVariable Long user) {
17.  
    // ...
18.  
    }
19.  
    }

6.1.1. Spring MVC自动配置

Spring Boot为Spring MVC提供适用于多数应用的自动配置功能。在Spring默认基础上，自动配置添加了以下特性：

1.  
   引入ContentNegotiatingViewResolver和BeanNameViewResolver beans。
2.  
   对静态资源的支持，包括对WebJars的支持。
3.  
   自动注册Converter，GenericConverter，Formatter beans。
4.  
   对HttpMessageConverters的支持。
5.  
   自动注册MessageCodeResolver。
6.  
   对静态index.html的支持。
7.  
   对自定义Favicon的支持。

如果想全面控制Spring MVC，你可以添加自己的@Configuration，并使用@EnableWebMvc对其注解。如果想保留Spring Boot MVC的特性，并只是添加其他的MVC配置(拦截器，formatters，视图控制器等)，你可以添加自己的WebMvcConfigurerAdapter类型的@Bean（不使用@EnableWebMvc注解）。

6.1.2. HttpMessageConverters

Spring MVC使用HttpMessageConverter接口转换HTTP请求和响应。合理的缺省值被包含的恰到好处（out of the box），例如对象可以自动转换为JSON（使用Jackson库）或XML（如果Jackson XML扩展可用则使用它，否则使用JAXB）。字符串默认使用UTF-8编码。

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

1.  
   import org.springframework.boot.autoconfigure.web.HttpMessageConverters;
2.  
   import org.springframework.context.annotation.*;
3.  
   import org.springframework.http.converter.*;
4.  
    
5.  
   @Configuration
6.  
   public class MyConfiguration {
7.  
    
8.  
   @Bean
9.  
   public HttpMessageConverters customConverters() {
10.  
    HttpMessageConverter<?> additional = ...
11.  
    HttpMessageConverter<?> another = ...
12.  
    return new HttpMessageConverters(additional, another);
13.  
    }
14.  
    }

任何在上下文中出现的HttpMessageConverter bean将会添加到converters列表，你可以通过这种方式覆盖默认的转换器（converters）。

6.1.3. MessageCodesResolver

Spring MVC有一个策略，用于从绑定的errors产生用来渲染错误信息的错误码：MessageCodesResolver。如果设置spring.mvc.message-codes-resolver.format属性为PREFIXERRORCODE或POSTFIXERRORCODE（具体查看DefaultMessageCodesResolver.Format枚举值），Spring Boot会为你创建一个MessageCodesResolver。

6.1.4. 静态内容

默认情况下，Spring Boot从classpath下一个叫/static（/public，/resources或/META-INF/resources）的文件夹或从ServletContext根目录提供静态内容。这使用了Spring MVC的ResourceHttpRequestHandler，所以你可以通过添加自己的WebMvcConfigurerAdapter并覆写addResourceHandlers方法来改变这个行为（加载静态文件）。

在一个单独的web应用中，容器默认的servlet是开启的，如果Spring决定不处理某些请求，默认的servlet作为一个回退（降级）将从ServletContext根目录加载内容。大多数时候，这不会发生（除非你修改默认的MVC配置），因为Spring总能够通过DispatcherServlet处理请求。

此外，上述标准的静态资源位置有个例外情况是Webjars内容。任何在/webjars/**路径下的资源都将从jar文件中提供，只要它们以Webjars的格式打包。

注：如果你的应用将被打包成jar，那就不要使用src/main/webapp文件夹。尽管该文件夹是一个共同的标准，但它仅在打包成war的情况下起作用，并且如果产生一个jar，多数构建工具都会静悄悄的忽略它。

6.1.5. 模板引擎

正如REST web服务，你也可以使用Spring MVC提供动态HTML内容。Spring MVC支持各种各样的模板技术，包括Velocity, FreeMarker和JSPs。很多其他的模板引擎也提供它们自己的Spring MVC集成。

Spring Boot为以下的模板引擎提供自动配置支持：

1.  
   FreeMarker
2.  
   Groovy
3.  
   Thymeleaf
4.  
   Velocity

注：如果可能的话，应该忽略JSPs，因为在内嵌的servlet容器使用它们时存在一些已知的限制。

当你使用这些引擎的任何一种，并采用默认的配置，你的模板将会从src/main/resources/templates目录下自动加载。

注：IntelliJ IDEA根据你运行应用的方式会对classpath进行不同的整理。在IDE里通过main方法运行你的应用跟从Maven或Gradle或打包好的jar中运行相比会导致不同的顺序。这可能导致Spring Boot不能从classpath下成功地找到模板。如果遇到这个问题，你可以在IDE里重新对classpath进行排序，将模块的类和资源放到第一位。或者，你可以配置模块的前缀为classpath*:/templates/，这样会查找classpath下的所有模板目录。

6.1.6. 错误处理

Spring Boot默认提供一个/error映射用来以合适的方式处理所有的错误，并且它在servlet容器中注册了一个全局的 错误页面。对于机器客户端（相对于浏览器而言，浏览器偏重于人的行为），它会产生一个具有详细错误，HTTP状态，异常信息的JSON响应。对于浏览器客户端，它会产生一个白色标签样式（whitelabel）的错误视图，该视图将以HTML格式显示同样的数据（可以添加一个解析为erro的View来自定义它）。为了完全替换默认的行为，你可以实现ErrorController，并注册一个该类型的bean定义，或简单地添加一个ErrorAttributes类型的bean以使用现存的机制，只是替换显示的内容。

如果在某些条件下需要比较多的错误页面，内嵌的servlet容器提供了一个统一的Java DSL（领域特定语言）来自定义错误处理。 示例：

1.  
   @Bean
2.  
   public EmbeddedServletContainerCustomizer containerCustomizer(){
3.  
   return new MyCustomizer();
4.  
   }
5.  
    
6.  
   // ...
7.  
   private static class MyCustomizer implements EmbeddedServletContainerCustomizer {
8.  
   @Override
9.  
   public void customize(ConfigurableEmbeddedServletContainer container) {
10.  
    container.addErrorPages(new ErrorPage(HttpStatus.BAD_REQUEST, "/400"));
11.  
    }
12.  
    }

你也可以使用常规的Spring MVC特性来处理错误，比如@ExceptionHandler方法和@ControllerAdvice。ErrorController将会捡起任何没有处理的异常。

N.B. 如果你为一个路径注册一个ErrorPage，最终被一个过滤器（Filter）处理（对于一些非Spring web框架，像Jersey和Wicket这很常见），然后过滤器需要显式注册为一个ERROR分发器（dispatcher）。

1.  
   @Bean
2.  
   public FilterRegistrationBean myFilter() {
3.  
   FilterRegistrationBean registration = new FilterRegistrationBean();
4.  
   registration.setFilter(new MyFilter());
5.  
   ...
6.  
   registration.setDispatcherTypes(EnumSet.allOf(DispatcherType.class));
7.  
   return registration;
8.  
   }

注：默认的FilterRegistrationBean没有包含ERROR分发器类型。

6.1.7. Spring HATEOAS

如果你正在开发一个使用超媒体的RESTful API，Spring Boot将为Spring HATEOAS提供自动配置，这在多数应用中都工作良好。自动配置替换了对使用@EnableHypermediaSupport的需求，并注册一定数量的beans来简化构建基于超媒体的应用，这些beans包括一个LinkDiscoverer和配置好的用于将响应正确编排为想要的表示的ObjectMapper。ObjectMapper可以根据spring.jackson.*属性或一个存在的Jackson2ObjectMapperBuilder bean进行自定义。

通过使用@EnableHypermediaSupport，你可以控制Spring HATEOAS的配置。注意这会禁用上述的对ObjectMapper的自定义。

6.2. JAX-RS和Jersey

如果喜欢JAX-RS为REST端点提供的编程模型，你可以使用可用的实现替代Spring MVC。如果在你的应用上下文中将Jersey 1.x和Apache Celtix的Servlet或Filter注册为一个@Bean，那它们工作的相当好。Jersey 2.x有一些原生的Spring支持，所以我们会在Spring Boot为它提供自动配置支持，连同一个启动器（starter）。

想要开始使用Jersey 2.x只需要加入spring-boot-starter-jersey依赖，然后你需要一个ResourceConfig类型的@Bean，用于注册所有的端点（endpoints）。

1.  
   @Component
2.  
   public class JerseyConfig extends ResourceConfig {
3.  
   public JerseyConfig() {
4.  
   register(Endpoint.class);
5.  
   }
6.  
   }

所有注册的端点都应该被@Components和HTTP资源annotations（比如@GET）注解。

1.  
   @Component
2.  
   @Path("/hello")
3.  
   public class Endpoint {
4.  
   @GET
5.  
   public String message() {
6.  
   return "Hello";
7.  
   }
8.  
   }

由于Endpoint是一个Spring组件（@Component），所以它的生命周期受Spring管理，并且你可以使用@Autowired添加依赖及使用@Value注入外部配置。Jersey servlet将被注册，并默认映射到/*。你可以将@ApplicationPath添加到ResourceConfig来改变该映射。

默认情况下，Jersey将在一个ServletRegistrationBean类型的@Bean中被设置成名称为jerseyServletRegistration的Servlet。通过创建自己的相同名称的bean，你可以禁止或覆盖这个bean。你也可以通过设置spring.jersey.type=filter来使用一个Filter代替Servlet（在这种情况下，被覆盖或替换的@Bean是jerseyFilterRegistration）。该servlet有@Order属性，你可以通过spring.jersey.filter.order进行设置。不管是Servlet还是Filter注册都可以使用spring.jersey.init.*定义一个属性集合作为初始化参数传递过去。

这里有一个Jersey示例，你可以查看如何设置相关事项。

6.3. 内嵌servlet容器支持

Spring Boot支持内嵌的Tomcat, Jetty和Undertow服务器。多数开发者只需要使用合适的'Starter POM'来获取一个完全配置好的实例即可。默认情况下，内嵌的服务器会在8080端口监听HTTP请求。

6.3.1. Servlets和Filters

当使用内嵌的servlet容器时，你可以直接将servlet和filter注册为Spring的beans。在配置期间，如果你想引用来自application.properties的值，这是非常方便的。默认情况下，如果上下文只包含单一的Servlet，那它将被映射到根路径（/）。在多Servlet beans的情况下，bean的名称将被用作路径的前缀。过滤器会被映射到/*。

如果基于约定（convention-based）的映射不够灵活，你可以使用ServletRegistrationBean和FilterRegistrationBean类实现完全的控制。如果你的bean实现了ServletContextInitializer接口，也可以直接注册它们。

6.3.2. EmbeddedWebApplicationContext

Spring Boot底层使用了一个新的ApplicationContext类型，用于对内嵌servlet容器的支持。EmbeddedWebApplicationContext是一个特殊类型的WebApplicationContext，它通过搜索一个单一的EmbeddedServletContainerFactory bean来启动自己。通常，TomcatEmbeddedServletContainerFactory，JettyEmbeddedServletContainerFactory或UndertowEmbeddedServletContainerFactory将被自动配置。

注：你通常不需要知道这些实现类。大多数应用将被自动配置，并根据你的行为创建合适的ApplicationContext和EmbeddedServletContainerFactory。

6.3.3. 自定义内嵌servlet容器

常见的Servlet容器设置可以通过Spring Environment属性进行配置。通常，你会把这些属性定义到application.properties文件中。 常见的服务器设置包括：

1.  
   server.port - 进来的HTTP请求的监听端口号
2.  
   server.address - 绑定的接口地址
3.  
   server.sessionTimeout - session超时时间

具体参考ServerProperties。

编程方式的自定义 如果需要以编程的方式配置内嵌的servlet容器，你可以注册一个实现EmbeddedServletContainerCustomizer接口的Spring bean。EmbeddedServletContainerCustomizer提供对ConfigurableEmbeddedServletContainer的访问，ConfigurableEmbeddedServletContainer包含很多自定义的setter方法。

1.  
   import org.springframework.boot.context.embedded.*;
2.  
   import org.springframework.stereotype.Component;
3.  
    
4.  
   @Component
5.  
   public class CustomizationBean implements EmbeddedServletContainerCustomizer {
6.  
   @Override
7.  
   public void customize(ConfigurableEmbeddedServletContainer container) {
8.  
   container.setPort(9000);
9.  
   }
10.  
    }

直接自定义ConfigurableEmbeddedServletContainer 如果上面的自定义手法过于受限，你可以自己注册TomcatEmbeddedServletContainerFactory，JettyEmbeddedServletContainerFactory或UndertowEmbeddedServletContainerFactory。

1.  
   @Bean
2.  
   public EmbeddedServletContainerFactory servletContainer() {
3.  
   TomcatEmbeddedServletContainerFactory factory = new TomcatEmbeddedServletContainerFactory();
4.  
   factory.setPort(9000);
5.  
   factory.setSessionTimeout(10, TimeUnit.MINUTES);
6.  
   factory.addErrorPages(new ErrorPage(HttpStatus.NOT_FOUND, "/notfound.html");
7.  
   return factory;
8.  
   }

很多可选的配置都提供了setter方法，也提供了一些受保护的钩子方法以满足你的某些特殊需求。具体参考相关文档。

6.3.4. JSP的限制

在内嵌的servlet容器中运行一个Spring Boot应用时（并打包成一个可执行的存档archive），容器对JSP的支持有一些限制。

1.  
   tomcat只支持war的打包方式，不支持可执行的jar。
2.  
   内嵌的Jetty目前不支持JSPs。
3.  
   Undertow不支持JSPs。

这里有个JSP示例，你可以查看如何设置相关事项。