SpingBoot原理

YangeIT大约 36 分钟

SpingBoot原理

今日目标

配置优先级：Springboot项目当中属性配置的常见方式以及配置的优先级 🍐
Bean的管理 🍐 ❤️
剖析Springboot的底层原理 🍐 🚀

知识储备

能够创建SpringBoot入门项目
能够在SpringBoot项目中书写请求、接受参数、返回响应
能够使用过滤器和拦截器拦截请求
能够在SpringBoot工程下进行事务管理
能够进行统一异常处理，并自定义异常

今日初始代码下载open in new window42kb

1. 配置优先级 🚀

配置优先级

SpringBoot项目当中支持的三类配置文件：

application.properties
application.yml企业实用
application.yaml

配置文件优先级排名（从高到低）： 👇

properties配置文件
yml配置文件
yaml配置文件

注意事项 ⚠️：虽然springboot支持多种格式配置文件，但是在项目开发时，推荐统一使用一种格式的配置。yml是主流

application.properties

server.port=8081

application.yml

server:
   port: 8082

application.yaml

server:
   port: 8082

我们启动SpringBoot程序，测试下三个配置文件中哪个Tomcat端口号生效：

properties、yaml、yml三种配置文件同时存在

properties、yaml、yml三种配置文件，优先级最高的是properties 👈👈

yaml、yml两种配置文件同时存在

在SpringBoot项目当中除了以上3种配置文件外，SpringBoot为了增强程序的扩展性，除了支持配置文件的配置方式以外，还支持另外两种常见的配置方式🚀 🚀：

Java系统属性配置开发人员偶尔用（格式： -Dkey=value）
```
-Dserver.port=9000
```
命令行参数测试人员常用（格式：--key=value）
```
--server.port=10010
```

其他2种配置方式演示操作，如下👇 👇

其他2种配置方式演示操作 👇 👇

那在idea当中运行程序时，如何来指定Java系统属性和命令行参数呢？

编辑启动程序的配置信息

重启服务，同时配置Tomcat端口(三种配置文件、系统属性、命令行参数)，测试哪个Tomcat端口号生效：

删除命令行参数配置，重启SpringBoot服务：

优先级：命令行参数 > 系统属性参数 > properties参数 > yml参数 > yaml参数

思考：如果项目已经打包上线了，这个时候我们又如何来设置Java系统属性和命令行参数呢？

java -Dserver.port=9000 -jar XXXXX.jar --server.port=10010

下面我们来演示下打包程序运行时指定Java系统属性和命令行参数：

执行maven打包指令package，把项目打成jar文件
使用命令：java -jar 方式运行jar文件程序

项目打包：

运行jar程序：

同时设置Java系统属性和命令行参数

仅设置Java系统属性

注意事项：
Springboot项目进行打包时，需要引入插件 spring-boot-maven-plugin (基于官网骨架创建项目，会自动添加该插件)

总结

在SpringBoot项目当中，常见的属性配置方式有5种(3配+2外)---优先级(从低到高)：

application.yaml（忽略）
application.yml 企业实用
application.properties
java系统属性（-Dxxx=xxx）
命令行参数（--xxx=xxx）测试人员实用

课堂作业

🚩 Spring Boot 中常用的配置文件类型是哪些？

A. .yml 或 .yaml
B. .properties
C. 两者都可以

🚩 yml 和 properties 配置文件的语法有什么不同

A. yml 使用缩进表示层级关系，properties 使用冒号分隔键值对
B. yml 使用冒号分隔键值对，properties 使用等号
C. yml 和 properties 的语法是完全一样的

🚩 资料中有一个jar包，jar的默认端口是8080，请在不修改源码的情况下，将端口临时改成8888运行

点击查看答案解析

答案：C

解析：Spring Boot 支持 .properties 和 .yml（或 .yaml）两种类型的配置文件。在同一个项目中，你可以同时使用这两种类型的配置文件，优先级如下：命令行参数 > .properties > .yml。

答案：A 解析：yml 使用缩进表示层级关系，不同层级之间的缩进必须保持一致。而 properties 使用冒号或等号分隔键值对，键和值之间必须用一个空格分隔。

2. Bean管理 🍐

2.1 手动获取Bean

学习目标

主要学习IOC容器中Bean的其他使用细节，主要学习以下三方面：

如何从IOC容器中的获取到bean对象
bean的作用域配置
管理第三方的bean对象

已经学过的Spring注解

控制反转(IOC)
- @Component
  - @Controller
  - @Service
  - @Repository
依赖注入(DI)
- @Autowired

获取Bean

获取Bean

要获得Bean对象，先获得IOC容器

@SpringBootTest
class SpringbootWebConfig2ApplicationTests {

    @Autowired
    private ApplicationContext applicationContext; //IOC容器对象

默认情况下，SpringBoot项目在启动的时候会自动的创建IOC容器(也称为Spring容器)，并且在启动的过程当中会自动的将bean对象都创建好，存放在IOC容器当中。应用程序在运行时需要依赖什么bean对象，就直接进行依赖注入就可以了。

通过容器获取Bean

Spring容器中提供了一些方法，可以主动从IOC容器中获取到bean对象，下面介绍3种常用方式：

根据name获取bean --Object getBean(String name)
根据类型获取bean --<T> T getBean(Class<T> requiredType)
根据name获取bean（带类型转换）--<T> T getBean(String name, Class<T> requiredType)

点击查看获取Bean的代码

控制器：BookController

@RestController
public class BookController {


