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示例,你可以查看如何设置相关事项。

posted @ 2018-07-14 11:42  杨柳春色  阅读(197)  评论(0编辑  收藏  举报