1 SpringBoot是什么

众所周知 Spring 应用需要进行大量的配置,各种 XML 配置和注解配置让人眼花缭乱,且极容易出错,因此 Spring 一度被称为“配置地狱”。
为了简化 Spring 应用的搭建和开发过程,Pivotal 团队在 Spring 基础上提供了一套全新的开源的框架,它就是 Spring Boot。
Spring Boot 具有 Spring 一切优秀特性,Spring 能做的事,Spring Boot 都可以做,而且使用更加简单,功能更加丰富,性能更加稳定而健壮。随着近些年来微服务技术的流行,Spring Boot 也成为了时下炙手可热的技术。
Spring Boot 提供了大量开箱即用(out-of-the-box)的依赖模块,例如 spring-boot-starter-redis、spring-boot-starter-data-mongodb 和 spring-boot-starter-data-elasticsearch 等。这些依赖模块为 Spring Boot 应用提供了大量的自动配置,使得 Spring Boot 应用只需要非常少量的配置甚至零配置,便可以运行起来,让开发人员从 Spring 的“配置地狱”中解放出来,有更多的精力专注于业务逻辑的开发。

Spring Boot 的特点

Spring Boot 具有以下特点:

1. 独立运行的 Spring 项目

Spring Boot 可以以 jar 包的形式独立运行,Spring Boot 项目只需通过命令“ java–jar xx.jar” 即可运行。

2. 内嵌 Servlet 容器

Spring Boot 使用嵌入式的 Servlet 容器(例如 Tomcat、Jetty 或者 Undertow 等),应用无需打成 WAR 包 。

3. 提供 starter 简化 Maven 配置

Spring Boot 提供了一系列的“starter”项目对象模型(POMS)来简化 Maven 配置。

4. 提供了大量的自动配置

Spring Boot 提供了大量的默认自动配置,来简化项目的开发,开发人员也通过配置文件修改默认配置。

5. 自带应用监控

Spring Boot 可以对正在运行的项目提供监控。

6. 无代码生成和 xml 配置

Spring Boot 不需要任何 xml 配置即可实现 Spring 的所有配置。

2 IDEA创建Spring Boot项目

Spring Boot 版本及其环境配置要求如下表。

Spring Boot 2.x
JDK 8.0 及以上版本
Maven 3.x
IntelliJ IDEA 14.0 以上

