Spring Boot 框架介绍和使用

摘要：使用还是，根据个人喜好即可。如果错误页面也需要使用模板引擎动态生成，那么放在下面的路径。数据库自动配置嵌入式数据库如果类路径中包含或的相应包，那么就会自动配置这些嵌入式数据库的实例和数据源。

本文参考自Spring Boot文档。

Spring框架功能很强大，但是就算是一个很简单的项目，我们也要配置很多东西。因此就有了Spring Boot框架，它的作用很简单，就是帮我们自动配置。Spring Boot框架的核心就是自动配置，只要存在相应的jar包，Spring就帮我们自动配置。如果默认配置不能满足需求，我们还可以替换掉自动配置类，使用我们自己的配置。另外，Spring Boot还集成了嵌入式的Web服务器，系统监控等很多有用的功，让我们快速构建企业及应用程序。

创建项目很简单。如果使用STS的话，新建Spring Starter项目即可。如果使用IDEA的话，新建Spring Initializer项目。如果不想使用IDE的话，从start.spring.io创建项目也可以。例如下面就是一个Spring Boot项目的build.gradle文件，是我用IDEA创建的项目。由于我是用了最新的快照版本，因此这里的仓库还多了两个Spring的快找仓库，可以直接无视。（因为1.5的稳定版中Thymeleaf的支持才到2，为了使用最新Thymeleaf3，只能使用最新的快照版。）

我们可以看到Spring Boot和一般的项目差不多，只不过多应用了Spring Boot插件，它会让我们更方便的运行Spring。另外在项目中没有其他依赖的引用，只引用了Spring Boot Starter依赖，这些依赖会将可能会使用到的依赖帮我们引用。例如spring-boot-starter-test会引用JUnit、AssertJ等一些测试框架，我们不用再引用了。这极大地方便了我们的开发。而且这些依赖不需要指定具体版本，具体的版本由Spring帮我们决定。关于详细的Starter项目和具体jar包的版本号，参考13.5. Starters和F. Dependency versions。

buildscript {
    ext {
        springBootVersion = "2.0.0.BUILD-SNAPSHOT"
    }
    repositories {
        mavenCentral()
        maven { url "https://repo.spring.io/snapshot" }
        maven { url "https://repo.spring.io/milestone" }
    }
    dependencies {
        classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
    }
}

apply plugin: "java"
apply plugin: "eclipse"
apply plugin: "org.springframework.boot"

jar {
    baseName = "spring-boot-sample"
    version = "0.0.1-SNAPSHOT"
}

sourceCompatibility = 1.8

repositories {
    mavenCentral()
    maven { url "https://repo.spring.io/snapshot" }
    maven { url "https://repo.spring.io/milestone" }
}


dependencies {
    compile("org.springframework.boot:spring-boot-starter-aop")
    compile("org.springframework.boot:spring-boot-starter-data-jpa")
    compile("org.springframework.boot:spring-boot-starter-thymeleaf")
    compile("org.springframework.boot:spring-boot-starter-web")
    runtime("org.springframework.boot:spring-boot-devtools")
    runtime("org.hsqldb:hsqldb")
    runtime("mysql:mysql-connector-java")
    compileOnly("org.projectlombok:lombok")
    testCompile("org.springframework.boot:spring-boot-starter-test")
}

项目格式类似下图，和一般的Maven或者Gradle项目类似，只不过多了点东西。资源文件夹下static文件夹用来存放web程序的静态资源，例如图片、css、js等。template文件夹存放web程序的视图模板，html等需要渲染的模板文件就放在这里。application.properties文件很重要，它是Spring Boot项目的全局配置文件。以往我们需要编写层级XML配置文件，现在只需要在这里使用key=value方式即可指定这些属性。默认的模板还为我们添加了两个类。一个在main下，是Spring Boot项目的运行类，另一个在test下，是测试类。

运行类的代码如下。它是一个简单的类，包含了主方法，而且类上使用了@SpringBootApplication注解。这是一个惯用注解，它会帮我们启用自动配置等特性。