    @RequestMapping("/books")
    public String list(){
        String  bookname="重生在黑马学java";
        System.out.println(bookname);
        return bookname;
    }


}

测试类：

@SpringBootTest
class SpringbootWebConfigApplicationTests {

    @Autowired
    private ApplicationContext applicationContext;


    @Test
    public void test(){
        System.out.println("test");
        //根据bean的名称获取
        BookController bookController = (BookController) applicationContext.getBean("bookController");

        System.out.println(bookController);
        //根据bean的类型获取
        BookController bookController2 =applicationContext.getBean(BookController.class);
        System.out.println(bookController2);

        //根据bean的名称 及 类型获取
        BookController bookController3 =applicationContext.getBean("bookController",BookController.class);
        System.out.println(bookController3);

    }

程序运行后控制台日志：

问题：输出的bean对象地址值是一样的，说明IOC容器当中的bean对象有几个？
答案：只有一个。（默认情况下，IOC中的bean对象是单例）
那么能不能将bean对象设置为非单例的(每次获取的bean都是一个新对象)？
可以，在下一个知识点(bean作用域)中讲解。

上述所说的【Spring项目启动时，会把其中的bean都创建好】还会受到作用域及延迟初始化影响，这里主要针对于默认的单例非延迟加载的bean而言。

2.2 Bean作用域

Bean作用域

⚠️ IOC容器当中，默认bean对象是单例模式(只有一个实例对象)
🎯 通过设置Bean的作用域见下图红色区域，来修改非单例模式

在Spring中支持五种作用域今天先尝前2种，后三种在web环境才生效：

作用域	说明
singleton默认	容器内同名称的bean只有一个实例（单例）（默认）
prototype	每次使用该bean时会创建新的实例（非单例）
request	每个请求范围内会创建新的实例（web环境中，了解）
session	每个会话范围内会创建新的实例（web环境中，了解）
application	每个应用范围内会创建新的实例（web环境中，了解）

1). 测试一

控制器

@RestController
public class BookController {


    @RequestMapping("/books")
    public String list(){
        String  bookname="重生在黑马学java";
        System.out.println(bookname);
        return bookname;
    }


}

测试类（原来的代码）


@SpringBootTest
class SpringbootWebConfigApplicationTests {

    @Autowired
    private ApplicationContext applicationContext;


    @Test
    public void test(){
        System.out.println("test");
        //根据bean的名称获取
        BookController bookController = (BookController) applicationContext.getBean("bookController");

        System.out.println(bookController);
        //根据bean的类型获取
        BookController bookController2 =applicationContext.getBean(BookController.class);
        System.out.println(bookController2);

        //根据bean的名称 及 类型获取
        BookController bookController3 =applicationContext.getBean("bookController",BookController.class);
        System.out.println(bookController3);

    }

}

重启SpringBoot服务，运行测试方法，查看控制台打印的日志：

注意事项：
IOC容器中的bean默认使用的作用域：singleton (单例)
默认singleton的bean，在容器启动时被创建，可以使用@Lazy注解来延迟初始化(延迟到第一次使用时)

2). 测试二

控制器

@Scope("prototype") //prototype非单例
@RestController
public class BookController {


    @RequestMapping("/books")
    public String list(){
        String  bookname="重生在黑马学java";
        System.out.println(bookname);
        return bookname;
    }


}

测试类（原来的代码）


@SpringBootTest
class SpringbootWebConfigApplicationTests {

    @Autowired
    private ApplicationContext applicationContext;


    @Test
    public void test(){
        System.out.println("test");
        //根据bean的名称获取
        BookController bookController = (BookController) applicationContext.getBean("bookController");

        System.out.println(bookController);
        //根据bean的类型获取
        BookController bookController2 =applicationContext.getBean(BookController.class);
        System.out.println(bookController2);

        //根据bean的名称 及 类型获取
        BookController bookController3 =applicationContext.getBean("bookController",BookController.class);
        System.out.println(bookController3);

    }

}

重启SpringBoot服务，运行测试方法，查看控制台打印的日志：

总结

prototype的bean，每一次使用该bean的时候都会创建一个新的实例
实际开发当中，绝大部分的Bean是单例的，也就是说绝大部分Bean不需要配置scope属性

2.3 第三方Bean

第三方Bean

我们所配置的bean，像controller、service，dao三层体系下编写的类，这些类都是我们在项目当中自己定义的类(自定义类)。当我们要声明这些bean，也非常简单，我们只需要在类上加上@Component以及它的这三个衍生注解（@Controller、@Service、@Repository），就可以来声明这个bean对象了。

如果要管理的bean对象来自于第三方（不是自定义的,如jar包中的类），是无法用@Component 及衍生注解声明bean的，就需要用到 @Bean 注解。如下图：👇 👇

那怎么将这些三方的类的对象加入到IOC容器中尼？下面有2种解决方案 👇

解决方案1：在配置类中定义@Bean标识的方法 企业实用