Intellij IDEA 一般可以通过两种方式创建 Spring Boot 项目:

  • 使用 Maven 创建
  • 使用 Spring Initializr 创建

    2.1 使用Maven

  1. IDEA创建Maven项目

  2. 在该 Maven 项目的 pom.xml 中添加以下配置,导入 Spring Boot 相关的依赖。重点就是父依赖的添加和引入两个依赖。

    1. <project>
    2. ...
    3. <parent>
    4. <groupId>org.springframework.boot</groupId>
    5. <artifactId>spring-boot-starter-parent</artifactId>
    6. <version>2.4.5</version>
    7. <relativePath/> <!-- lookup parent from repository -->
    8. </parent>
    9. <dependencies>
    10. <dependency>
    11. <groupId>org.springframework.boot</groupId>
    12. <artifactId>spring-boot-starter-web</artifactId>
    13. </dependency>
    14. <dependency>
    15. <groupId>org.springframework.boot</groupId>
    16. <artifactId>spring-boot-starter-test</artifactId>
    17. <scope>test</scope>
    18. </dependency>
    19. </dependencies>
    20. ...
    21. </project>
  3. 在 net.biancheng.www 包下,创建一个名为 helloWorldApplication 主程序,用来启动 Spring Boot 应用,代码如下。 ```java package net.biancheng.www;

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

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

  1. Spring Boot 项目目录结构如下图。<br />![](https://cdn.nlark.com/yuque/0/2021/png/12786164/1638750835315-127556dc-800f-42f7-a42a-e1587cb43360.png#clientId=ubd52b404-1ada-4&crop=0&crop=0&crop=1&crop=1&from=paste&id=u38bd6031&originHeight=460&originWidth=404&originalType=url&ratio=1&rotation=0&showTitle=false&status=done&style=none&taskId=u1ae7d593-54f2-4bd4-b0fa-f6b6069bd64&title=)
  2. <a name="fHzgj"></a>
  3. ## 2.2 使用 Spring Initializr 创建
  4. IntelliJ IDEA 支持用户使用 Spring 项目创建向导(Spring Initializr )快速地创建一个 Spring Boot 项目,步骤如下。(**部分图略**)<br />![](https://cdn.nlark.com/yuque/0/2021/png/12786164/1638750908867-7cae628f-6aa9-46bc-9b75-265a2a24cb12.png#clientId=ubd52b404-1ada-4&crop=0&crop=0&crop=1&crop=1&from=paste&id=u701ee5a7&margin=%5Bobject%20Object%5D&originalType=url&ratio=1&rotation=0&showTitle=false&status=done&style=none&taskId=u52dd5557-e058-41d6-82b2-4775f543653&title=)<br />![](https://cdn.nlark.com/yuque/0/2021/png/12786164/1638750941819-fcba2eb1-7bdc-4289-b844-b6614b45e63c.png#clientId=ubd52b404-1ada-4&crop=0&crop=0&crop=1&crop=1&from=paste&id=u7d39fd14&margin=%5Bobject%20Object%5D&originalType=url&ratio=1&rotation=0&showTitle=false&status=done&style=none&taskId=uac73dedc-f308-4c1f-8b00-4bcd263fdb7&title=)<br />返回 IDEA 工作区,可以看到 Spring Boot 项目 helloworld 已经创建完成。该项目不但具有完整的目录结构,还有完整的 Maven 配置,并默认生成了一个名为 HelloworldApplication 的主启动程序。<br />![](https://cdn.nlark.com/yuque/0/2021/png/12786164/1638750980218-fd396608-42f7-4522-920e-990f076600a1.png#clientId=ubd52b404-1ada-4&crop=0&crop=0&crop=1&crop=1&from=paste&id=u8a5a6c43&margin=%5Bobject%20Object%5D&originalType=url&ratio=1&rotation=0&showTitle=false&status=done&style=none&taskId=uc2498d36-9f83-4dac-847e-67d717072df&title=)
  5. > 此时,几乎所有的准备工作都已经准备就绪,我们可以在没有编写任何代码的情况下,直接将该 Spring Boot 项目运行起来。
  6. <a name="cLN2A"></a>
  7. ## 2.3 启动Spring Boot
  8. 默认情况下,Spring Boot 项目会创建一个名为 ***Application 的主程序启动类 ,该类中使用了一个组合注解 @SpringBootApplication,用来开启 Spring Boot 的自动配置,另外该启动类中包含一个 main() 方法,用来启动该项目。<br /> 直接运行启动类 HelloworldApplication 中的 main() 方法,便可以启动该项目,结果如下图。<br />![](https://cdn.nlark.com/yuque/0/2021/png/12786164/1638751076341-ca4591cf-bdd3-4e5e-b65b-ba7a374257fe.png#clientId=ubd52b404-1ada-4&crop=0&crop=0&crop=1&crop=1&from=paste&id=u6f8327a8&margin=%5Bobject%20Object%5D&originalType=url&ratio=1&rotation=0&showTitle=false&status=done&style=none&taskId=u9f46b048-789e-449f-9402-6eb43ceaf3e&title=)
  9. > 注意:Spring Boot 内部集成了 Tomcat,不需要人为手动配置 Tomcat,开发者只需要关注具体的业务逻辑即可。
  10. 为了能比较的清楚的看到效果,我们在 net.biancheng.www 包下又创建一个 controller 包,并在该包内创建一个名为 HelloController Controller,代码如下。
  11. ```java
  12. package net.biancheng.www.controller;
  13. import org.springframework.stereotype.Controller;
  14. import org.springframework.web.bind.annotation.RequestMapping;
  15. import org.springframework.web.bind.annotation.ResponseBody;
  16. @Controller
  17. public class HelloController {
  18. @ResponseBody
  19. @RequestMapping("/hello")
  20. public String hello() {
  21. return "Hello World!";
  22. }
  23. }

