SpringBoot技术总结

SpringBoot

前言

SpringBoot门技术是用来加速开发Spring程序的，SpringBoot基于Spring4.0设计，不仅继承了Spring框架原有的优秀特性[IOC AOP DI]，而且还通过简化配置来进一步简化了Spring应用的整个搭建和开发过程，使用Spring Boot可以做到专注于Spring应用的开发，而无需过多关注XML的配置。另外SpringBoot通过集成大量的框架使得依赖包的版本冲突，以及引用的不稳定性等问题得到了很好的解决

Spring Boot的核心功能

1、 可独立运行的Spring项目：Spring Boot可以以jar包的形式独立运行。

2、 内嵌的Servlet容器：Spring Boot可以选择内嵌Tomcat、Jetty或者Undertow，无须以war包形式部署项目。

3、 简化的Maven配置：Spring提供推荐的基础 POM 文件来简化Maven 配置。

4、 自动配置Spring：Spring Boot会根据项目依赖来自动配置Spring 框架，极大地减少项目要使用的配置。

5、 无代码生成和xml配置：Spring Boot不生成代码。完全不需要任何xml配置即可实现Spring的所有配置。

1.快速上手SpringBoot

1.1 SpringBoot入门程序制作

​
​ 下面使用SpringBoot技术快速构建一个SpringMVC的程序

步骤①：创建新模块，选择Spring Initializr，并配置模块相关基础信息

步骤②：选择当前模块需要使用的技术

​ 按照要求，左侧选择web，然后在中间选择Spring Web即可，选完右侧就出现了新的内容项，这就表示勾选成功了,自动生成的目录如下：

默认生成的Spring Boot项目：
主程序已经生成好了，我们只需要完成我们自己的逻辑

resources文件夹中目录结构：
static：保存所有的静态资源； js、css、images；
templates：保存所有的模板页面；（Spring Boot默认jar包使用嵌入式的Tomcat，默认不支持JSP页面）；可以使用模板引擎（freemarker、thymeleaf）；
application.properties：Spring Boot应用的配置文件；可以修改一些默认设置；

步骤③：开发Controller类，在controller目录下新建BookController类

@RestController
@RequestMapping("/books")
public class BookController {
    @GetMapping
    public String getById(){
        System.out.println("springboot is running...");
        return "springboot is running...";
    }
}

​在RequestMapping可以指定Controller 的访问地址，使用注解@GetMapping等，可以指定请求的方法（GET、POT等）@RequestMapping、@GetMapping、@PostMapping 等，通过这些注解来映射请求，也就是通过它来指定控制器可以处理哪些URL请求，用在方法上，可以通过配置的url进行访问。
在方法的参数中，可以使用注解来获取网络参数，常用的有：
@RequestParam获取查询参数。即url?name=这种形式
@PathVariable获取路径参数。即url/{id}这种形式。
@RequestBody获取Body的参数，一般用于post获取参数
@RequestHeader获取请求头的信息
@CookieValue获取Cookie的信息

做到这里SpringBoot程序基础的开发已经完成，可以运行SpringBoot生产的Application类进行测试

步骤④：运行自动生成的Application类

​ 使用带main方法的java程序的运行形式来运行程序，运行完毕后，控制台输出上述信息。
​ 运行的信息中包含了8080的端口，Tomcat这种字样，这里启动了内置的Tomcat服务器

访问路径：	http://localhost:8080/books

1.2 pom.xml

spring-boot-dependencie：核心依赖在父工程中。大部分依赖的版本都是在父工程中管理着，我们拿过来调用即可，因此我们引用一些依赖时不需要指定版本。并且父工程中已经帮我们配置好资源过滤和一些插件。
这是maven的配置文件，描述了当前工程构建时相应的配置信息，在pom文件中，导入需要的依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.16</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>demo4</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>demo4</name>
    <description>demo4</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

配置中有两个信息需要关注，一个是parent，也就是当前工程继承了另外一个工程，还有依赖坐标

1.3 启动类

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

启动器其实就是 springboot 的启动场景，比如 spring-boot-starter-web 启动器会帮我们自动导入 web 环境所有依赖。
springboot 会将所有的功能场景，都变成一个个启动器。
我们要使用什么功能，只需要找到对应的启动器就可以了即 starter

1.4 主程序

1.4.1 注解

@SpringBootApplication

主要组合包含了以下几个注解：
@SpringBootConfiguration：组合了@Configuration注解，实现配置⽂件的功能。
@EnableAutoConfiguration：打开⾃动配置的功能，也可以关闭某个⾃动配置的选项，如关闭数据源⾃动配置功能：
@SpringBootApplication(exclude={DataSourceAutoConfiguration.class})。
@ComponentScan：扫描当前主启动类同级的包。扫描@Service、@Repository、@Component、@Controller等标注的类，创建bean。可以设置扫描范围，决定类哪些生成bean，哪些类不生成。（扫描的包到 Registrar.class 注册）

1.4.2 run方法

main 方法中的 run 方法启动会开启一个服务。

public class Demo4Application {

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

}

这个类功能很简单，就一句代码，运行程序就是运行的这个类
主要两部分
一是 SpringApplication 的实例化。
二是 run 方法的执行。