@SpringBootApplication
public class SpringBootSampleApplication {

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

如果看一下SpringBootApplication的源代码，类似下面这样。可以看到，SpringBootApplication的功能是通过几个注解实现的。EnableAutoConfiguration注解启用了自动配置功能。ComponentScan注解会扫描该类所在的包和子包。所以Spring推荐我们将这个运行类放到项目的根包下，以便我们不需要任何配置即可扫描到所有配置类。

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = {
        @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
        @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {

Spring Boot项目更喜欢Java配置方式。因此从这里开始，所有的Spring配置都是用Java方式配置。当然如果你还想使用XML配置文件也可以，新建一个空的配置类，然后添加@ImportResource注解并传递要使用的XML文件路径即可。

如果使用Maven的话，运行下面的命令。

mvn spring-boot:run

如果使用Gradle的话，使用下面的命令。

gradle bootRun

然后就会显示类似下面的输出，后面会跟一大堆日志信息。如果是命令行程序的话，日志信息之后就会显示程序的运行结果了。如果是Web程序的话，默认情况下会使用内嵌的Tomcat来运行。我们使用localhost:8080来访问即可。

  .   ____          _            __ _ _
 / / ___"_ __ _ _(_)_ __  __ _    
( ( )\___ | "_ | "_| | "_ / _` |    
 /  ___)| |_)| | | | | || (_| |  ) ) ) )
  "  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::  (v2.0.0.BUILD-SNAPSHOT)

这个日志可以是彩色的。如果你的输出不是彩色的，可以在application.properties文件中添加下面一句。

spring.output.ansi.enabled=always

前面我们看到了SpringBoot项目的启动类是这样的。

@SpringBootApplication()
public class SpringBootSampleApplication {

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

其实，我们可以自定义它的各种属性。这时候需要创建SpringApplication对象并设置它的各种属性。比方说下面不显示Banner。还有很多配置和用法请查阅官方文档。

@SpringBootApplication()
public class SpringBootSampleApplication {

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

如果有更高级的需求可以使用监听器来管理Spring Boot程序的各个生命周期。监听器需要实现org.springframework.context.ApplicationListener接口。

public class MyAppListener implements ApplicationListener {


    @Override
    public void onApplicationEvent(ApplicationReadyEvent event) {
        System.out.println("应用程序准备就绪");
    }
}

在监听器中可以设置下面几种事件。

ApplicationStartingEvent

ApplicationEnvironmentPreparedEvent

ApplicationPreparedEvent

ApplicationReadyEvent

ApplicationFailedEvent

之后，把监听器添加到Spring程序中。

@SpringBootApplication()
public class SpringBootSampleApplication {

    public static void main(String[] args) {
        SpringApplication application = new SpringApplication(SpringBootSampleApplication.class);
        application.setBannerMode(Banner.Mode.OFF);
        application.addListeners(new MyAppListener());
        application.run(args);
    }
}

在Spring Boot中Profiles更简单了。我们使用application-{profile}.properties格式来区分不同的Profile，例如一个测试profile（application-test.properties），一个生产环境profile（application-product.properties）。

定义好多个Profiles之后，还需要在标准的application.properties中列出和启用这些Profiles。列出使用spring.profiles.include，激活其中的一个使用spring.profiles.active。

spring.output.ansi.enabled=always
spring.thymeleaf.cache=false
spring.profiles.include[0]=test
spring.profiles.include[1]=product
spring.profiles.active[0]=test

YAML也是一种配置文件格式，比方说上面的properties，就可以改写为下面这样的YAML文件（application.yaml）。

spring:
  output:
    ansi:
      enabled: always
  thymeleaf:
    cache: false
  profiles:
    include:
    - product
    - test
    active: test

如果需要多个Profile，YAML只需要一个文件即可，profiles之间使用---分隔开。

server:
    address: 192.168.1.100
---
spring:
    profiles: development
server:
    address: 127.0.0.1
---
spring:
    profiles: production
server:
    address: 192.168.1.120

使用Properties还是YAML，根据个人喜好即可。

Spring Boot的核心就是自动配置，它为几乎所有的Spring组件都提供了相应的自动配置类，而且默认是打开的。所以只要相关的jar文件存在，这些自动配置就会被使用。其中有些配置属于必配的（例如Web模板），自动配置会为我们省下不少时间；有些配置（例如数据源）则往往需要我们修改。Spring的自动配置是非侵入式的，所以如果我们声明了自己的数据源，那么Spring自动配置的嵌入式数据源就会取消。

当然如果想要关闭某些自动配置也是可以的。如果你有自己的主配置类，手动在上排除某些自动配置类即可。

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

如果我们使用了SpringBootApplication注解，那么上面这种方式需要修改一下。SpringBootApplication注解提供了几个属性，可以控制排除的自动配置和组件搜索的路径。

@SpringBootApplication(exclude = {DataSourceAutoConfiguration.class})
public class SpringBootSampleApplication {

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

另外还可以直接修改项目的属性。我们可以编辑application.properties文件，在其中添加spring.autoconfigure.exclude属性并指定要排除的类即可。

Spring的自动配置类一般在org.springframework.boot.autoconfigure包下，如果我们需要查看当前使用了多少个自动配置类，可以在运行程序的时候添加--debug标志，这样Spring会打印额外的调试信息。如果需要详细的自动配置类的列表，可以参考Spring Boot文档 附录C. Auto-configuration classes。

MVC自动配置会启用以下功能。

ContentNegotiatingViewResolver 和 BeanNameViewResolver beans.

静态资源和WebJars的支持.

自动注册 Converter, GenericConverter, Formatter beans.

HttpMessageConverters 的支持.

自动注册MessageCodesResolver.

静态index.html的支持.

自定义Favicon（浏览器页面的小图标） 支持.

自动使用ConfigurableWebBindingInitializer bean.

自动注册指的是，只需要在Spring中注册相应类型的Bean。Spring Web MVC会自动识别和使用这些Bean。例如，我们要添加新的HttpMessageConverter，只需要向下面这样。

@Configuration
public class MyConfiguration {