重启 Spring Boot 项目,然后在地址栏访问 “http://localhost:8080/hello”,结果如下图。
SpringBoot - 图1

3 Spring Boot starter入门

传统的 Spring 项目想要运行,不仅需要导入各种依赖,还要对各种 XML 配置文件进行配置,十分繁琐,但 Spring Boot 项目在创建完成后,即使不编写任何代码,不进行任何配置也能够直接运行,这都要归功于 Spring Boot 的 starter 机制。本节我们将对 stater 进行介绍。

3.1 starter

Spring Boot 将日常企业应用研发中的各种场景都抽取出来,做成一个个的 starter(启动器),starter 中整合了该场景下各种可能用到的依赖,用户只需要在 Maven 中引入 starter 依赖,SpringBoot 就能自动扫描到要加载的信息并启动相应的默认配置。starter 提供了大量的自动配置,让用户摆脱了处理各种依赖和配置的困扰。所有这些 starter 都遵循着约定成俗的默认配置,并允许用户调整这些配置,即遵循“约定大于配置”的原则。

并不是所有的 starter 都是由 Spring Boot 官方提供的,也有部分 starter 是第三方技术厂商提供的,例如 druid-spring-boot-starter 和 mybatis-spring-boot-starter 等等。当然也存在个别第三方技术,Spring Boot 官方没提供 starter,第三方技术厂商也没有提供 starter。

以 spring-boot-starter-web 为例,它能够为提供 Web 开发场景所需要的几乎所有依赖,因此在使用 Spring Boot 开发 Web 项目时,只需要引入该 Starter 即可,而不需要额外导入 Web 服务器和其他的 Web 依赖。

在 pom.xml 中引入 spring-boot-starter-web,示例代码如下。

  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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  4. <modelVersion>4.0.0</modelVersion>
  5. <!--SpringBoot父项目依赖管理-->
  6. <parent>
  7. <groupId>org.springframework.boot</groupId>
  8. <artifactId>spring-boot-starter-parent</artifactId>
  9. <version>2.4.5</version>
  10. <relativePath/>
  11. </parent>
  12. ....
  13. <dependencies>
  14. <!--导入 spring-boot-starter-web-->
  15. <dependency>
  16. <groupId>org.springframework.boot</groupId>
  17. <artifactId>spring-boot-starter-web</artifactId>
  18. </dependency>
  19. ...
  20. </dependencies>
  21. ...
  22. </project>

在该项目中执行以下 mvn 命令查看器依赖树。

  1. mvn dependency:tree

