Spring Boot 框架介绍和使用

谁借莪１个温暖的怀抱￠ 2022-09-30 03:51 191阅读 0赞

本文参考自[Spring Boot文档][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下，是测试类。

![项目格式][1240]

运行类的代码如下。它是一个简单的类，包含了主方法，而且类上使用了@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

## 项目配置 ##

### 自定义 SpringApplication ###

前面我们看到了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<ApplicationReadyEvent> { 
    
    
        @Override
        public void onApplicationEvent(ApplicationReadyEvent event) {
            System.out.println("应用程序准备就绪");
        }
    }

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

*  ApplicationStartingEvent
 *  ApplicationEnvironmentPreparedEvent
 *  ApplicationPreparedEvent
 *  ApplicationReadyEvent
 *  ApplicationFailedEvent

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

### Profiles ###

在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 ###

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][Spring Boot_ _C. Auto-configuration classes]。

### Spring Web MVC自动配置 ###

#### 自动配置 ####

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`，只需要将自己的`favicon.ico`直接放到resources文件夹下即可。

#### 视图模板 ####

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

#### 错误处理 ####

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

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

src/
     +- main/
         +- java/
         |   + <source code>
         +- resources/
             +- public/
                 +- error/
                 |   +- 404.html
                 +- <other public assets>

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

src/
     +- main/
         +- java/
         |   + <source code>
         +- resources/
             +- templates/
                 +- error/
                 |   +- 5xx.ftl
                 +- <other templates>

### SQL数据库自动配置 ###

#### 嵌入式数据库 ####

如果类路径中包含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 ####

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

### JPA自动配置 ###

#### 实体类 ####

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

#### Spring Data JPA ####

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

spring.jpa.hibernate.ddl-auto=update

#### H2的web控制台 ####

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

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

![H2 web控制台][H2 web]

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

*  security.user.role
 *  security.basic.authorize-mode
 *  security.basic.enabled

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

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

## 其他配置 ##

### 调试工具（devtools） ###

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

<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <optional>true</optional>
        </dependency>
    </dependencies>

如果使用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 ###

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

### Servlet容器 ###

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

#### 端口号 ####

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

#### 使用Jetty ####

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

<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
        <exclusions>
            <exclusion>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-tomcat</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-jetty</artifactId>
    </dependency>

如果使用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） ##

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

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

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

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

### 端点（Endpoints） ###

每个端点就是一个监控项。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的使用方法。当然官方文档还有很多内容这里没有列出。这里也不可能完全列出来。如果需要更详细的介绍还是直接看官方文档吧。没有比这个更全面的了。

[Spring Boot]: http://docs.spring.io/spring-boot/docs/1.5.2.RELEASE/reference/htmlsingle/
[start.spring.io]: http://start.spring.io/
[13.5. Starters]: http://docs.spring.io/spring-boot/docs/2.0.0.BUILD-SNAPSHOT/reference/htmlsingle/#using-boot-starter
[F. Dependency versions]: http://docs.spring.io/spring-boot/docs/2.0.0.BUILD-SNAPSHOT/reference/htmlsingle/#appendix-dependency-versions
[1240]: /images/20220708/2fa1bd460f1e43c4935e8ae08cf63512.png
[Spring Boot_ _C. Auto-configuration classes]: http://docs.spring.io/spring-boot/docs/2.0.0.BUILD-SNAPSHOT/reference/htmlsingle/#auto-configuration-classes
[H2 web]: /images/20220708/8e154b98cb7345a1806a7c45f3ea0cfb.png
[47. Endpoints]: http://docs.spring.io/spring-boot/docs/2.0.0.BUILD-SNAPSHOT/reference/htmlsingle/#production-ready-endpoints