    @Bean
    public HttpMessageConverters customConverters() {
        HttpMessageConverter additional = ...
        HttpMessageConverter another = ...
        return new HttpMessageConverters(additional, another);
    }

}

静态资源默认放在resources文件夹的/static (或 /public或 /resources 或/META-INF/resources下面。如果需要配置位置的话，在属性文件中添加spring.mvc.static-path-pattern=/resources/**。

如果需要静态主页，直接在resources/static/下放入一个index.html即可。

如果需要配置自己的favicon.ico，只需要将自己的favicon.ico直接放到resources文件夹下即可。

Spring会对Thymeleaf、Freemarker、Groovy和mustache四种模板进行自动配置。默认的模板路径为resources/templates。

错误处理和一般的Spring Web MVC类似，使用@ControllerAdvice。

自定义错误页面放在下面的路径。

src/
 +- main/
     +- java/
     |   + 
     +- resources/
         +- public/
             +- error/
             |   +- 404.html
             +- 

如果错误页面也需要使用模板引擎动态生成，那么放在下面的路径。

src/
 +- main/
     +- java/
     |   + 
     +- resources/
         +- templates/
             +- error/
             |   +- 5xx.ftl
             +- 

如果类路径中包含HSQL、Derby或H2的相应jar包，那么Spring就会自动配置这些嵌入式数据库的实例和数据源。它们会将数据保存在内存中，当程序结束之后数据会丢失。这非常适合开发和测试。

在不同的测试中Spring默认会重用这些嵌入式数据库。假如不同测试之间的数据不同，你可能希望每次测试都使用新的数据库。这时候可以在属性文件中指定spring.datasource.generate-unique-name=true。

Spring会自动选择带连接池的数据源，遵循以下规则：

如果存在tomcat-jdbc数据源，则使用它。

否则，如果存在HikariCP，则使用它。

如果前两个都不存在，而存在DBCP2，则使用它。

这时候我们需要提供数据源的额外配置信息。

spring.datasource.url=jdbc:mysql://localhost/test
spring.datasource.username=dbuser
spring.datasource.password=dbpass
spring.datasource.driver-class-name=com.mysql.jdbc.Driver

JdbcTemplate和NamedParameterJdbcTemplate会由上面的数据源自动配置。我们直接使用@Autowire注入到程序中即可。

JPA Entity类（标记了@Entity的类）默认在persistence.xml中配置。在Spring Boot中，@EnableAutoConfiguration 或 @SpringBootApplication包下的实体类会被自动扫描到。如果希望自定义实体类的位置，可以使用@EntityScan注解，添加到配置类上即可。

继承了 Repository的接口会被自动扫描到，我们不需要做任何配置。如果需要配置，设置spring.jpa.*属性。例如下面指定了数据的生成策略。

spring.jpa.hibernate.ddl-auto=update

H2嵌入式数据库提供了一个基于web界面的控制台。这个控制台也可以由Spring自动配置。当（1:存在H2相关jar包，2:当前程序是一个web程序，3:devtoos存在）的情况下，Spring便会自动配置H2控制台。

web控制台的访问路径默认为/h2-console。我们可以使用spring.h2.console.path属性修改它。

如图，这是一个完整的交互界面，我们可以方便的在这里处理数据。如果需要设置访问控制权限，添加下面的属性。

security.user.role

security.basic.authorize-mode

security.basic.enabled

如果不想使用该控制台，可以使用spring.h2.console.enabled=false关闭它。在生产环境中记得把它关掉。

最后我要说一点，Spring Boot文档包含了很多其他Spring项目的自动配置，这里不可能全写完。所以如果需要详细信息的话还是直接啃文档吧。

如果使用Maven，添加下面的依赖。

    
        org.springframework.boot
        spring-boot-devtools
        true
    

如果使用Gradle，添加下面的依赖。

dependencies {
    compile("org.springframework.boot:spring-boot-devtools")
}

这样就可以将调试工具添加到项目中。调试工具添加了热更新、自动重启等几个非常有用的调试功能。自动重启需要Spring检测到类路径上有更改，在Spring Tool Suite中，简单的保存文件即可达到效果。如果在Intellij IDEA中，只能选择Build Project。

Spring Boot默认使用Logback来打印日志。不过我们直接使用slf4j提供的接口就可以了。slf4j和Logback也都由Spring自动配置好了。我们只需要在属性文件中设置日志级别即可。

logging.level.yitian.study=debug

然后在代码中调用slf4j的日志接口并打印日志即可。

@Controller
public class MainController {
    private Logger logger = LoggerFactory.getLogger(MainController.class);

    @RequestMapping("/")
    public String index(@RequestParam(defaultValue = "苟") String name, Model model) {
        model.addAttribute("name", name);
        logger.debug("访问了主页");
        return "index";
    }
}

日志信息和Spring的输出格式一样。另外随着日志级别的变化，日志的颜色也会在绿、黄和红之间变化，非常方便。

2017-03-16 23:50:19.628  INFO 17220 --- [nio-8080-exec-1] o.s.web.servlet.DispatcherServlet        : FrameworkServlet "dispatcherServlet": initialization completed in 4 ms
2017-03-16 23:50:19.632 ERROR 17220 --- [nio-8080-exec-1] yitian.study.controller.MainController   : 访问了主页

这个Banner也是可以定制的。在类路径（也就是resource文件夹下）添加banner.txt，Banner就会使用你的文本。Banner甚至可以是一张图片，支持gif、jpg、png等格式。Spring会将图片转换成字符形式。

默认情况下Spring使用Tomcat作为嵌入式容器。

端口号使用server.port设置。如果希望在运行时随机分配一个未使用的端口号，可以将端口号设置为0：server.port=0。

spring-boot-starter-web包默认使用Tomcat，如果我们希望使用Jetty，就需要排除Tomcat的包。使用Maven的话，这么做。

    org.springframework.boot
    spring-boot-starter-web
    
        
            org.springframework.boot
            spring-boot-starter-tomcat
        
    


    org.springframework.boot
    spring-boot-starter-jetty

如果使用Gradle的话，这么做。

configurations {
    compile.exclude module: "spring-boot-starter-tomcat"
}

dependencies {
    compile("org.springframework.boot:spring-boot-starter-web:2.0.0.BUILD-SNAPSHOT")
    compile("org.springframework.boot:spring-boot-starter-jetty:2.0.0.BUILD-SNAPSHOT")
    // ...
}

使用server.compression.enabled=true启用HTTP的响应压缩。默认情况下要压缩的响应体至少需要2048字节，可以使用server.compression.min-response-size修改这个值。

Spring Boot项目默认打包为jar文件。我们可以使用Maven或Gradle的打包命令来打包项目。打包好之后，就可以和一般jar文件一样，使用java命令来运行了。如果希望打包为war文件的话也可以，不过由于篇幅所限就不介绍了。直接看源文档吧。

Actuator我没理解怎么翻译，所以凭我的感觉就叫做系统监控吧。这些功能可以帮助我们监控正在运行的Spring Boot项目。要启用监控功能，需要添加spring-boot-starter-actuator。使用Maven的话，添加下面的依赖。

    
        org.springframework.boot
        spring-boot-starter-actuator
    

如果使用Gradle的话，添加下面的依赖。

dependencies {
    compile("org.springframework.boot:spring-boot-starter-actuator")
}

每个端点就是一个监控项。Spring包含了很多端点，详细列表在这里47. Endpoints。除了health之外，其余端点都属于敏感信息，在没有设置Spring Security的情况下无法访问。为了简单的在本地访问，我们可以设置management.security.enabled=false。注意该选项在生产环境中务必打开，保证服务器信息不会泄露。

端点的访问路径默认是/端点名，例如health的访问路径就是/health。比较有用的几个端点是beans（列出当前所有已注册的Spring Beans）、mappings（所有的控制器映射路径）、trace（最近100个HTTP连接的信息）、health（服务器当前的运行状态和磁盘剩余空间以及数据库的运行状态）。还有一个有趣的端点是shutdown，当我们向/shutdown发送post请求时服务器就会关闭，不过该功能是默认关闭的。

端点可以在属性文件中设置，每个端点敏感性和是否启用都是可以定制的。

endpoints.beans.sensitive=false
endpoints.shutdown.enabled=true

端点的访问也是可以定制的。

management.port=8081
management.address=127.0.0.1

好了，Spring Boot框架的介绍到此为止。我们已经基本看到了Spring Boto的使用方法。当然官方文档还有很多内容这里没有列出。这里也不可能完全列出来。如果需要更详细的介绍还是直接看官方文档吧。没有比这个更全面的了。