Spring Boot | SpringBoo“开发入门“

- 1.SpringBoot的“介绍”
- - SpringBoot”概述” ：
  - SpringBoot”简介“
  - SpringBoot的“优点”
- 2. SpringBoot入门程序
- - 环境准备
  - 使用 “Maven”方式构建SpringBoot 项目
  - 使用“Spring Initializr”方式构建Spring Boot 项目
- 3. “单元测试” 和“热部署”
- - 单元测试
  - 热部署
- 4. Spring Boot”原理分析”
- - 4.1Spring Boot”依赖管理“
  - - spring-boot-starter-parent 依赖
    - spring-boot-starter-web 依赖
  - Spring Boot自动配置
  - - @SpringBootConfiguration
    - @EnableAutoConfiguration

作者简介 ：一只大皮卡丘，计算机专业学生，正在努力学习、努力敲代码中! 让我们一起继续努力学习！

该文章参考学习教材为：
《Spring Boot企业级开发教程》 黑马程序员 / 编著
文章以课本知识点 + 代码为主线，结合自己看书学习过程中的理解和感悟，最终成就了该文章

文章用于本人学习使用 ，同时希望能帮助大家。
欢迎大家点赞👍 收藏⭐ 关注💖哦！！！

（侵权可联系我，进行删除，如果雷同，纯属巧合）

1.SpringBoot的“介绍”

SpringBoot”概述” ：

随着互联网的兴起，Spring 势如破竹地占据了Java领域“轻量级”开发的王者之位。随着 Java语言的发展以及市场开发的需求，Spring推陈出新，推出了 全新的Spring Boot 框架。Spring Boot 是 Spring家族 的一个 子项目，其 设计初衷是为了 简化Spring配置，从而让用户可以轻松构建独立运行的程序，并极大提高开发率。

SpringBoot”简介“

在 SpringBoot框架出现之前，JavaEE开发最常用的框架是Spring，Spring框架开始于2003年，它是由罗德·约翰逊(Rod Johnson)创建的一个 轻量级开源框架。Spring框架是为了 解决企业应用开发的复杂性而创建的，它的出现使得开发者无须开发重量级的Enterprise JavaBean( EJB )，而是通过 控制反转(IOC) 和 面向切面编程(AOP) 的思想进行更轻松的企业应用开发，取代了 EJB 臃肿、低效的开发模式。
虽然Spring 框架是轻量级的，但 Spring的配置却是重量级的。Spring 的早期版本专注于 XML配置，开发一个程序需要 配置各种XML 配置文件 。为了简化开发，在Spring 2.x版本开始 引入少量的注解 : @Component、@Service 等。由于支持的注解不是很多且功能尚不完善，所以只能辅助使用。
随着 实际生产中敏捷开发的需要，以及Spring 注解的大量出现和功能改进，到了 Spring 4.x版本基本可以脱离XML配置文件进行项目开发，多数开发者也逐渐感受到了基于注解开发的便利，因此，在Spring 中使用注解开发逐渐占据了主流地位。与此同时，Pivotal 团队在原有Spring框架的基础上通过注解的方式进一步简化了Spring 框架的使用，并基于Spring框架开发了全新的 SpringBoot框架，于 2014 年4月正式推出了 SpringBoot1.0 版本，同时在 2018 年3月又推出了 Spring Boot 2.0 版本。Spring Boot 2.x 版本在Spring Boot 1.x版本的基础上进行了诸多功能的改进和扩展，同时进行了大量的代码重构，所以选择合适的版也是非常重要的。 Spring Boot 3.0 在 2022年 11月24日正式发布。
SpringBoot框架本身 并 不提供Spring 框架的核心特性以及扩展功能，只是用于快速、敏捷地开发新一代基于 Spring 框架的应用，并且在开发过程中大量使用“约定优先配置”( convention over configuration )的思想来 摆脱 Spring 框架中各种复杂的手动配置，同时衍生出了 Java Config ( 取代传统XML配置文件的Java 配置类)这种优秀的配置方式。也就是说， Spring Boot 并不是替代 Spring 框架 的 解决方案，而是和 Spring框架紧密结合 用于 提升Spring开发者体验 的工具，同时Spring Boot 还集成了大量常用的 第三方库配置 ( 例如Jackson、JDBC、Redis、Mail 等)。使用 Spring Boot 开发程序时，几乎是 开箱即用 (out-of-the-box )，大部分 Spring Boot 应用只需少量配置就能完成相应的功能，这一特性进一步 促使开发者专注于业务逻辑 的实现。
而Spring Boot框架的出现恰好完美地 解决了怎么快速、便捷地构建一个准生产环境的Spring应用 这些问题，同时其内部还 简化了许多常用 的 第三方库配置，使得微服务开发更加便利。