SpringApplication 类主要做了四件事情
判断应用的类型是普通项目还是 web 项目。（普通项目直接就结束了，web 项目可以一直启动）
查找并加载所有可用初始化器，设置到 initializers 属性中。
查找所有的应用程序监听器，设置到 listeners 属性中。（获取上下文处理 bean）
推断并设置 main 方法的定义类，找到运行的主类。

​ 通过上面的制作，不难发现，SpringBoot程序几乎什么都没写，功能就有了，这也是SpringBoot技术为什么现在这么火的原因，和Spirng程序相比，SpringBoot程序在开发的过程中各个层面均具有优势

类配置文件	Spring	SpringBoot
pom文件中的坐标	手工添加	勾选添加
web3.0配置类	手工制作	无
Spring/SpringMVC配置类	手工制作	无
控制器	手工制作	手工制作

​ 一句话总结一下就是能少写就少写，能不写就不写，这就是SpringBoot技术给我们带来的好处

总结

1. 开发SpringBoot程序可以根据向导进行联网快速制作
2. SpringBoot程序需要基于JDK8以上版本进行制作
3. SpringBoot程序中需要使用何种功能通过勾选选择技术，也可以手工添加对应的要使用的技术（后期讲解）
4. 运行SpringBoot程序通过运行Application程序入口进行

思考

​ 前面制作的时候说过，这个过程必须联网才可以进行，但是有些时候会遇到一些莫名其妙的问题，比如基于Idea开发时，你会发现你配置了一些坐标，然后Maven下载对应东西的时候死慢死慢的，甚至还会失败。其实这和Idea这款IDE工具有关，万一Idea不能正常访问网络的话，我们是不是就无法制作SpringBoot程序了呢？咱们下一节再说

2 SpringBoot简介

​ SpringBoot是由Pivotal团队提供的全新框架，其设计目的是用来简化Spring应用的初始搭建以及开发过程。

​ 其实就是针对原始的Spring程序制作的两个方面进行了简化：

• Spring程序缺点
  • 依赖设置繁琐
    • 以前写Spring程序，使用的技术都要自己一个一个的写，现在不需要了，一个坐标就行
  • 配置繁琐
    • 以前写配置类或者配置文件，然后用什么东西就要自己写加载bean这些东西，现在什么都没写，照样能用

​ 这些简化操作在SpringBoot中有专业的用语，也是SpringBoot程序的核心功能及优点：

• 起步依赖（简化依赖配置）
  • 依赖配置的书写简化就是靠这个起步依赖达成的
• 自动配置（简化常用工程相关配置）
  • 配置过于繁琐，使用自动配置就可以做响应的简化，但是内部还是很复杂的，后面具体展开说
• 辅助功能（内置服务器，……）
  • 除了上面的功能，其实SpringBoot程序还有其他的一些优势，比如我们没有配置Tomcat服务器，但是能正常运行，这是SpringBoot程序的一个可以感知到的功能，也是SpringBoot的辅助功能之一。

​ 下面结合入门程序来说说这些简化操作都在哪些方面进行体现的，一共分为4个方面

• parent
• starter
• 引导类
• 内嵌tomcat

2.1 parent

​ SpringBoot关注到开发者在进行开发时，往往对依赖版本的选择具有固定的搭配格式，并且这些依赖版本的选择还不能乱搭配。比如A技术的2.0版与B技术的3.5版可以合作在一起，但是和B技术的3.7版合并使用时就有冲突。其实很多开发者都一直想做一件事情，就是将各种各样的技术配合使用的常见依赖版本进行收集整理，制作出了最合理的依赖版本配置方案，这样使用起来就方便多了。

​ SpringBoot将所有的技术版本的常见使用方案都给开发者整理了出来，以后开发者使用时直接用它提供的版本方案，就不用担心冲突问题了，相当于SpringBoot做了无数个技术版本搭配的列表，这个技术搭配列表的名字叫做parent。

​ parent自身具有很多个版本，每个parent版本中包含有几百个其他技术的版本号，不同的parent间使用的各种技术的版本号有可能会发生变化。当开发者使用某些技术时，直接使用SpringBoot提供的parent就行了，由parent帮助开发者统一的进行各种技术的版本管理

​ 比如现在要使用Spring配合MyBatis开发，没有parent之前怎么做呢？选个Spring的版本，再选个MyBatis的版本，再把这些技术使用时关联的其他技术的版本逐一确定下来。当Spring的版本发生变化需要切换时，你的MyBatis版本有可能也要跟着切换，关联技术呢？可能都要切换，而且切换后还可能出现问题。现在这一切工作都可以交给parent来做了。开发者无需关注这些技术间的版本冲突问题，开发者只需要关注用什么技术就行了，冲突问题由parent负责处理。

​ parent仅仅帮我们进行版本管理，它不负责帮你导入坐标，用什么还是开发者自己定，只不过版本不需要手动管理了。整体上来说，使用parent可以帮助开发者进行版本的统一管理

​ 关注：parent定义出来以后，并不是直接使用的，仅仅给了开发者一个说明书，但是并没有实际使用，这个一定要确认清楚

• 项目中的pom.xml中继承了一个坐标

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.5.4</version>
</parent>

• 打开后可以查阅到其中又继承了一个坐标

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-dependencies</artifactId>
    <version>2.5.4</version>
</parent>