准备工作，在pojo包下，创建一个Books的实体类，如下：

@Component
public class Books {
    String  name="凡人修仙传";

}

如果需要定义第三方Bean时，通常会单独定义一个配置类

@Configuration //配置类  (在配置类当中对第三方bean进行集中的配置管理)
public class CommonConfig {

    //声明第三方bean
    @Bean //将当前方法的返回值对象交给IOC容器管理, 成为IOC容器bean
          //通过@Bean注解的name/value属性指定bean名称, 如果未指定, 默认是方法名
    public JsonIOException jsonIOException(Books books){
        System.out.println(books.name);
        return new JsonIOException("json错误了");
    }

}

重启服务，执行测试方法，查看控制台日志：

com.google.gson.JsonIOException: json错误了

在方法上加上一个@Bean注解，Spring 容器在启动的时候，它会自动的调用这个方法，并将方法的返回值声明为Spring容器当中的Bean对象。

解决方案2：在启动类上添加@Bean标识的方法 不建议使用

重启服务，执行测试方法，查看控制台日志：

com.google.gson.JsonIOException: json错误了

说明：以上在启动类中声明第三方Bean的作法，不建议使用（项目中要保证启动类的纯粹性）

总结

注意事项：

通过 @Bean 注解的name或value属性可以声明bean的名称，如果不指定，默认bean的名称就是方法名。

    //@Bean 默认名字 jsonIOException1
    //@Bean("jsonhh") 指定名字 jsonhh
    public JsonIOException jsonIOException1(){
        System.out.println(books.name+"sds");
        return new JsonIOException("json错误了");
    }

如果第三方bean需要依赖其它bean对象，直接在bean定义方法中设置形参即可，容器会根据类型自动装配。

    @Bean //将当前方法的返回值对象交给IOC容器管理, 成为IOC容器bean
          //通过@Bean注解的name/value属性指定bean名称, 如果未指定, 默认是方法名
    public JsonIOException jsonIOException(Books books){
        System.out.println(books.name+"sds");
        return new JsonIOException("json错误了");
    }

关于@Bean大家只需要保持一个原则：

如果是在项目当中我们自己定义的类，想将这些类交给IOC容器管理，我们直接使用 @Component 以及它的衍生注解来声明就可以。
如果这个类它不是我们自己定义的，而是引入的第三方依赖当中提供的类，而且我们还想将这个类交给IOC容器管理。此时我们就需要在配置类中定义一个方法，在方法上加上一个 @Bean 注解，通过这种方式来声明第三方的bean对象。

总结

课堂作业

🚩 流畅的回答下列面试题？

Spring Bean默认作用域是单例还是多例？🎤
简单的概述下Spring Bean的生命周期（可以查阅资料，自行整理答案） 🎤
@Bean注解的作用是什么，为什么要有这个注解？ 🎤
@Bean修饰的方法，是将返回值注册到IOC容器中，请问是单例还是多例？ 🎤

3. SpringBoot原理 🍐🚀

3.1 起步依赖 🍐

SpringBoot原理概述和起步依赖

经过前面10多天课程的学习，大家也会发现基于SpringBoot进行web程序的开发是非常简单、非常高效的。使用若干注解即可

SpringBoot使我们能够集中精力地去关注业务功能的开发，而不用过多地关注框架本身的配置使用。而我们前面所讲解的都是面向应用层面的技术，接下来我们开始学习SpringBoot的原理，这部分内容偏向于底层的原理分析。 🍐 🚀

在剖析SpringBoot的原理之前，我们先来快速回顾一下我们前面所讲解的Spring家族的框架。

Spring是目前世界上最流行的Java框架，它可以帮助我们更加快速、更加容易的来构建Java项目。而在Spring家族当中提供了很多优秀的框架，而所有的框架都是基于一个基础框架的SpringFramework(也就是Spring框架)。而前面我们也提到，如果我们直接基于Spring框架进行项目的开发，会比较繁琐。

这个繁琐主要体现在两个地方：

在pom.xml中依赖配置比较繁琐，在项目开发时，需要自己去找到对应的依赖，还需要找到依赖它所配套的依赖以及对应版本，否则就会出现版本冲突问题。
在使用Spring框架进行项目开发时，需要在Spring的配置文件中做大量的配置，这就造成Spring框架入门难度较大，学习成本较高。

基于Spring存在的问题，官方在Spring框架4.0版本之后，又推出了一个全新的框架：SpringBootopen in new window 点击进入官网
通过 SpringBoot来简化Spring框架的开发(是简化不是替代)。我们直接基于SpringBoot来构建Java项目，会让我们的项目开发更加简单，更加快捷。

SpringBoot能简化Spring开发尼？

SpringBoot框架之所以使用起来更简单更快捷，是因为SpringBoot框架底层提供了两个非常重要的功能：一个是起步依赖，一个是自动配置。

通过SpringBoot所提供的起步依赖，就可以大大的简化pom文件当中依赖的配置，从而解决了Spring框架当中依赖配置繁琐的问题。
通过自动配置的功能就可以大大的简化框架在使用时bean的声明以及bean的配置。我们只需要引入程序开发时所需要的起步依赖，项目开发时所用到常见的配置都已经有了，我们直接使用就可以了。