SpringBoot的“优点”

相较于传统的 Spring 框架，Spring Boot 框架 具有以下优点 :

可快速构建独立的 Spring 应用 :
Spring Boot 是一个依靠大量注解 实现 自动化配置的全新框架。在构建 Spring 应用时，我们添加相应的场景依赖， Spring Boot 就会根据添加的场景依赖 自动进行配置，在 无须额外手动添加配置 的情况下快速构建出一个独立的Spring 应用。

直接嵌入Tomcat、Jetty 和Undertow服务器 ( 无须部署WAR文件，无需手动打包) ：
传统的 Spring 应用部署时，通常会将应用打成WAR 包形式并部署到Tomcat、Jetty 或Undertow服务器 ( 传统Spring项目要手动打包，而SpringBoot开发不需要手动打包 )中。SpringBoot 框架内嵌了Tomcat、Jetty 和 Undertow服务器， SpringBoot会自动将项目打包 (不用手动打包)并在项目运行时部署到服务器中。

通过 “依赖启动器” 简化构建配置 :
在SpringBoot 项目构建过程中，无须准备各种独立的JAR 文件，只需在构建项目时根据开发场景需求选择对应的 依赖启动器“starter”，在引入的依赖启动器“starter”内部已经包含了对应开发场景所需的依赖，并会自动下载和拉取相关JAR包。
例如，在Web 开发时，只需在构建项目时选择对应的 Web场景依赖 启动器 spring-boot-starter-web，Spring Boot项目便会 自动导入spring-webmvc、spring-web、spring-boot-starter-tomcat等子依赖，并自动下载和获取 Web 开发需要的相关JAR 包。

自动化配置 Spring和第三方库 :
SpringBoot 充分考虑到与传统Spring 框架以及其他第三方库融合的场景，在提供了各种 场景依赖启动器 的基础上，内部还默认 提供了各种 自动化配置类( 例如RedisAuto Configuration )。使用 SpringBoot开发项目时，一旦 引入了某个场景的依赖启动器，SpringBoot内部提供的 默认自动化配置类就会生效，开发者无须手动在配置文件中进行相关配置 ( 除非开发者需要更改默认配置)，从而极大减少了开发人员的工作量，提高了程序的开发效率。

提供生产就绪功能 :
SpringBoot 提供了一些 用于生产环境运行时的特性，例如指标、监控检查 和 外部化配置。其中，指标和监控检查可以帮助运维人员在运维期间监控项目运行情况；外部化配置可以使运维人员快速、方便地进行外部化配置和部署工作。

极少的代码生成和 极少的XML配置 ：

SpringBoot 框架内部已经实现了与Spring以及其他常用第三方库的整合连接，并提供了默认最优化的整合配置，使用时基本上不需要额外生成配置代码 和 XML配置文件。在需要自定义配置的情况下，SpringBoot 更加提倡使用Java config( Java配置类) 替换传统的XML配置方式，这样更加方便查看和管理。

2. SpringBoot入门程序

环境准备

JDK环境 :
SpringBoot 2.0及以上版本要求的JDK版本最低是Java 8。
项目构建工具 ：需要使用 Maven 和 Gradle 。如 : SpringBoot 2.1.3 要求 Maven ( 3.3 + ) ，
Gradle ( 4.4+ )
开发工具 : IntelliJIDEA ，其在 智能代码助手、重构、各类版本工具( Git、SVN 等)支持等方面的功能非常不错。

使用 “Maven”方式构建SpringBoot 项目

第一步、添加SpringBoot依赖 ：

<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.myh</groupId>
    <artifactId>chapter_01</artifactId>
    <version>1.0-SNAPSHOT</version>

    <!-- "依赖启动器"的parent依赖 : 统一父类管理依赖  -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.3.RELEASE</version>
    </parent>

    <dependencies>
        <!-- 引入web开发依赖 (引入“web场景依赖”)   -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

</project>

第二步、编写主程序启动类 ：

package com.myh;

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

/**
 * "主程序类" 和有"操作代码的"包和文件要在同一个文件夹下
 */
@SpringBootApplication //标记该类为"主程序启动类"
public class ManualChapter01Application {
    //主程序启动方法
    public static void main(String[] args) {
        SpringApplication.run(ManualChapter01Application.class, args);
    }
}