• 这个坐标中定义了两组信息，第一组是各式各样的依赖版本号属性，下面列出依赖版本属性的局部，可以看的出来，定义了若干个技术的依赖版本号

<properties>
    <activemq.version>5.16.3</activemq.version>
    <aspectj.version>1.9.7</aspectj.version>
    <assertj.version>3.19.0</assertj.version>
    <commons-codec.version>1.15</commons-codec.version>
    <commons-dbcp2.version>2.8.0</commons-dbcp2.version>
    <commons-lang3.version>3.12.0</commons-lang3.version>
    <commons-pool.version>1.6</commons-pool.version>
    <commons-pool2.version>2.9.0</commons-pool2.version>
    <h2.version>1.4.200</h2.version>
    <hibernate.version>5.4.32.Final</hibernate.version>
    <hibernate-validator.version>6.2.0.Final</hibernate-validator.version>
    <httpclient.version>4.5.13</httpclient.version>
    <jackson-bom.version>2.12.4</jackson-bom.version>
    <javax-jms.version>2.0.1</javax-jms.version>
    <javax-json.version>1.1.4</javax-json.version>
    <javax-websocket.version>1.1</javax-websocket.version>
    <jetty-el.version>9.0.48</jetty-el.version>
    <junit.version>4.13.2</junit.version>
</properties>

​ 第二组是各式各样的的依赖坐标信息，可以看出依赖坐标定义中没有具体的依赖版本号，而是引用了第一组信息中定义的依赖版本属性值

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>${hibernate.version}</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>${junit.version}</version>
        </dependency>
    </dependencies>
</dependencyManagement>

关注：上面的依赖坐标定义是出现在标签中的，其实是对引用坐标的依赖管理，并不是实际使用的坐标。因此当你的项目中继承了这组parent信息后，在不使用对应坐标的情况下，前面的这组定义是不会具体导入某个依赖的