执行结果如下。

  1. [INFO] Scanning for projects...
  2. [INFO]
  3. [INFO] --------------------< net.biancheng.www:helloworld >--------------------
  4. [INFO] Building helloworld 0.0.1-SNAPSHOT
  5. [INFO] --------------------------------[ jar ]---------------------------------
  6. [INFO]
  7. [INFO] --- maven-dependency-plugin:3.1.2:tree (default-cli) @ helloworld ---
  8. [INFO] net.biancheng.www:helloworld:jar:0.0.1-SNAPSHOT
  9. [INFO] \- org.springframework.boot:spring-boot-starter-web:jar:2.4.5:compile
  10. [INFO] +- org.springframework.boot:spring-boot-starter:jar:2.4.5:compile
  11. [INFO] | +- org.springframework.boot:spring-boot:jar:2.4.5:compile
  12. [INFO] | +- org.springframework.boot:spring-boot-autoconfigure:jar:2.4.5:compile
  13. [INFO] | +- org.springframework.boot:spring-boot-starter-logging:jar:2.4.5:compile
  14. [INFO] | | +- ch.qos.logback:logback-classic:jar:1.2.3:compile
  15. [INFO] | | | +- ch.qos.logback:logback-core:jar:1.2.3:compile
  16. [INFO] | | | \- org.slf4j:slf4j-api:jar:1.7.30:compile
  17. [INFO] | | +- org.apache.logging.log4j:log4j-to-slf4j:jar:2.13.3:compile
  18. [INFO] | | | \- org.apache.logging.log4j:log4j-api:jar:2.13.3:compile
  19. [INFO] | | \- org.slf4j:jul-to-slf4j:jar:1.7.30:compile
  20. [INFO] | +- jakarta.annotation:jakarta.annotation-api:jar:1.3.5:compile
  21. [INFO] | +- org.springframework:spring-core:jar:5.3.6:compile
  22. [INFO] | | \- org.springframework:spring-jcl:jar:5.3.6:compile
  23. [INFO] | \- org.yaml:snakeyaml:jar:1.27:compile
  24. [INFO] +- org.springframework.boot:spring-boot-starter-json:jar:2.4.5:compile
  25. [INFO] | +- com.fasterxml.jackson.core:jackson-databind:jar:2.11.4:compile
  26. [INFO] | | +- com.fasterxml.jackson.core:jackson-annotations:jar:2.11.4:compile
  27. [INFO] | | \- com.fasterxml.jackson.core:jackson-core:jar:2.11.4:compile
  28. [INFO] | +- com.fasterxml.jackson.datatype:jackson-datatype-jdk8:jar:2.11.4:compile
  29. [INFO] | +- com.fasterxml.jackson.datatype:jackson-datatype-jsr310:jar:2.11.4:compile
  30. [INFO] | \- com.fasterxml.jackson.module:jackson-module-parameter-names:jar:2.11.4:compile
  31. [INFO] +- org.springframework.boot:spring-boot-starter-tomcat:jar:2.4.5:compile
  32. [INFO] | +- org.apache.tomcat.embed:tomcat-embed-core:jar:9.0.45:compile
  33. [INFO] | +- org.glassfish:jakarta.el:jar:3.0.3:compile
  34. [INFO] | \- org.apache.tomcat.embed:tomcat-embed-websocket:jar:9.0.45:compile
  35. [INFO] +- org.springframework:spring-web:jar:5.3.6:compile
  36. [INFO] | \- org.springframework:spring-beans:jar:5.3.6:compile
  37. [INFO] \- org.springframework:spring-webmvc:jar:5.3.6:compile
  38. [INFO] +- org.springframework:spring-aop:jar:5.3.6:compile
  39. [INFO] +- org.springframework:spring-context:jar:5.3.6:compile
  40. [INFO] \- org.springframework:spring-expression:jar:5.3.6:compile
  41. [INFO] ------------------------------------------------------------------------
  42. [INFO] BUILD SUCCESS
  43. [INFO] ------------------------------------------------------------------------
  44. [INFO] Total time: 2.505 s
  45. [INFO] Finished at: 2021-04-30T14:52:30+08:00
  46. [INFO] ------------------------------------------------------------------------

从以上结果中,我们可以看到 Spring Boot 导入了 springframework、logging、jackson 以及 Tomcat 等依赖,而这些正是我们在开发 Web 项目时所需要的。
您可能会发现一个问题,即在以上 pom.xml 的配置中,引入依赖 spring-boot-starter-web 时,并没有指明其版本(version),但在依赖树中,我们却看到所有的依赖都具有版本信息,那么这些版本信息是在哪里控制的呢?
其实,这些版本信息是由 spring-boot-starter-parent(版本仲裁中心) 统一控制的。

3.2 spring-boot-starter-parent