上述代码中，@SpringBootApplication注解 是Spring Boot 框架的 核心注解，该注解用于表明ManualChapter01Application类是Spring boot项目的 主程序启动类。然后调用SpringApplication对象的 .run( )方法启动主程序类。

第三步、创建一个 用于Web访问的Controller ：

package com.myh.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController // 组合注解 : 该注解 = @ResponseBody + @Controller
public class HelloController {

    @GetMapping("/hello")
    public String hello() {
        return "hello Spring Boot";
    }
}

运行 主程序启动类，启动成功后，此时在浏览器上访问 http://localhost:8080/hello 。

使用“Spring Initializr”方式构建Spring Boot 项目

除了可以使用Maven方式构建SpringBoot 项目外，还可以通过 Spring Initializr 方式快速构建 Spring Boot 项目。从本质上说，SpringInitializr 是一个 Web 应用，它提供了一个基本的项目结构，能够帮助我们快速构建一个基础的Spring Boot 项目。

具体的代码文件 ：

Chapter02Application.java :

package com.myh.chapter_02;

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

@SpringBootApplication
public class Chapter02Application {

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

HelloController.java ：

package com.myh.chapter_02.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController // 组合注解 : 该注解 = @ResponseBody + @Controller
public class HelloController {

    @GetMapping("/hello2")
    public String hello() {
        return "hello Spring Boot2";
    }
}

pom.xml :

<?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.1.3.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <groupId>com.myh</groupId>
    <artifactId>chapter_02</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>chapter_02</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>17</java.version>
    </properties>
    <dependencies>

        <!--   web模块依赖启动器    -->
        <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>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter</artifactId>
            <version>RELEASE</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

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

</project>

运行 主程序启动类，启动成功后，此时在浏览器上访问 http://localhost:8080/hello2 。

3. “单元测试” 和“热部署”

单元测试

在实际开发中，每当 完成一个功能接口或业务方法 的 编写后，通常都会借助 单元测试 验证该功能是否正确。Spring Boot 对项目的单元测试提供了很好的支持，在使用时，需要提前在项目的 pom.xml 文件中添加 spring-boot-starter-test 测试依赖启动器，可以通过相关注解 实现单元测试。
```
 
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>
```
在项目中添 加测试依赖启动器后，可以编写SpringBoot项目中相关方法对应的单元测试。如果是使用Spring Initializr 方式搭建的 Spring Boot 项目，会在src.test.java 测试目录下自动创建与项目主程序启动类对应的 单元测试类。例如，chapter2 项目的 Chapter02ApplicationTests 是自动生成的“单元测试类” :

Chapter02Application.java :

package com.myh.chapter_02;

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

@SpringBootApplication
public class Chapter02Application {

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

pom.xml :

<?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.1.3.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <groupId>com.myh</groupId>
    <artifactId>chapter_02</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>chapter_02</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>17</java.version>
    </properties>
    <dependencies>

        <!--   web模块依赖启动器    -->
        <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>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter</artifactId>
            <version>RELEASE</version>
            <scope>test</scope>
        </dependency>

    </dependencies>

    <!--   Maven打包工具插件   -->
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

HelloController.java :

package com.myh.chapter_02.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController // 组合注解 : 该注解 = @ResponseBody + @Controller
public class HelloController {

    @GetMapping("/hello2")
    public String hello() {
        return "hello Spring Boot(单元测试)";
    }
}

Chapter02ApplicationTests.java :

package com.myh.chapter_02;

import com.myh.chapter_02.controller.HelloController;
import org.junit.jupiter.api.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class) //测试运行器，并加载SpringBoot测试注解
@SpringBootTest //标记为类为"单元测试类",并加载项目的上下文环境ApplicationContext
class Chapter02ApplicationTests {


    @Autowired
    private HelloController helloController;

    /**
     * 使用"单元测试"运行方法
     */
    @Test //单元测试方法
    public void helloController() {
        String hello = helloController.hello();
        System.out.println(hello);
    }

    //自动创建爱你的单元测试方法示例
    @Test
    void contextLoads() {
    }

}

热部署

在开发过程中，通常会对一段业务代码不断地修改测试，在 修改之后往往 需要 重启服务，有些服务需要加载很久才能启动成功，这种不必要的重复操作极大降低了程序开发效率。为此，Spring Boot 框架专门提供了进行热部署的依赖启动器，用于进行项目热部署，而 无须开发人员手动重启项目。
第一步、导入“热部署”依赖启动器 :
 