关注：因为在maven中继承机会只有一次，上述继承的格式还可以切换成导入的形式进行，并且在阿里云的starter创建工程时就使用了此种形式

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>${spring-boot.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

总结

1. 开发SpringBoot程序要继承spring-boot-starter-parent
2. spring-boot-starter-parent中定义了若干个依赖管理
3. 继承parent模块可以避免多个依赖使用相同技术时出现依赖版本冲突
4. 继承parent的形式也可以采用引入依赖的形式实现效果

2.2 starter

​ SpringBoot关注到开发者在实际开发时，对于依赖坐标的使用往往都有一些固定的组合方式，比如使用spring-webmvc就一定要使用spring-web。每次都要固定搭配着写，非常繁琐，而且格式固定。
​ SpringBoot把所有的技术使用的固定搭配格式都给开发出来，以后用某个技术，就不用一次写一堆依赖了，开发者使用的时候，直接用这样的固定技术搭配，SpringBoot给它起了个名字叫做starter。

​ starter定义了使用某种技术时对于依赖的固定搭配格式，也是一种最佳解决方案，使用starter可以帮助开发者减少依赖配置

​ 这个东西其实在入门程序里面已经使用过了，入门案例中的web功能就是使用这种方式添加依赖的。

• 项目中的pom.xml定义了使用SpringMVC技术，但是并没有写SpringMVC的坐标，而是添加了一个名字中包含starter的依赖

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

• 在spring-boot-starter-web中又定义了若干个具体依赖的坐标

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
        <version>2.5.4</version>
        <scope>compile</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-json</artifactId>
        <version>2.5.4</version>
        <scope>compile</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-tomcat</artifactId>
        <version>2.5.4</version>
        <scope>compile</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-web</artifactId>
        <version>5.3.9</version>
        <scope>compile</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.3.9</version>
        <scope>compile</scope>
    </dependency>
</dependencies>

​ 之前提到过开发SpringMVC程序需要导入spring-webmvc的坐标和spring整合web开发的坐标，就是上面这组坐标中的最后两个了。

​ 除了这两个还有其他的，比如第二个，叫做spring-boot-starter-json。看名称就知道，这个是与json有关的坐标了它的名字中也有starter，打开后里面如下

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
        <version>2.5.4</version>
        <scope>compile</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-web</artifactId>
        <version>5.3.9</version>
        <scope>compile</scope>
    </dependency>
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>2.12.4</version>
        <scope>compile</scope>
    </dependency>
    <dependency>
        <groupId>com.fasterxml.jackson.datatype</groupId>
        <artifactId>jackson-datatype-jdk8</artifactId>
        <version>2.12.4</version>
        <scope>compile</scope>
    </dependency>
    <dependency>
        <groupId>com.fasterxml.jackson.datatype</groupId>
        <artifactId>jackson-datatype-jsr310</artifactId>
        <version>2.12.4</version>
        <scope>compile</scope>
    </dependency>
    <dependency>
        <groupId>com.fasterxml.jackson.module</groupId>
        <artifactId>jackson-module-parameter-names</artifactId>
        <version>2.12.4</version>
        <scope>compile</scope>
    </dependency>
</dependencies>

​ 这个starter中又包含了若干个坐标，其实就是使用SpringMVC开发通常都会使用到Json，使用json又离不开这里面定义的这些坐标，SpringBoot把开发中使用的东西能用到的都给提前做好了。

​ 使用starter可以帮开发者快速配置依赖关系。以前写依赖3个坐标的，现在写导入一个就搞定了，就是加速依赖配置的。

starter与parent的区别

​
​ starter是一个坐标中定了若干个坐标，以前写多个的，现在写一个，是用来减少依赖配置的书写量的

​ parent是定义了几百个依赖版本号，以前写依赖需要自己手工控制版本，现在由SpringBoot统一管理，这样就不存在版本冲突了，是用来减少依赖冲突的

实际开发应用方式

• 实际开发中如果需要用什么技术，先去找有没有这个技术对应的starter

  • 如果有对应的starter，直接写starter，而且无需指定版本，版本由parent提供
  • 如果没有对应的starter，手写坐标即可

• 实际开发中如果发现坐标出现了冲突现象，确认你要使用的可行的版本号，使用手工书写的方式添加对应依赖，覆盖SpringBoot提供给我们的配置管理

  • 方式一：直接写坐标
  • 方式二：覆盖中定义的版本号，就是下面这堆东西了，哪个冲突了覆盖哪个就OK了

  <properties>
      <activemq.version>5.16.3</activemq.version>
      <aspectj.version>1.9.7</aspectj.version>
      <assertj.version>3.19.0</assertj.version>
      <commons-codec.version>1.15</commons-codec.version>
      <commons-dbcp2.version>2.8.0</commons-dbcp2.version>
      <commons-lang3.version>3.12.0</commons-lang3.version>
      <commons-pool.version>1.6</commons-pool.version>
      <commons-pool2.version>2.9.0</commons-pool2.version>
      <h2.version>1.4.200</h2.version>
      <hibernate.version>5.4.32.Final</hibernate.version>
      <hibernate-validator.version>6.2.0.Final</hibernate-validator.version>
      <httpclient.version>4.5.13</httpclient.version>
      <jackson-bom.version>2.12.4</jackson-bom.version>
      <javax-jms.version>2.0.1</javax-jms.version>
      <javax-json.version>1.1.4</javax-json.version>
      <javax-websocket.version>1.1</javax-websocket.version>
      <jetty-el.version>9.0.48</jetty-el.version>
      <junit.version>4.13.2</junit.version>
  </properties>
  

总结

1. 开发SpringBoot程序需要导入坐标时通常导入对应的starter
2. 每个不同的starter根据功能不同，通常包含多个依赖坐标
3. 使用starter可以实现快速配置的效果，达到简化配置的目的

2.3 引导类

​ SpringBoot确实帮助我们减少了很多配置工作，下面说一下程序是如何运行的。目前程序运行的入口就是SpringBoot工程创建时自带的那个类了，带有main方法的那个类，运行这个类就可以启动SpringBoot工程的运行

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

​ SpringBoot本身是为了加速Spring程序的开发的，而Spring程序运行的基础是需要创建自己的Spring容器对象（IoC容器）并将所有的对象交给Spring的容器管理，也就是一个一个的Bean。SpringBoot加速开发Spring程序，这个容器还在。当前这个类运行后就会产生一个Spring容器对象，并且可以将这个对象保存起来，通过容器对象直接操作Bean。

@SpringBootApplication
public class Demo4Application {

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

}

​ SpringBoot程序启动还是创建了一个Spring容器对象。这个类在SpringBoot程序中是所有功能的入口，称这个类为引导类。

​ 作为一个引导类最典型的特征就是当前类上方声明了一个注解@SpringBootApplication

总结

1. SpringBoot工程提供引导类用来启动程序
2. SpringBoot工程启动后创建并初始化Spring容器

2.4 内嵌tomcat

​ 当前我们做的SpringBoot入门案例勾选了Spirng-web的功能，并且导入了对应的starter。

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

​ 如果要做web程序，自然离不开使用web服务器，SpringBoot内置了一个web服务器，开发者可以直接使用也可以自己设置。由于这个功能不属于程序的主体功能，可用可不用，于是乎SpringBoot将其定位成辅助功能，

​ 下面就围绕着这个内置的web服务器，也可以说是内置的tomcat服务器来研究几个问题

1. 这个服务器在什么位置定义的
2. 这个服务器是怎么运行的
3. 这个服务器如果想换怎么换

内嵌Tomcat定义位置

​ 导入的web相关的starter做的这件事。

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

​ 打开查看web的starter

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
        <version>2.5.4</version>
        <scope>compile</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-json</artifactId>
        <version>2.5.4</version>
        <scope>compile</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-tomcat</artifactId>
        <version>2.5.4</version>
        <scope>compile</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-web</artifactId>
        <version>5.3.9</version>
        <scope>compile</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.3.9</version>
        <scope>compile</scope>
    </dependency>
</dependencies>

​ 第三个依赖就是tomcat对应的东西，也是一个starter

<dependencies>
    <dependency>
        <groupId>jakarta.annotation</groupId>
        <artifactId>jakarta.annotation-api</artifactId>
        <version>1.3.5</version>
        <scope>compile</scope>
    </dependency>
    <dependency>
        <groupId>org.apache.tomcat.embed</groupId>
        <artifactId>tomcat-embed-core</artifactId>
        <version>9.0.52</version>
        <scope>compile</scope>
        <exclusions>
            <exclusion>
                <artifactId>tomcat-annotations-api</artifactId>
                <groupId>org.apache.tomcat</groupId>
            </exclusion>
        </exclusions>
    </dependency>
    <dependency>
        <groupId>org.apache.tomcat.embed</groupId>
        <artifactId>tomcat-embed-el</artifactId>
        <version>9.0.52</version>
        <scope>compile</scope>
    </dependency>
    <dependency>
        <groupId>org.apache.tomcat.embed</groupId>
        <artifactId>tomcat-embed-websocket</artifactId>
        <version>9.0.52</version>
        <scope>compile</scope>
        <exclusions>
            <exclusion>
                <artifactId>tomcat-annotations-api</artifactId>
                <groupId>org.apache.tomcat</groupId>
            </exclusion>
        </exclusions>
    </dependency>
</dependencies>

​ 这里面有一个核心的坐标，tomcat-embed-core，叫做tomcat内嵌核心。就是这个坐标把tomcat功能引入到了我们的程序中。spring-boot-starter-web中的spring-boot-starter-tomcat把tomcat引入到程序中。

内嵌Tomcat运行原理

​ Tomcat服务器是一款软件，而且是一款使用java语言开发的软件tomcat安装目录中保存有jar，好多个jar。java程序运行原理是：一切皆对象，万物皆对象。那tomcat运行的原理也是对象。

​ tomcat服务器运行其实是以对象的形式在Spring容器中运行的，以一个对象的形式存在，保存在Spring容器中运行的。具体运行的是前面提到的tomcat内嵌核心

<dependencies>
    <dependency>
        <groupId>org.apache.tomcat.embed</groupId>
        <artifactId>tomcat-embed-core</artifactId>
        <version>9.0.52</version>
        <scope>compile</scope>
    </dependency>
</dependencies>

更换内嵌Tomcat

​ 根据SpringBoot的工作机制，用什么技术，加入什么依赖就行了。SpringBoot提供了3款内置的服务器

• tomcat(默认)：apache出品，粉丝多，应用面广，负载了若干较重的组件

• jetty：更轻量级，负载性能远不及tomcat

• undertow：负载性能勉强跑赢tomcat

  想用哪个，加个坐标就OK。前提是把tomcat排除掉，因为tomcat是默认加载的。

<dependencies>
    <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>
</dependencies>

​ 现在就已经成功替换了web服务器，核心思想就是用什么加入对应坐标就可以了。如果有starter，优先使用starter。

总结

1. 内嵌Tomcat服务器是SpringBoot辅助功能之一
2. 内嵌Tomcat工作原理是将Tomcat服务器作为对象运行，并将该对象交给Spring容器管理
3. 变更内嵌服务器思想是去除现有服务器，添加全新的服务器

3 SpringBoot基础配置

3.1 属性配置

​ SpringBoot默认配置文件是application.properties，SpringBoot通过配置文件application.properties修改默认的配置，properties格式的文件书写规范是key=value

name=xiaoming

​ 例如改端口，默认的是8080，写port。

server.port=80

1. SpringBoot程序可以在application.properties文件中进行属性配置
2. application.properties文件中只要输入要配置的属性关键字就可以根据提示进行设置
3. SpringBoot将配置信息集中在一个文件中写，不管你是服务器的配置，还是数据库的配置，总之都写在一起，逃离一个项目十几种配置文件格式的尴尬局面

关闭运行日志图表（banner)