3.1 起步依赖

起步依赖是Spring Boot为简化 Maven或Gradle项目构建配置而提供的一种依赖管理方式。👈
起步依赖会自动导入依赖的 jar 包和相关的默认配置，帮助开发者快速构建出可运行、独立的应用程序。
起步依赖的命名规则是 spring-boot-starter-* ，其中 * 是依赖的具体名字，如 spring-boot-starter-web 包含了构建 Web 应用所需的基本依赖。
Spring Boot 官方提供了大量的起步依赖，方便开发者快速集成常用的技术，如数据访问、消息队列、测试等。
起步依赖的原理是基于 Spring Boot 的自动化配置机制和Maven的依赖传递 👈

⚠️使用和未使用SpringBoot的依赖对比左边未使用Boot👇

spring-webmvc依赖：这是Spring框架进行web程序开发所需要的依赖
servlet-api依赖：Servlet基础依赖
jackson-databind依赖：JSON处理工具包
如果要使用AOP，还需要引入aop依赖、aspect依赖
项目中所引入的这些依赖，还需要保证版本匹配，否则就可能会出现版本冲突问题。 👈
使用了SpringBoot只需要引入一个依赖就可以 👈

总结

起步依赖是Spring Boot为简化 Maven或Gradle项目构建配置而提供的一种依赖管理方式。👈
起步依赖会自动导入依赖的 jar 包和相关的默认配置，帮助开发者快速构建出可运行、独立的应用程序

课堂作业

SpringBoot能简化Spring开发的原因？🎤

3.2 自动配置

自动配置

目标🎯 ：理解自动配置的定义和作用

在当前项目中我们并没有声明Google提供的Gson这么一个bean对象，然而我们却可以通过@Autowired从Spring容器中注入bean对象，那么这个bean对象怎么来的？ ⁉️

SpringBoot的自动配置就是当Spring容器启动后，一些配置类、bean对象就自动存入到了IOC容器中，不需要我们手动去声明，从而简化了开发，省去了繁琐的配置操作。

比如：我们要进行事务管理、要进行AOP程序的开发，此时就不需要我们再去手动的声明这些bean对象了，我们直接使用就可以从而大大的简化程序的开发，省去了繁琐的配置操作。

配置类@Configration注解修饰的类最终也是SpringIOC容器当中的一个bean对象
在IOC容器中除了我们自己定义的bean以外，还有很多配置类，这些配置类都是SpringBoot在启动的时候加载进来的配置类。这些配置类加载进来之后，它也会生成很多的bean对象。

比如：配置类GsonAutoConfiguration里面有一个bean，bean的名字叫gson，它的类型是Gson。
com.google.gson.Gson是谷歌包中提供的用来处理JSON格式数据的。

当我们想要使用这些配置类中生成的bean对象时，可以使用@Autowired就自动注入了：

@SpringBootTest
public class AutoConfigurationTests {
// IOC容器中已经有了，因此直接注入即可使用
    @Autowired
    private Gson gson;
    @Test
    public void testJson(){
        String json = gson.toJson(Result.success());
        System.out.println(json);
    }
}

添加断点，使用debug模式运行测试类程序：

体验了SpringBoot的自动配置了，下面我们就来分析自动配置的原理🎯。

其实分析自动配置原理就是来解析在SpringBoot项目中，在引入依赖之后是如何将依赖jar包当中所定义的配置类以及bean加载到SpringIOC容器中的需要阅读源码来理解。

SpringBoot项目在启动时通过自动配置完成了bean对象的创建。

@Configuration(proxyBeanMethods = false)
@ConditionalOnClass(Gson.class)
@EnableConfigurationProperties(GsonProperties.class)
public class GsonAutoConfiguration {

	@Bean
	@ConditionalOnMissingBean
	public GsonBuilder gsonBuilder(List<GsonBuilderCustomizer> customizers) {
		GsonBuilder builder = new GsonBuilder();
		customizers.forEach((c) -> c.customize(builder));
		return builder;
	}

	@Bean
	@ConditionalOnMissingBean
	public Gson gson(GsonBuilder gsonBuilder) {
		return gsonBuilder.create();
	}
    // 省略
}

结论和下个学习目标

从上述步骤可知，Gson对象是通过配置类的@Bean方式加入到IOC中的

🎯接下来通过代码的方式演示如何加入第三方依赖中的Bean对象至IOC容器中 🎯

步骤：

导入三方依赖运行
使用@ComponentScan组件扫描
使用@Import导入

案例中引入进来的第三方依赖当中的bean以及配置类为什么没有生效？

原因在我们之前讲解IOC的时候有提到过，在类上添加@Component注解来声明bean对象时，还需要保证@Component注解能被Spring的组件扫描到。
SpringBoot项目中的@SpringBootApplication注解，具有包扫描的作用，但是它只会扫描启动类所在的当前包以及子包。
当前包：com.itheima，第三方依赖中提供的包：com.heihei（扫描不到）

那么如何解决以上问题的呢？ 👇 👇

方案1：@ComponentScan 组件扫描
方案2：@Import 导入（使用@Import导入的类会被Spring加载到IOC容器中）

方案一