 <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
 </dependency>
第二步、IDEA工具热部署设置 ：

然后
在任意页面使用 组合键 : Ctrl + Shift + Alt + / 打开 Maintenance选择框，选中并打开 Registry页面 ，如下图所示 ：

第三步、热部署效果测试 ：
启动 chapter01项目，通过 浏览器访问“http://localhost:8080/hello”，具体如下图所示 ：

页面原始输出 的内容是“hello Spring Boot”。

为了测试配置的热部署是否有效，接下来在不关闭当前项目的情况下，将 HelloController类 中的 请求处理方法hello( ) 的返回值修改为“ 你好，Spring Boot ”并保存，查看控制台信息会发现项目能够自动构建和编译，说明项目热部署生效。此时，关闭重新打开浏览器访问 ：“http://localhost:8080/hello”，此时
效果如下图 所示：

4. Spring Boot”原理分析”

传统的Spring 框架实现一个Web 服务，需要导入各种依赖JAR包，然后 编写对应的XML配置文件等；相较而言，Spring Boot 显得更加方便、快捷和高效。
下面将分别针对 SpringBoot 框架 的 依赖管理、自动配置 和 执行流程 进行 深入分析和讲解。

4.1Spring Boot”依赖管理“

在Spring Boot 入门程序中，项目 pom.xml 文件 有两个核心依赖，分别是 spring-boot-starter-parent ( 父项目依赖管理“启动器” ) 和 spring-boot-starter-web ( web场景依赖“启动器” )

spring-boot-starter-parent 依赖

<!-- 父项目依赖管理"启动器" : Spring Boot父项目依赖管理  -->
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.1.3.RELEASE</version>
</parent>

上述代码中，将 spring-boot-starter-parent依赖 作为Spring Boot项目的 统一父项目依赖管理 ，并将项目 版本号统一为2.1.3.RELEASE，该版本号根据实际开发需求是可以修改的。

进入并查看spring-boot-starter-parent底层源文件可以发现 spring-boot-starter-parent 的 底层有一个父依赖 : spring-boot-dependencies ，核心代码如下 ：

<parent>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-dependencies</artifactId>
 <version>2.1.3.RELEASE</version>
 <relativePath>../../spring-boot-dependencies</relativePath>
</parent>
.....

继续查看 spring-boot-dependencies 底层源文件，核心代码 如下：

<properties>
 <activemq.version>5.15.8</activemq.version>    
 ...
 <solr.version>7.4.0</solr.version>
 <spring.version>5.1.5.RELEASE</spring.version>
 <spring-amqp.version>2.1.4.RELEASE</spring-amqp.version>
 <spring-batch.version>4.1.1.RELEASE</spring-batch.version>
 <spring-cloud-connectors.version>2.0.4.RELEASE</spring-cloud-connectors.version>
 <spring-data-releasetrain.version>Lovelace-SR5</spring-data-releasetrain.version>
 <spring-framework.version>${spring.version}</spring-framework.version>
 <spring-hateoas.version>0.25.1.RELEASE</spring-hateoas.version>
 <spring-integration.version>5.1.3.RELEASE</spring-integration.version>
 <spring-kafka.version>2.2.4.RELEASE</spring-kafka.version>
 <spring-ldap.version>2.3.2.RELEASE</spring-ldap.version>
 <spring-plugin.version>1.2.0.RELEASE</spring-plugin.version>
 <spring-restdocs.version>2.0.3.RELEASE</spring-restdocs.version>
 <spring-retry.version>1.2.4.RELEASE</spring-retrdy.version>
 <spring-security.version>5.1.4.RELEASE</spring-security.version>
 <spring-session-bom.version>Bean-SR3</spring-session-bom.version>
 <spring-ws.version>3.0.6.RELEASE</spring-ws.version>
 <sqlite-jdbc.version>3.25.2</sqlite-jdbc.version>
 <statsd-client.version>3.1.0</statsd-client.version>
 <sun-mail.version>${javax-mail.version}</sun-mail.version>
 <thymeleaf.version>3.0.11.RELEASE</thymeleaf.version> 
 <tomcat.version>9.0.16</tomcat.version> 
 <unboundid-ldapsdk.version>4.0.9</unboundid-ldapsdk.version>
 <undertow.version>2.0.17.Final</undertow.version>
 <versions-maven-plugin.version>2.7</versions-maven-plugin.version>
 <webjars-hal-browser.version>3325375</webjars-hal-browser.version>
 <webjars-locator-core.version>0.35</webjars-locator-core.version>
</properties>

从 spring-boot-dependencies底层源文件可以看出，该文件通过 <properties>标签 对一些常用技术框架的依赖文件进行了 统一版本号管理，例如activemq、spring、tomcat 等，都有与 SpringBoot 2.1.3 版本相匹配的版本，这也是pom.xml引入依赖文件 不需要标注依赖文件版本号的原因。

需要说明的是，如果pom.xml 引入的依赖文件不是spring-boot-starter-parent 管理的，那么在 pom.xml 引入依赖文件时，需要使用 <version>标签指定依赖文件的版本号。

spring-boot-starter-web 依赖

spring-boot-starter-parent父依赖启动器的主要作用是进行版本统一管理。

<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.1.3.RELEASE</version>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-json</artifactId>
      <version>2.1.3.RELEASE</version>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-tomcat</artifactId>
      <version>2.1.3.RELEASE</version>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>org.hibernate.validator</groupId>
      <artifactId>hibernate-validator</artifactId>
      <version>6.0.14.Final</version>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>5.1.5.RELEASE</version>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.1.5.RELEASE</version>
      <scope>compile</scope>
    </dependency>
  </dependencies>
从上述代码可以发现，spring-boot-starter-web依赖启动器 的主要作用是 提供Web开发场景所需的底层所有依赖文件，它对Web开发场景所需的依赖文件进行了统一管理。

正是如此，在pom.xml 中引入spring-boot-starter-web依赖启动器时，就可以实现Web场景开发，而 不需要额外导入Tomcat服务器以及其他 Web 依赖文件 等。当然，这些引入的依赖文件的版本号还是由spring-boot-starter-parent父依赖进行统一管理。
需要说明 ：
的是，Spring Boot 官方 并不是 针对所有场景开发的技术框架 都提供了依赖启动器，例如数据库操作框 : MyBatis、阿里巴巴的Druid 数据源等，Spring Boot 官方就 没有提供对应的依赖启动器。为了充分利用Spring Boot 框架的优势，在Spring Boot官方没有整合这些技术框架的情况下，MyBatis、Druid等技术框架所在的开发团队主动与Spring Boot框架进行了整合，实现了各自的依赖启动器，例如 mybatis-spring-boot-starter、druid-spring-boot-starter 等。我们 在pom.xml 文件中引入这些第三方的依赖启动器时，切记要配置对应的版本号。

Spring Boot自动配置

Spring Boot应用的 启动入口 是 @SpringBootApplication注解 标注类 中的main( )方法，@SpringBootApplication 能够扫描 Spring组件 并 自动配置Spring Boot。
@SpringBootApplication内部源码 分析：
@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 { 
   ...
}
从上述源码可以看出，@SpringBootApplication注解是一个 组合注解 ，包含 @SpringBootConfiguration
、 @EnableAutoConfiguration 、 @ComponentScan3个核心注解。

@SpringBootConfiguration

@SpringBootConfiguration注解表示SpringBoot配置类 ，查看其源码，核心代码 如下：
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration
public @interface SpringBootConfiguration {
}
从上述源码可以看出，@SpringBootConfiguration注解 内部有一个核心注解@Configuration，
该注解是 Spring 框架提供的，表示当前类为一个配置类(XML配置文件的注解表现形式)，并
可以被组件扫描器扫描。由此可见，@SpringBootConfiguration注解 的作用与 @Configuration注
解相同，都是标识一个可以被组件扫描器扫描的配置类，只不过**@SpringBootConfiguration** 是被
Spring Boot 进行了重新封装命名而已。

@EnableAutoConfiguration

@EnableAutoConfiguration注解表示 开启自动配置功能，该注解是Spring Boot框架 最重要
的注解，也是实现自动化配置的注解。同样该注解的核心代码如下 ：
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {

	String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";

	/**
	 * Exclude specific auto-configuration classes such that they will never be applied.
	 * @return the classes to exclude
	 */
	Class<?>[] exclude() default {};

	/**
	 * Exclude specific auto-configuration class names such that they will never be
	 * applied.
	 * @return the class names to exclude
	 * @since 1.3.0
	 */
	String[] excludeName() default {};

}
从上述源码可以看出，@EnableAutoConfiguration 注解是一个 组合注解，它主要包括有
@AutoConfigurationPackage和 @lmport两个核心注解。