spring.main.banner-mode=off

设置运行日志的显示级别

logging.level.root=debug

​ 在SpringBoot的官网，SpringBoot官方文档中有具体的配置项介绍，打开查看附录中的Application Properties就可以获取到对应的配置项了，https://docs.spring.io/spring-boot/docs/current/reference/html/application-properties.html#application-properties

​ 所有的starter中都会依赖下面这个starter，spring-boot-starter。这个starter是所有的SpringBoot的starter的基础依赖，里面定义了SpringBoot相关的基础配置。

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
    <version>2.5.4</version>
    <scope>compile</scope>
</dependency>

总结

1. SpringBoot中导入对应starter后，提供对应配置属性
2. 书写SpringBoot配置采用关键字+提示形式书写

3.2 配置文件分类

​ SpringBoot除了支持properties格式的配置文件，还支持另外两种格式的配置文件。分别如下:

• properties格式

• yml格式

• yaml格式

  ---

application.properties（properties格式）

server.port=80

• application.yml（yml格式）

server:
  port: 81

• application.yaml（yaml格式）

server:
  port: 82

​ yml格式和yaml格式除了文件名后缀不一样，格式完全一样。

3.2.1 配置文件优先级

​ 其实三个文件如果共存的话，优先级如下：

application.properties  >  application.yml  >  application.yaml

不同配置文件中相同配置按照加载优先级相互覆盖，不同配置文件中不同配置全部保留
​

3.3 yaml文件

​ SpringBoot的配置可以使用yml结尾的这种文件格式，并且在书写时可以通过提示的形式加载正确的格式。但是这种文件还是有严格的书写格式要求的。

​ YAML（YAML Ain’t Markup Language），一种数据序列化格式。具有容易阅读、容易与脚本语言交互、以数据为核心，重数据轻格式的特点。常见的文件扩展名有两种：

• .yml格式（主流）

• .yaml格式

  对于文件自身在书写时，具有严格的语法格式要求，具体如下：