@ComponentScan组件扫描

重新执行测试方法，控制台日志输出：

大家可以想象一下，如果采用以上这种方式来完成自动配置，那我们进行项目开发时，当需要引入大量的第三方的依赖，就需要在启动类上配置N多要扫描的包，这种方式会很繁琐。而且这种大面积的扫描性能也比较低。
缺点：
使用繁琐
性能低
结论：SpringBoot中并没有采用以上这种方案(采用的是方案二)。

方案二

@Import导入

导入形式主要有以下几种：
1. 导入普通类
2. 导入配置类
3. 导入ImportSelector接口实现类

1️⃣ 使用@Import导入普通类：

2️⃣ 使用@Import导入配置类：

3️⃣ 使用@Import导入ImportSelector接口实现类：

我们使用@Import注解通过这三种方式都可以导入第三方依赖中所提供的bean或者是配置类。

思考：如果基于以上方式完成自动配置，当要引入一个第三方依赖时，是不是还要知道第三方依赖中有哪些配置类和哪些Bean对象？

答案：是的。（对程序员来讲，很不友好，而且比较繁琐）

思考：当我们要使用第三方依赖，依赖中到底有哪些bean和配置类，谁最清楚？

答案：第三方依赖自身最清楚。

结论：我们不用自己指定要导入哪些bean对象和配置类了，让第三方依赖它自己来指定。

怎么让第三方依赖自己指定bean对象和配置类？

比较常见的方案就是第三方依赖给我们提供一个注解，这个注解一般都以@EnableXxxx开头的注解，注解中封装的就是@Import注解

4️⃣ 使用第三方依赖提供的 @EnableXxxxx注解

第三方依赖中提供的注解

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Import(MyImportSelector.class)//指定要导入哪些bean对象或配置类
public @interface EnableHeaderConfig { 
}

以上四种方式都可以完成导入操作，但是第4种方式会更方便更优雅，而这种方式也是SpringBoot当中所采用的方式。

总结

配置类@Configration注解修饰的类最终也是SpringIOC容器当中的一个bean对象
在IOC容器中除了我们自己定义的bean以外，还有很多配置类，这些配置类都是SpringBoot在启动的时候加载进来的配置类。这些配置类加载进来之后，它也会生成很多的bean对象
第三方依赖中的Bean对象至IOC容器中
1. 导入三方依赖运行
2. 使用@ComponentScan组件扫描
3. 使用@Import导入

课堂作业

引入进来的第三方依赖当中的bean以及配置类为什么没有生效？🎤
@SpringBootApplication注解含有几个主要注解，分别什么意思？

3.3 跟踪源码

跟踪源码

前置知识

理解Gson对象是由其配置类通过@Bean注解，进行自动配置的！
能听懂上述的4种导入三方Bean至IOC中的操作

🎯那下面我们通过源码跟踪的形式来剖析下SpringBoot底层到底是如何完成自动配置的哪一种！。

源码跟踪技巧：

在跟踪框架源码的时候，一定要抓住关键点，找到核心流程。一定不要从头到尾一行代码去看，一个方法的去研究，一定要找到关键流程，抓住关键点，先在宏观上对整个流程或者整个原理有一个认识，有精力再去研究其中的细节。

如何高效的看代码（idea标签） 👍

标记书签
- ctrl+f11 后按 0~9 a~z 提供了这么多的书签
- 设置0号标签 ctrl+f11后按0
快速跳转到标签
- 假设之前设置了0号标签
- 跳转到0号标签 ctrl+0
刪除标签
- 选择标签所在行按F11

从启动类开始看！！✏️ 老弟！一步一步来！

要搞清楚SpringBoot的自动配置原理，要从SpringBoot启动类上使用的核心注解@SpringBootApplication开始分析：

在@SpringBootApplication注解中包含了：

元注解（不再解释）
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan

先来看第一个注解：@SpringBootConfiguration

@SpringBootConfiguration注解上使用了@Configuration，表明SpringBoot启动类就是一个配置类。
@Indexed注解，是用来加速应用启动的不用关心。

接下来再先看@ComponentScan注解：

@ComponentScan注解是用来进行组件扫描的，扫描启动类所在的包及其子包下所有被@Component及其衍生注解声明的类。
SpringBoot启动类，之所以具备扫描包功能，就是因为包含了@ComponentScan注解。

最后我们来看看@EnableAutoConfiguration注解（自动配置核心注解）：

使用@Import注解，导入了实现ImportSelector接口的实现类。
AutoConfigurationImportSelector类是ImportSelector接口的实现类。
image-20230115003242549

AutoConfigurationImportSelector类中重写了ImportSelector接口的selectImports()方法：

selectImports()方法底层调用getAutoConfigurationEntry()方法，获取可自动配置的配置类信息集合

getAutoConfigurationEntry()方法通过调用getCandidateConfigurations(annotationMetadata, attributes)方法获取在配置文件中配置的所有自动配置类的集合

getCandidateConfigurations方法的功能：
获取所有基于META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports文件、META-INF/spring.factories文件中配置类的集合

META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports文件和META-INF/spring.factories文件这两个文件在哪里呢？

通常在引入的起步依赖中，都有包含以上两个文件