spring-boot-starter-parent 是所有 Spring Boot 项目的父级依赖,它被称为 Spring Boot 的版本仲裁中心,可以对项目内的部分常用依赖进行统一管理。

  1. <!--SpringBoot父项目依赖管理-->
  2. <parent>
  3. <groupId>org.springframework.boot</groupId>
  4. <artifactId>spring-boot-starter-parent</artifactId>
  5. <version>2.4.5</version>
  6. <relativePath/>
  7. </parent>

Spring Boot 项目可以通过继承 spring-boot-starter-parent 来获得一些合理的默认配置,它主要提供了以下特性:

  • 默认 JDK 版本(Java 8)
  • 默认字符集(UTF-8)
  • 依赖管理功能
  • 资源过滤
  • 默认插件配置
  • 识别 application.properties 和 application.yml 类型的配置文件
    查看 spring-boot-starter- parent 的底层代码,可以发现其有一个父级依赖 spring-boot-dependencies。

    1. <parent>
    2. <groupId>org.springframework.boot</groupId>
    3. <artifactId>spring-boot-dependencies</artifactId>
    4. <version>2.4.5</version>
    5. </parent>

    spring-boot-dependencies 的底层代码如下。

    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <project xmlns="http://maven.apache.org/POM/4.0.0"
    3. xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"
    4. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
    5. <modelVersion>4.0.0</modelVersion>
    6. <groupId>org.springframework.boot</groupId>
    7. <artifactId>spring-boot-dependencies</artifactId>
    8. <version>2.4.5</version>
    9. <packaging>pom</packaging>
    10. ....
    11. <properties>
    12. <activemq.version>5.16.1</activemq.version>
    13. <antlr2.version>2.7.7</antlr2.version>
    14. <appengine-sdk.version>1.9.88</appengine-sdk.version>
    15. <artemis.version>2.15.0</artemis.version>
    16. <aspectj.version>1.9.6</aspectj.version>
    17. <assertj.version>3.18.1</assertj.version>
    18. <atomikos.version>4.0.6</atomikos.version>
    19. ....
    20. </properties>
    21. <dependencyManagement>
    22. <dependencies>
    23. <dependency>
    24. <groupId>org.apache.activemq</groupId>
    25. <artifactId>activemq-amqp</artifactId>
    26. <version>${activemq.version}</version>
    27. </dependency>
    28. <dependency>
    29. <groupId>org.apache.activemq</groupId>
    30. <artifactId>activemq-blueprint</artifactId>
    31. <version>${activemq.version}</version>
    32. </dependency>
    33. ...
    34. </dependencies>
    35. </dependencyManagement>
    36. <build>
    37. <pluginManagement>
    38. <plugins>
    39. <plugin>
    40. <groupId>org.codehaus.mojo</groupId>
    41. <artifactId>build-helper-maven-plugin</artifactId>
    42. <version>${build-helper-maven-plugin.version}</version>
    43. </plugin>
    44. <plugin>
    45. <groupId>org.flywaydb</groupId>
    46. <artifactId>flyway-maven-plugin</artifactId>
    47. <version>${flyway.version}</version>
    48. </plugin>
    49. ...
    50. </plugins>
    51. </pluginManagement>
    52. </build>
    53. </project>

    以上配置中,部分元素说明如下:

  • dependencyManagement :负责管理依赖;

  • pluginManagement:负责管理插件;
  • properties:负责定义依赖或插件的版本号。

spring-boot-dependencies 通过 dependencyManagement 、pluginManagement 和 properties 等元素对一些常用技术框架的依赖或插件进行了统一版本管理,例如 Activemq、Spring、Tomcat 等。

4 YMAL

Spring Boot 提供了大量的自动配置,极大地简化了spring 应用的开发过程,当用户创建了一个 Spring Boot 项目后,即使不进行任何配置,该项目也能顺利的运行起来。当然,用户也可以根据自身的需要使用配置文件修改 Spring Boot 的默认设置。
SpringBoot 默认使用以下 2 种全局的配置文件,其文件名是固定的。

  • application.properties
  • application.yml