1. 大小写敏感
2. 属性层级关系使用多行描述，每行结尾使用冒号结束
3. 使用缩进表示层级关系，同层级左侧对齐，只允许使用空格（不允许使用Tab键）
4. 属性值前面添加空格（属性名与属性值之间使用冒号+空格作为分隔）
5. #号 表示注释

核心的一条规则，数据前面要加空格与冒号隔开

​ 常见的数据书写格式如下

boolean: TRUE  						#TRUE,true,True,FALSE,false，False均可
float: 3.14    						#6.8523015e+5  #支持科学计数法
int: 123       						#0b1010_0111_0100_1010_1110    #支持二进制、八进制、十六进制
null: ~        						#使用~表示null
string: HelloWorld      			#字符串可以直接书写
string2: "Hello World"  			#可以使用双引号包裹特殊字符
date: 2018-02-17        			#日期必须使用yyyy-MM-dd格式
datetime: 2018-02-17T15:02:31+08:00  #时间和日期之间使用T连接，最后使用+代表时区

​ 此外，yaml格式中也可以表示数组，在属性名书写位置的下方使用减号作为数据开始符号，每行书写一个数据，减号与数据间空格分隔

subject:
	- Java
	- 前端
	- 大数据
enterprise:
	name: itcast
    age: 16
    subject:
    	- Java
        - 前端
        - 大数据
likes: [小明,小红]			#数组书写缩略格式
users:							 #对象数组格式一
  - name: Tom
   	age: 4
  - name: Jerry
    age: 5
users:							 #对象数组格式二
  -  
    name: Tom
    age: 4
  -   
    name: Jerry
    age: 5			    
users2: [ { name:Tom , age:4 } , { name:Jerry , age:5 } ]	#对象数组缩略格式

总结

1. yaml语法规则
   • 大小写敏感
   • 属性层级关系使用多行描述，每行结尾使用冒号结束
   • 使用缩进表示层级关系，同层级左侧对齐，只允许使用空格（不允许使用Tab键）
   • 属性值前面添加空格（属性名与属性值之间使用冒号+空格作为分隔）
   • #号 表示注释
2. 注意属性名冒号后面与数据之间有一个空格
3. 字面值、对象数据格式、数组数据格式

3.4 yaml数据读取

3.4.1 读取单一数据

​ yaml中保存的单个数据，可以使用Spring中的注解直接读取，使用@Value可以读取单个数据，属性名引用方式：${一级属性名.二级属性名……}

​ 使用@Value注解时，要将该注入写在某一个指定的Spring管控的bean的属性名上方。

总结

1. 使用@Value配合SpEL读取单个数据
2. 如果数据存在多层级，依次书写层级名称即可

3.4.2 读取全部数据

​ 读取单一数据可以解决读取数据的问题，但是如果定义的数据量过大，单一读写会造成繁琐的工作，SpringBoot提供了一个对象，能够把所有的数据都封装到这一个对象中，这个对象叫做Environment，使用自动装配注解可以将所有的yaml数据封装到这个对象中

​ 数据封装到了Environment对象中，获取属性时，通过Environment的接口操作进行，具体方法时getProperties（String），参数填写属性名即可

总结

1. 使用Environment对象封装全部配置信息
2. 使用@Autowired自动装配数据到Environment对象中

3.4.3 读取对象数据

​ 单一数据读取书写比较繁琐，全数据封装每次拿数据需要一个一个的getProperties（。由于Java是一个面向对象的语言，很多情况下，我们会将一组数据封装成一个对象。SpringBoot也提供了可以将一组yaml对象数据封装一个Java对象的操作

​ 首先定义一个对象，并将该对象纳入Spring管控的范围，也就是定义成一个bean，然后使用注解@ConfigurationProperties指定该对象加载哪一组yaml中配置的信息。

​ 使用@ConfigurationProperties必须声明他加载的数据前缀，这样当前前缀下的所有属性就封装到这个对象中。数据属性名要与对象的变量名一一对应。

总结

1. 使用@ConfigurationProperties注解绑定配置信息到封装类中
2. 封装类需要定义为Spring管理的bean，否则无法进行属性注入

3.4.4 yaml文件中的数据引用

​ 在书写yaml数据时，经常出现如下现象，比如很多个文件都具有相同的目录前缀

center:
	dataDir: /usr/local/fire/data
    tmpDir: /usr/local/fire/tmp
    logDir: /usr/local/fire/log
    msgDir: /usr/local/fire/msgDir

或者

center:
	dataDir: D:/usr/local/fire/data
    tmpDir: D:/usr/local/fire/tmp
    logDir: D:/usr/local/fire/log
    msgDir: D:/usr/local/fire/msgDir

​ 这个时候可以使用引用格式来定义数据，其实就是定义了一个变量名，然后引用变量，格式如下：

baseDir: /usr/local/fire
	center:
    dataDir: ${baseDir}/data
    tmpDir: ${baseDir}/tmp
    logDir: ${baseDir}/log
    msgDir: ${baseDir}/msgDir

​ 有一个注意事项，在书写字符串时，如果需要使用转义字符，需要将数据字符串使用双引号包裹起来

lesson: "Spring\tboot\nlesson"

总结

1. 在配置文件中可以使用${属性名}方式引用属性值
2. 如果属性中出现特殊字符，可以使用双引号包裹起来作为字符解析

4 基于SpringBoot实现SSMP整合

4.1 整合JUnit