在前面在给大家演示自动配置的时候，我们直接在测试类当中注入了一个叫gson的bean对象，进行JSON格式转换。虽然我们没有配置bean对象，但是我们是可以直接注入使用的。原因就是因为在自动配置类当中做了自动配置。到底是在哪个自动配置类当中做的自动配置呢？我们通过搜索来查询一下。

在META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports配置文件中指定了第三方依赖Gson的配置类：GsonAutoConfiguration

第三方依赖中提供的GsonAutoConfiguration类：

在GsonAutoConfiguration类上，添加了注解@AutoConfiguration，通过查看源码，可以明确：GsonAutoConfiguration类是一个配置。
image-20230115065247287

看到这里，大家就应该明白为什么可以完成自动配置了，原理就是在配置类中定义一个@Bean标识的方法，而Spring会自动调用配置类中使用@Bean标识的方法，并把方法的返回值注册到IOC容器中。

自动配置源码小结

自动配置原理源码入口就是@SpringBootApplication注解，在这个注解中封装了3个注解，分别是：

1️⃣ @SpringBootConfiguration
- 声明当前类是一个配置类
2️⃣ @ComponentScan
- 进行组件扫描（SpringBoot中默认扫描的是启动类所在的当前包及其子包）
3️⃣ @EnableAutoConfiguration
- 封装了4️⃣@Import注解（Import注解中指定了一个5️⃣ImportSelector接口的实现类）
  - 在实现类重写的selectImports()方法，读取当前项目下所有依赖jar包中6️⃣META-INF/spring.factories、META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports两个文件里面定义的配置类（配置类中定义了7️⃣@Bean注解标识的方法）。

当SpringBoot程序启动时，就会加载配置文件当中所定义的配置类，并将这些配置类信息(类的全限定名)封装到String类型的数组中，最终通过@Import注解将这些配置类全部加载到Spring的IOC容器中，交给IOC容器管理。

课堂作业

🚩 流畅的回答下述面试题（建议自己整理成文字）

自行的跟踪自动配置的源码，简单的描述成文字并绘制成流程图 👍

3.4 如何保障三方的Bean是单例的

问题如果2个依赖都有相同的自动配置，会创建2个对象到IOC容器中吗？

在META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports文件中定义的配置类非常多，而且每个配置类中又可以定义很多的bean，那这些bean都会注册到Spring的IOC容器中吗？（下图是配置多个出现的问题）

点击查看代码

答案：并不是。在声明bean对象时，上面有加一个以@Conditional开头的注解，这种注解的作用就是按照条件进行装配，只有满足条件之后，才会将bean注册到Spring的IOC容器中

我们在跟踪SpringBoot自动配置的源码的时候，在自动配置类声明bean的时候，除了在方法上加了一个@Bean注解以外，还会经常用到一个注解，就是以Conditional开头的这一类的注解。以Conditional开头的这些注解都是条件装配的注解。下面我们就来介绍下条件装配注解。

@Conditional注解：

作用：按照一定的条件进行判断，在满足给定条件后才会注册对应的bean对象到Spring的IOC容器中。
位置：方法、类
@Conditional本身是一个父注解，派生出大量的子注解：
- @ConditionalOnClass：判断环境中有对应字节码文件，才注册bean到IOC容器。
- @ConditionalOnMissingBean：判断环境中没有对应的bean(类型或名称)，才注册bean到IOC容器。
- @ConditionalOnProperty：判断配置文件中有对应属性和值，才注册bean到IOC容器。

自动配置原理总结：

自动配置的核心就在1️⃣ @SpringBootApplication注解上，SpringBootApplication这个注解底层包含了3个注解，分别是：
@SpringBootConfiguration
@ComponentScan
@EnableAutoConfiguration
2️⃣ @EnableAutoConfiguration这个注解才是自动配置的核心。
它封装了一个3️⃣ @Import注解，Import注解里面指定了一个5️⃣ ImportSelector接口的实现类。
在这个实现类中，重写了ImportSelector接口中的5️⃣ selectImports()方法。
而selectImports()方法中会去读取两份配置文件，并将配置文件中定义的配置类做为selectImports()方法的返回值返回，返回值代表的就是需要将哪些类交给Spring的IOC容器进行管理。
那么所有自动配置类的中声明的bean都会加载到Spring的IOC容器中吗? 其实并不会，因为这些配置类中在声明bean时，通常都会添加6️⃣ @Conditional开头的注解，这个注解就是进行条件装配。而Spring会根据Conditional注解有选择性的进行bean的创建。
@Enable 开头的注解底层，它就封装了一个注解 import 注解，它里面指定了一个类，是 ImportSelector 接口的实现类。在实现类当中，我们需要去实现 ImportSelector 接口当中的一个方法 selectImports 这个方法。这个方法的返回值代表的就是我需要将哪些类交给 spring 的 IOC容器进行管理。
此时它会去读取两份配置文件，一份儿是 spring.factories，另外一份儿是 autoConfiguration.imports。而在 autoConfiguration.imports 这份儿文件当中，它就会去配置大量的自动配置的类。
而前面我们也提到过这些所有的自动配置类当中，所有的 bean都会加载到 spring 的 IOC 容器当中吗？其实并不会，因为这些配置类当中，在声明 bean 的时候，通常会加上这么一类@Conditional 开头的注解。这个注解就是进行条件装配。所以SpringBoot非常的智能，它会根据 @Conditional 注解来进行条件装配。只有条件成立，它才会声明这个bean，才会将这个 bean 交给 IOC 容器管理。