其中,application.yml 是一种使用 YAML 语言编写的文件,它与 application.properties 一样,可以在 Spring Boot 启动时被自动读取,修改 Spring Boot 自动配置的默认值。
本节我们将详细介绍 YAML 语言的语法及使用。

4.1 YAML简介

YAML 全称 YAML Ain’t Markup Language,它是一种以数据为中心的标记语言,比 XML 和 JSON 更适合作为配置文件。
想要使用 YAML 作为属性配置文件(以 .yml 或 .yaml 结尾),需要将 SnakeYAML 库添加到 classpath 下,Spring Boot 中的 spring-boot-starter-web 或 spring-boot-starter 都对 SnakeYAML 库做了集成, 只要项目中引用了这两个 Starter 中的任何一个,Spring Boot 会自动添加 SnakeYAML 库到 classpath 下。
下面是一个简单的 application.yml 属性配置文件。

  1. server:
  2. port: 8081

4.2 YAML 语法

YAML 的语法如下:

  • 使用缩进表示层级关系。
  • 缩进时不允许使用 Tab 键,只允许使用空格。
  • 缩进的空格数不重要,但同级元素必须左侧对齐。
  • 大小写敏感。
    例如:

    1. spring:
    2. profiles: dev
    3. datasource:
    4. url: jdbc:mysql://127.0.01/banchengbang_springboot
    5. username: root
    6. password: root
    7. driver-class-name: com.mysql.jdbc.Driver

    4.3 YAML 常用写法

    4.3.1 YAML 字面量写法

    字面量是指单个的,不可拆分的值,例如:数字、字符串、布尔值、以及日期等。
    在 YAML 中,使用“key:[空格]value的形式表示一对键值对(空格不能省略),如 url: www.biancheng.net。
    字面量直接写在键值对的“value中即可,且默认情况下字符串是不需要使用单引号或双引号的。

    1. name: bianchengbang

    若字符串使用单引号,则会转义特殊字符。

    1. name: zhangsan \n lisi

    输出结果为:

    1. zhangsan \n lisi

    若字符串使用双引号,则不会转义特殊字符,特殊字符会输出为其本身想表达的含义

    1. name: zhangsan \n lisi

    输出结果为:

    1. zhangsan
    2. lisi

    4.3.2 YAML 对象写法

    在 YAML 中,对象可能包含多个属性,每一个属性都是一对键值对。
    YAML 为对象提供了 2 种写法:
    普通写法,使用缩进表示对象与属性的层级关系。

    1. website:
    2. name: bianchengbang
    3. url: www.biancheng.net

    行内写法:

    1. website: {name: bianchengbang,url: www.biancheng.net}

    4.3.3 YAML 数组写法

    YAML 使用“-”表示数组中的元素,普通写法如下:

    1. pets:
    2. -dog
    3. -cat
    4. -pig

    行内写法

    1. pets: [dog,cat,pig]

    4.3.4 复合结构

    以上三种数据结构可以任意组合使用,以实现不同的用户需求,例如:

    1. person:
    2. name: zhangsan
    3. age: 30
    4. pets:
    5. -dog
    6. -cat
    7. -pig
    8. car:
    9. name: QQ
    10. child:
    11. name: zhangxiaosan
    12. age: 2

    4.4 YAML 组织结构

    一个 YAML 文件可以由一个或多个文档组成,文档之间使用“—-作为分隔符,且个文档相互独立,互不干扰。如果 YAML 文件只包含一个文档,则“—-分隔符可以省略。 ```java


website: name: bianchengbang

url: www.biancheng.net

website: {name: bianchengbang,url: www.biancheng.net} pets: -dog -cat

-pig

pets: [dog,cat,pig]

name: “zhangsan \n lisi”

name: ‘zhangsan \n lisi’ ```

5 Spring Boot配置绑定