​ SpringBoot技术的定位用于简化开发，再具体点是简化Spring程序的开发。

​ 不使用SpringBoot技术时，Spring整合JUnit的制作方式

//加载spring整合junit专用的类运行器
@RunWith(SpringJUnit4ClassRunner.class)
//指定对应的配置信息
@ContextConfiguration(classes = SpringConfig.class)
public class AccountServiceTestCase {
    //注入你要测试的对象
    @Autowired
    private AccountService accountService;
    @Test
    public void testGetById(){
        //执行要测试的对象对应的方法
        System.out.println(accountService.findById(2));
    }
}

​ 其中核心代码是前两个注解，第一个注解@RunWith是设置Spring专用于测试的类运行器，简单说就是Spring程序执行程序有自己的一套独立的运行程序的方式，不能使用JUnit提供的类运行方式了，必须指定一下，但是格式是固定的，每次都指定一样的东西，第二个注解@ContextConfiguration是用来设置Spring核心配置文件或配置类的，就是加载Spring的环境时要告诉Spring具体的环境配置是在哪，虽然每次加载的文件都有可能不同，但是如果文件名是固定的，也是一个固定格式。有可能是固定格式，那就有可能每次都写一样的东西
​ SpringBoot就抓住上述两条没有技术含量的内容书写进行开发简化，能走默认值的走默认值，能不写的就不写，具体格式如下

@SpringBootTest
class Springboot04JunitApplicationTests {
    //注入你要测试的对象
    @Autowired
    private BookDao bookDao;
    @Test
    void contextLoads() {
        //执行要测试的对象对应的方法
        bookDao.save();
        System.out.println("two...");
    }
}

​ 一个注解就搞定了，而且还没有参数SpringBoot整合其他技术的优势在于简化。使用一个注解@SpringBootTest替换了前面两个注解。

​ 加载的配置类或者配置文件是前面启动程序使用的引导类。如果想手工指定引导类有两种方式，第一种方式使用属性的形式进行，在注解@SpringBootTest中添加classes属性指定配置类

@SpringBootTest(classes = Springboot04JunitApplication.class)
class Springboot04JunitApplicationTests {
    //注入你要测试的对象
    @Autowired
    private BookDao bookDao;
    @Test
    void contextLoads() {
        //执行要测试的对象对应的方法
        bookDao.save();
        System.out.println("two...");
    }
}

​ 第二种方式仍然使用@ContextConfiguration注解进行，效果是一样的

@SpringBootTest
@ContextConfiguration(classes = Springboot04JunitApplication.class)
class Springboot04JunitApplicationTests {
    //注入你要测试的对象
    @Autowired
    private BookDao bookDao;
    @Test
    void contextLoads() {
        //执行要测试的对象对应的方法
        bookDao.save();
        System.out.println("two...");
    }
}

​ 温馨提示

​ 使用SpringBoot整合JUnit需要保障导入test对应的starter，由于初始化项目时此项是默认导入的。

总结

1. 导入测试对应的starter
2. 测试类使用@SpringBootTest修饰
3. 使用自动装配的形式添加要测试的对象
4. 测试类如果存在于引导类所在包或子包中无需指定引导类
5. 测试类如果不存在于引导类所在的包或子包中需要通过classes属性指定引导类

4.2 整合MyBatis

​ Spring整合MyBatis如下，以配置类的形式为例

• 导入坐标，MyBatis坐标不能少，Spring整合MyBatis还有自己专用的坐标，此外Spring进行数据库操作的jdbc坐标是必须的，剩下还有mysql驱动坐标，本例中使用了Druid数据源，这个倒是可以不要

  <dependencies>
      <dependency>
          <groupId>com.alibaba</groupId>
          <artifactId>druid</artifactId>
          <version>1.1.16</version>
      </dependency>
      <dependency>
          <groupId>org.mybatis</groupId>
          <artifactId>mybatis</artifactId>
          <version>3.5.6</version>
      </dependency>
      <dependency>
          <groupId>mysql</groupId>
          <artifactId>mysql-connector-java</artifactId>
          <version>5.1.47</version>
      </dependency>
      <!--1.导入mybatis与spring整合的jar包-->
      <dependency>
          <groupId>org.mybatis</groupId>
          <artifactId>mybatis-spring</artifactId>
          <version>1.3.0</version>
      </dependency>
      <!--导入spring操作数据库必选的包-->
      <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-jdbc</artifactId>
          <version>5.2.10.RELEASE</version>
      </dependency>
  </dependencies>
  

• Spring核心配置

  @Configuration
  @ComponentScan("com.itheima")
  @PropertySource("jdbc.properties")
  public class SpringConfig {
  }
  

• MyBatis要交给Spring接管的bean

  //定义mybatis专用的配置类
  @Configuration
  public class MyBatisConfig {
  //    定义创建SqlSessionFactory对应的bean
      @Bean
      public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource){
          //SqlSessionFactoryBean是由mybatis-spring包提供的，专用于整合用的对象
          SqlSessionFactoryBean sfb = new SqlSessionFactoryBean();
          //设置数据源替代原始配置中的environments的配置
          sfb.setDataSource(dataSource);
          //设置类型别名替代原始配置中的typeAliases的配置
          sfb.setTypeAliasesPackage("com.itheima.domain");
          return sfb;
      }
  //    定义加载所有的映射配置
      @Bean
      public MapperScannerConfigurer mapperScannerConfigurer(){
          MapperScannerConfigurer msc = new MapperScannerConfigurer();
          msc.setBasePackage("com.itheima.dao");
          return msc;
      }
  
  }
  