3.5 自定义自定义起步依赖了解即可 🚀

自定义自定义起步依赖

实际的项目开发当中，并不是所有的第三方的技术官方都给我们提供了与SpringBoot整合的starter起步依赖
阿里云OSS对象存储服务，阿里云的官方没有提供对应的起步依赖
在SpringBoot项目中，一般都会将这些公共组件封装为SpringBoot当中的starter(起步依赖)

SpringBoot官方starter命名： spring-boot-starter-xxxx
第三组织提供的starter命名： xxxx-spring-boot-starter

在自定义一个起步依赖starter的时候，按照规范需要定义两个模块：

starter模块（把程序开发所需要的依赖都定义在starter起步依赖中）
autoconfigure模块（自动配置）

之前阿里云OSS的使用：

配置文件

测试工程模块下

#配置阿里云OSS参数
aliyun:
  oss:
    endpoint: https://oss-cn-guangzhou.aliyuncs.com
    accessKeyId: xxxxx
    accessKeySecret: xxxxx
    bucketName: java84

AliOSSProperties类

aliyun-oss-spring-boot-autoconfigure模块下的oss包下

/*阿里云OSS相关配置*/
@Data
@ConfigurationProperties(prefix = "aliyun.oss")
public class AliOSSProperties {
    //区域
    private String endpoint;
    //身份ID
    private String accessKeyId ;
    //身份密钥
    private String accessKeySecret ;
    //存储空间
    private String bucketName;
}

AliOSSUtils工具类

aliyun-oss-spring-boot-autoconfigure模块下的oss包下


import lombok.Data;
import org.springframework.web.multipart.MultipartFile;

import java.io.IOException;
import java.io.InputStream;
import java.util.UUID;

@Data
public class AliOSSUtils {
    private AliOSSProperties aliOSSProperties;

    /**
     * 实现上传图片到OSS
     */
    public String upload(MultipartFile multipartFile) throws IOException {
        // 获取上传的文件的输入流
        InputStream inputStream = multipartFile.getInputStream();

        // 避免文件覆盖
        String originalFilename = multipartFile.getOriginalFilename();
        String fileName = UUID.randomUUID().toString() + originalFilename.substring(originalFilename.lastIndexOf("."));

        //上传文件到 OSS
        OSS ossClient = new OSSClientBuilder().build(aliOSSProperties.getEndpoint(),
                aliOSSProperties.getAccessKeyId(), aliOSSProperties.getAccessKeySecret());
        ossClient.putObject(aliOSSProperties.getBucketName(), fileName, inputStream);

        //文件访问路径
        String url =aliOSSProperties.getEndpoint().split("//")[0] + "//" + aliOSSProperties.getBucketName() + "." + aliOSSProperties.getEndpoint().split("//")[1] + "/" + fileName;

        // 关闭ossClient
        ossClient.shutdown();
        return url;// 把上传到oss的路径返回
    }
}

自动配置类AliOSSAutoConfiguration

aliyun-oss-spring-boot-autoconfigure模块下的oss包下

@Configuration//当前类为Spring配置类
@EnableConfigurationProperties(AliOSSProperties.class)//导入AliOSSProperties类，并交给SpringIOC管理
public class AliOSSAutoConfiguration {
    
    //创建AliOSSUtils对象，并交给SpringIOC容器
    @Bean
    public AliOSSUtils aliOSSUtils(AliOSSProperties aliOSSProperties){
        AliOSSUtils aliOSSUtils = new AliOSSUtils();
        aliOSSUtils.setAliOSSProperties(aliOSSProperties);
        return aliOSSUtils;
    }
}

自定义起步依赖步骤提示

第1步：创建自定义starter模块（进行依赖管理）
- 把阿里云OSS所有的依赖统一管理起来
第2步：创建autoconfigure模块
- 在starter中引入autoconfigure （我们使用时只需要引入starter起步依赖即可）
第3步：在autoconfigure中完成自动配置
1. 定义一个自动配置类，在自动配置类中将所要配置的bean都提前配置好
2. 定义配置文件，把自动配置类的全类名定义在配置文件中
第4步：测试
1. 使用apifox上传文件试试或者直接在原有工程试试

创建aliyun-oss-spring-boot-starter模块

删除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.7.3</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>

	<groupId>com.aliyun.oss</groupId>
	<artifactId>aliyun-oss-spring-boot-starter</artifactId>
	<version>0.0.1-SNAPSHOT</version>

	<properties>
		<java.version>1.8</java.version>
	</properties>
	
	<dependencies>
		<!--引入autoconfigure模块-->
		

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

</project>

创建aliyun-oss-spring-boot-autoconfigure模块

创建完模块后，删除多余的文件，最终保留内容如下：

删除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.7.3</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>

	<groupId>com.aliyun.oss</groupId>
	<artifactId>aliyun-oss-spring-boot-autoconfigure</artifactId>
	<version>0.0.1-SNAPSHOT</version>

	<properties>
		<java.version>1.8</java.version>
	</properties>

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

		<!--引入web起步依赖-->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>

		<!--Lombok-->
		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
		</dependency>

		<!--阿里云OSS-->
		<dependency>
			<groupId>com.aliyun.oss</groupId>
			<artifactId>aliyun-sdk-oss</artifactId>
			<version>3.15.1</version>
		</dependency>

		<dependency>
			<groupId>javax.xml.bind</groupId>
			<artifactId>jaxb-api</artifactId>
			<version>2.3.1</version>
		</dependency>
		<dependency>
			<groupId>javax.activation</groupId>
			<artifactId>activation</artifactId>
			<version>1.1.1</version>
		</dependency>
		<!-- no more than 2.3.3-->
		<dependency>
			<groupId>org.glassfish.jaxb</groupId>
			<artifactId>jaxb-runtime</artifactId>
			<version>2.3.3</version>
		</dependency>
	</dependencies>
</project>

将上诉素材中的AliOSSProperties和AliOSSUtils工具类以及自动配置类AliOSSAutoConfiguration导入到包中

4.在aliyun-oss-spring-boot-autoconfigure模块中的resources下，新建自动配置文件：

META-INF/spring.factories

其中的代码：

整体结构如下：

导入测试工程测试工程

测试前准备：

将之前关于阿里云的依赖和包都注释，以免干扰 👈 👈

1️⃣ 在test工程中引入阿里云starter依赖

通过依赖传递，会把autoconfigure依赖也引入了

<!--引入阿里云OSS起步依赖-->
<dependency>
 <groupId>com.aliyun.oss</groupId>
 <artifactId>aliyun-oss-spring-boot-starter</artifactId>
 <version>0.0.1-SNAPSHOT</version>
</dependency>

2️⃣ 在test工程中的application.yml文件中，配置阿里云OSS配置参数信息（从以前的工程中拷贝即可）


#配置阿里云OSS参数
aliyun:
  oss:
    endpoint: https://oss-cn-guangzhou.aliyuncs.com
    accessKeyId: LTAI5tGJKWuBifboPQrMQFze
    accessKeySecret: 在文章中有，找找，找不到问yange
    bucketName: java84

3️⃣ 在test工程中的UploadController类编写代码

@RestController
public class UploadController {

 @Autowired
 private AliOSSUtils aliOSSUtils;

 @PostMapping("/upload")
 public String upload(MultipartFile image) throws Exception {
     //上传文件到阿里云 OSS
     String url = aliOSSUtils.upload(image);
     System.out.println(url);
     return url;
 }

}

编写完代码后，我们启动当前的SpringBoot测试工程：

随着SpringBoot项目启动，自动配置会把AliOSSUtils的bean对象装配到IOC容器中

用postman工具进行文件上传：

通过断点可以看到自动注入AliOSSUtils的bean对象：

课堂作业

🚩 1. 模仿pagehelper起步依赖，完成起步依赖的定义，体会其流程，你就是这条该最靓的崽！

4. Web后端开发总结

Web后端开发总结open in new window

你想知道Maven仓库中收费的jar怎么管理吗？点击这里学习

SpingBoot原理

# SpingBoot原理

# 1. 配置优先级 🚀

# 2. Bean管理 🍐

# 2.1 手动获取Bean

# 2.2 Bean作用域

# 2.3 第三方Bean

# 3. SpringBoot原理 🍐🚀

# 3.1 起步依赖 🍐

# 3.2 自动配置

# 方案一

# 方案二

# 1️⃣ 使用@Import导入普通类：

# 2️⃣ 使用@Import导入配置类：

# 3️⃣ 使用@Import导入ImportSelector接口实现类：

# 4️⃣ 使用第三方依赖提供的 @EnableXxxxx注解

# 3.3 跟踪源码

# 3.4 如何保障三方的Bean是单例的

# 3.5 自定义自定义起步依赖了解即可 🚀

# 1️⃣ 在test工程中引入阿里云starter依赖

# 2️⃣ 在test工程中的application.yml文件中，配置阿里云OSS配置参数信息（从以前的工程中拷贝即可）

# 3️⃣ 在test工程中的UploadController类编写代码

# 4. Web后端开发总结

SpingBoot原理

1. 配置优先级 🚀

2. Bean管理 🍐

2.1 手动获取Bean

2.2 Bean作用域

2.3 第三方Bean

3. SpringBoot原理 🍐🚀

3.1 起步依赖 🍐

3.2 自动配置

方案一

方案二

1️⃣ 使用@Import导入普通类：

2️⃣ 使用@Import导入配置类：

3️⃣ 使用@Import导入ImportSelector接口实现类：

4️⃣ 使用第三方依赖提供的 @EnableXxxxx注解

3.3 跟踪源码

3.4 如何保障三方的Bean是单例的

3.5 自定义自定义起步依赖了解即可 🚀

1️⃣ 在test工程中引入阿里云starter依赖

2️⃣ 在test工程中的application.yml文件中，配置阿里云OSS配置参数信息（从以前的工程中拷贝即可）

3️⃣ 在test工程中的UploadController类编写代码

4. Web后端开发总结