• 数据源对应的bean，此处使用Druid数据源

  @Configuration
  public class JdbcConfig {
      @Value("${jdbc.driver}")
      private String driver;
      @Value("${jdbc.url}")
      private String url;
      @Value("${jdbc.username}")
      private String userName;
      @Value("${jdbc.password}")
      private String password;
  
      @Bean("dataSource")
      public DataSource dataSource(){
          DruidDataSource ds = new DruidDataSource();
          ds.setDriverClassName(driver);
          ds.setUrl(url);
          ds.setUsername(userName);
          ds.setPassword(password);
          return ds;
      }
  }
  

• 数据库连接信息（properties格式）

  jdbc.driver=com.mysql.jdbc.Driver
  jdbc.url=jdbc:mysql://localhost:3306/spring_db?useSSL=false
  jdbc.username=root
  jdbc.password=root
  

  上述格式为spring整合MyBaits格式。SpringBoot整合MyBaits格式如下

步骤①：创建模块时勾选要使用的技术，MyBatis，由于要操作数据库，还要勾选对应数据库

​ 或者手工导入对应技术的starter，和对应数据库的坐标

<dependencies>
    <!--1.导入对应的starter-->
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>2.2.0</version>
    </dependency>

    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <scope>runtime</scope>
    </dependency>
</dependencies>

步骤②：配置数据源相关信息

#2.配置相关信息
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/ssm_db
    username: root
    password: root

​ 下面就可以写一下MyBatis程序运行需要的Dao（或者Mapper）就可以运行了

实体类

public class Book {
    private Integer id;
    private String type;
    private String name;
    private String description;
}

映射接口（Dao）

@Mapper
public interface BookDao {
    @Select("select * from tbl_book where id = #{id}")
    public Book getById(Integer id);
}

测试类

@SpringBootTest
class Springboot05MybatisApplicationTests {
    @Autowired
    private BookDao bookDao;
    @Test
    void contextLoads() {
        System.out.println(bookDao.getById(1));
    }
}

4.3 整合MyBatis-Plus

​ 整合的步骤如下：

• 导入对应技术的starter坐标
• 根据对应技术的要求做配置

步骤①：导入对应的starter

<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.4.3</version>
</dependency>

​ SpringBoot官网还未收录此坐标，而Idea创建模块时读取的是SpringBoot官网的Spring Initializr，所以也没有。如果换用阿里云的url创建项目可以找到对应的坐标

步骤②：配置数据源相关信息

#2.配置相关信息
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/ssm_db
    username: root
    password: root

​

映射接口（Dao）

@Mapper
public interface BookDao extends BaseMapper<Book> {
}

​ 核心在于Dao接口继承了一个BaseMapper的接口，这个接口中帮助开发者预定了若干个常用的API接口，简化了通用API接口的开发工作。

总结

1. 手工添加MyBatis-Plus对应的starter
2. 数据层接口使用BaseMapper简化开发
3. 需要使用的第三方技术无法通过勾选确定时，需要手工添加坐标

4.4 整合Druid

​ 前面整合MyBatis和MP的时候，使用的数据源对象都是SpringBoot默认的数据源对象，下面指定了一个数据源对象，Druid。

​ 在没有指定数据源时，配置如下：

#2.配置相关信息
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/ssm_db?serverTimezone=Asia/Shanghai
    username: root
    password: root

​ 此时虽然没有指定数据源，但是根据SpringBoot默认指定了HiKari。通过启动日志可以查看到对应的身影。

如果需要更换数据源，只需要两步即可。

步骤①：导入对应的坐标（注意，是坐标，不是starter）

<dependencies>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>1.1.16</version>
    </dependency>
</dependencies>

步骤②：修改配置，在数据源配置中有一个type属性，专用于指定数据源类型

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/ssm_db?serverTimezone=UTC
    username: root
    password: root
    type: com.alibaba.druid.pool.DruidDataSource

​ 如果对数据源进行个性化的配置，例如配置数据源对应的连接数量，每个数据源技术对应的配置不同，就要使用专用的配置格式了。按照SpringBoot整合其他技术的通用规则，只需导入对应的starter，进行相应的配置即可。

步骤①：导入对应的starter

<dependencies>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid-spring-boot-starter</artifactId>
        <version>1.2.6</version>
    </dependency>
</dependencies>

步骤②：修改配置

spring:
  datasource:
    druid:
      driver-class-name: com.mysql.cj.jdbc.Driver
      url: jdbc:mysql://localhost:3306/ssm_db?serverTimezone=UTC
      username: root
      password: root

​ 配置项中，在datasource下面并不是直接配置url这些属性的，而是先配置了一个druid节点，然后再配置的url这些东西。url这个属性时druid下面的属性，除了这4个常规配置外，还有druid专用的其他配置。

总结

1. 整合Druid需要导入Druid对应的starter
2. 根据Druid提供的配置方式进行配置
3. 整合第三方技术通用方式
   • 导入对应的starter
   • 根据提供的配置格式，配置非默认值对应的配置项