SpringBoot笔记

Spring系列 SpringBoot

发布时间 : 2022-12-06 20:08

字数:7.2k

springboot简介
1. 微服务
Spring Boot简介
1. Spring Boot 的主要优点：
与其他框架的区别
Spring Boot 的核心：约定优于配置
Spring Boot 2.0 都更新了什么
SpringBoot 源码常用注解拾遗
SpringBoot 启动过程
SpringBoot 自动配置原理
SpringBoot 的启动原理

springboot简介

微服务

什么是微服务

 微服务架构就是将单一程序开发成一个微服务，每个微服务运行在自己的进程中，并使用轻量级的机制通信，通常是HTTP RESTFUL API。这些服务围绕业务能力来划分，并通过自动化部署机制来独立部署。这些服务可以使用不同的编程语言，不同数据库，以保证最低限度的集中式管理。

微服务由来

微服务最早由Martin Fowler与James Lewis于2014年共同提出，微服务架构风格是一种使用一套小服务来开发单个应用的方式途径，每个服务运行在自己的进程中，并使用轻量级机制通信，通常是HTTP API，这些服务基于业务能力构建，并能够通过自动化部署机制来独立部署，这些服务使用不同的编程语言实现，以及不同数据存储技术，并保持最低限度的集中式管理。

为什么需要微服务？

在传统的IT行业软件大多都是各种独立系统的堆砌，这些系统的问题总结来说就是扩展性差，可靠性不高，维护成本高。到后面引入了SOA服务化，但是，由于 SOA 早期均使用了总线模式，这种总线模式是与某种技术栈强绑定的，比如：J2EE。这导致很多企业的遗留系统很难对接，切换时间太长，成本太高，新系统稳定性的收敛也需要一些时间。最终 SOA 看起来很美，但却成为了企业级奢侈品，中小公司都望而生畏。

微服务的优势

将复杂的业务拆分成多个小的业务，每个业务拆分成一个服务，将复杂的问题简单化。利于分工，降低新人的学习成本。
微服务系统是分布式系统，业务与业务之间完全解耦，随着业务的增加可以根据业务再拆分，具有极强的横向扩展能力。面对搞并发的场景可以将服务集群化部署，加强系统负载能力。
服务间采用HTTP协议通信，服务与服务之间完全独立。每个服务可以根据业务场景选取合适的编程语言和数据库。
微服务每个服务都是独立部署的，每个服务的修改和部署对其他服务没有影响。

微服务和SOA的关系

SOA即面向服务的架构，SOA是根据企业服务总线（ESB）模式来整合集成大量单一庞大的系统，微服务可以说是SOA的一种实现，将复杂的业务组件化。但它比ESB实现的SOA更加的轻便敏捷和简单。

Spring Boot简介

随着使用 Spring 进行开发的个人和企业越来越多，Spring 也慢慢从一个单一简洁的小框架变成一个大而全的开源软件，Spring 的边界不断进行扩充，到了后来 Spring 几乎可以做任何事情，市面上主流的开源软件、中间件都有 Spring 对应组件支持，人们在享用 Spring 的便利之后，也遇到了一些问题。

2013 年，微服务的概念也慢慢兴起，快速开发微小独立的应用变得更为急迫，Spring刚好处在这样一个交叉点上，于 2013 年初启动了 Spring Boot 项目的研发。2014 年，Spring Boot 伴随着 Spring 4.0 诞生发布了第一个正式版本。

Spring Boot 并不是要成为 Spring 平台里面众多“Foundation”层项目的替代者。Spring Boot 的目标不在于为已解决的问题域提供新的解决方案，而是为平台带来另一种开发体验，从而简化对这些已有技术的使用。对于已经熟悉 Spring 生态系统的开发人员来说，Spring Boot 是一个很理想的选择；对于采用 Spring 技术的新人来说，Spring Boot 提供一种更简洁的方式来使用这些技术。

Spring Boot 的主要优点：

为所有 Spring 开发者更快的入门
开箱即用，提供各种默认配置来简化项目配置
内嵌式容器TomcatJetty`简化 Web 项目
简化 XML 配置

嵌入式Tomcat、Jetty、 Undertow容器（无需部署war文件）。

提供的starters 简化构建配置

尽可能自动配置spring应用。

提供生产指标,例如指标、健壮检查和外部化配置

完全没有代码生成和XML配置要求

简言之，Spring Boot 是一个快速开发的框架,能够快速的整合第三方框架，简化 XML 配置，全部采用注解形式，内置 Tomcat 容器,帮助开发者能够实现快速开发，简化了应用系统的初始搭建以及开发过程。

常用的springboot starter项目依赖包，如果你要使用相应功能，只要加入相应的starter名称到pom.xml中即可，如果需要使用到配置或数据库连接，也只要在项目的application.properties或yaml中配置即可，项目启动时会自动在类路径中发现这两个配置文件并读取配置内容注入相应的类中。

spring-boot-starter-web-services: SOAP Web Services

spring-boot-starter-web: Web 和 RESTful 应用，这是默认常用的

spring-boot-starter-test:单元测试和集成测试，默认引用。

spring-boot-starter-jdbc: 传统 JDBC

spring-boot-starter-hateoas: 增加 HATEOAS 特性到服务。

spring-boot-starter-security: 使用spring安全实现验证和授权。

spring-boot-starter-data-jpa: Spring Data JPA with Hibernate

spring-boot-starter-cache: 激活 Spring Framework的缓存支持

spring-boot-starter-data-rest: 使用 Spring Data REST暴露简单的 REST 服务，

与其他框架的区别

Spring Boot 是在强大的 Spring 帝国生态基础上面发展而来，发明 Spring Boot 不是为了取代 Spring，因此该框架所具备的功能，是为了让人们更容易的使用 Spring。所以说没有 Spring 强大的功能和生态，就不会有后期 Spring Boot 的火热，Spring Boot 使用约定优于配置的理念，重新重构了 Spring 的使用，让 Spring 后续的发展更有生命力。

SpringBoot 和 Spring区别

什么是Spring

作为Java开发人员，大家都Spring都不陌生，简而言之，Spring框架为开发Java应用程序提供了全面的基础架构支持。它包含一些很好的功能，如依赖注入和开箱即用的模块，如：Spring JDBC 、Spring MVC 、Spring Security、 Spring AOP 、Spring ORM 、Spring Test，这些模块缩短应用程序的开发时间，提高了应用开发的效率例如，在Java Web开发的早期阶段，我们需要编写大量的代码来将记录插入到数据库中。但是通过使用Spring JDBC模块的JDBCTemplate，我们可以将操作简化为几行代码。

区别

简而言之，我们可以说Spring Boot只是Spring本身的扩展，使开发，测试和部署更加方便。

Spring 和 SpringMVC

Spring是一个一站式的轻量级的java开发框架，核心是控制反转（IOC）和面向切面（AOP），针对于开发的WEB层(springMvc)、业务层(Ioc)、持久层(jdbcTemplate)等都提供了多种配置解决方案；

SpringMVC是Spring基础之上的一个MVC框架，主要处理web开发的路径映射和视图渲染，属于Spring框架中WEB层开发的一部分；

SpringBoot 和 SpringMVC 区别

SpringBoot 是一个快速开发的框架,能够快速的整合第三方框架，简化 XML 配置，全部采用注解形式，内
嵌 Tomcat 容器,帮助开发者能够实现快速开发。SpringMVC 是一个封装了 Servlet API 的 MVC 框架，就像
其它的 MVC 框架，比如 Struts 一样负责处理 web 请求。SpringBoot 的 Web 组件默认集成的是 SpringMVC
框架。SpringMVC 通常被叫做控制层框架。

SpringBoot 和 SpringCloud 区别

SpringCloud 依赖于 SpringBoot 组件，或者说 Spring Cloud 构建于 Spring Boot 之上。它为微服务中涉及的
配置管理、服务治理、断路器、智能路由、控制总线、全局锁、决策竞选、分布式会话和集群状态管理通
常我们使用 SpringMVC 编写 http 协议接口，同时使用 SpringCloud 作为一套完整的微服务解决框架。

Spring Boot 的核心：约定优于配置

那么什么是约定优于配置呢？

约定优于配置（Convention Over Configuration），也称作按约定编程，是一种软件设计范式，旨在减少软件开发人员需做决定的数量、获得简单的好处，而又不失灵活性。

本质是说，开发人员仅需规定应用中不符约定的部分。例如，如果模型中有个名为 User 的类，那么数据库中对应的表就会默认命名为 user。只有在偏离这一约定时，例如将该表命名为“user_info”，才需写有关这个名字的配置。

我们可以按照这个思路来设想，我们约定 Controller 层就是 Web 请求层可以省略 MVC 的配置；我们约定在 Service 结尾的类自动注入事务，就可以省略了 Spring 的切面事务配置。

在 Spring 体系中，Spring Boot JPA 就是约定优于配置最佳实现之一，不需要关注表结构，我们约定类名即是表名，属性名即是表的字段，String 对应 varchar，long 对应 bigint，只有需要一些特殊要求的属性，我们再单独进行配置，按照这个约定我们可以将以前的工作大大简化。

Spring Boot 体系将约定优于配置的思想展现得淋漓尽致，小到配置文件、中间件的默认配置，大到内置容器、生态中的各种 Starters 无不遵循此设计规则。Spring Boot 鼓励各软件组织方创建自己的 Starter，创建 Starter 的核心组件之一就是 autoconfigure 模块，也是 Starter 的核心功能，在启动的时候进行自动装配，属性默认化配置。

可以说正是因为 Spring Boot 简化的配置和众多的 Starters 才让 Spring Boot 变得简单、易用、快速上手，也可以说正是约定优于配置的思想彻底落地才让 Spring Boot 走向辉煌。Spring Boot 约定优于配置的思想让 Spring Boot 项目非常容易上手，让编程变得更简单，其实编程本该很简单，简单才是编程的美。

Spring Boot 2.0 都更新了什么

2018 年 3 月 1 号 Spring Boot 2.0.0.RELEASE 正式发布，这是 Spring Boot 1.0 发布 4 年之后第一次重大修订，因此有多新功能和特性值得关注！在 Spring Boot 官方博客中我们了解到：Spring Boot 2.0 版本经历了 17 个月的开发，有 215 个不同的使用者提供了超过 6800 次的提交。

我们将 Spring Boot 2.0 更新的技术分为三类进行解读：

第一类，基础环境升级；

第二类，默认软件替换和优化；

第三类，新技术的引入。

基础环境升级

最低 JDK 8，支持 JDK 9，不再支持 Java 6 和 7

Spring Boot 2.0 要求 Java 8 作为最低版本，许多现有的 API 已更新，以利用 Java 8 的特性。例如，接口上的默认方法，函数回调以及新的 API，如 javax.time。如果你正在使用 Java 7 或更早版本，则在开发 Spring Boot 2.0 应用程序之前，需要升级你的 JDK。

Spring Boot 2.0 通过测试可以在 JDK 9 下正常运行，同时 Spring Boot 2.0 宣布不再支持 Java 6 和 7，据我了解国内绝大部分互联网公司的基本环境还在 JDK 7 或者 6 环境下运行，考虑升级 Spring Boot 2.0 的团队需要考虑这个因素。

依赖组件升级

Spring Boot 2.0 基于 Spring Framework 5 构建，本次 Spring Boot 的升级，同时也升级了部分其依赖的第三方组件，主要有以下几个：

Jetty 9.4，Jetty 是一个开源的 Servlet 容器，它为基于 Java 的 Web 内容，例如 JSP 和 Servlet 提供运行环境。Jetty 是使用 Java 语言编写的，它的 API 以一组 JAR 包的形式发布。
Tomcat 8.5，Apache Tomcat 8.5.x 旨在取代 8.0.x，完全支持 Java 9。
Flyway 5，Flyway 是独立于数据库的应用、管理并跟踪数据库变更的数据库版本管理工具。用通俗的话讲，Flyway 可以像 SVN 管理不同人的代码那样，管理不同人的 SQL 脚本，从而做到数据库同步。
Hibernate 5.2，Hibernate 是一款非常流行的 ORM 框架。
Gradle 3.4，Spring Boot 的 Gradle 插件在很大程度上已被重写，有了重大的改进。
Thymeleaf 3.0，Thymeleaf 3 相对于 Thymeleaf 2 有非常大的性能提升。

SpringBoot 源码常用注解拾遗

组合注解

当可能大量同时使用到几个注解到同一个类上，就可以考虑将这几个注解到别的注解上。被注解的注解我们就称之为组合注解。

元注解：可以注解到别的注解上的注解。
组合注解：被注解的注解我们就称之为组合注解。

@Value 【Spring 提供】

@Value 就相当于传统 xml 配置文件中的 value 字段。

假设存在代码：

@Component 
public class Person { 

@Value("i am name") 
private String name; 

}

上面代码等价于的配置文件：

<bean class="Person"> 
    <property name ="name" value="i am name"></property>
</bean>

我们知道配置文件中的 value 的取值可以是：

字面量
通过 ${key} 方式从环境变量中获取值
通过 ${key} 方式全局配置文件中获取值
#{SpEL}

所以，我们就可以通过 @Value(${key}) 的方式获取全局配置文件中的指定配置项。

@ConfigurationProperties 【SpringBoot 提供】

如果我们需要取 N 个配置项，通过 @Value 的方式去配置项需要一个一个去取，这就显得有点 low 了。我们可以使用 @ConfigurationProperties。

标有 @ConfigurationProperties 的类的所有属性和配置文件中相关的配置项进行绑定。（默认从全局配置文件中获取配置值），绑定之后我们就可以通过这个类去访问全局配置文件中的属性值了。

下面看一个实例：

1.在主配置文件中添加如下配置

person.name=kundy
person.age=13
person.sex=male

2.创建配置类，由于篇幅问题这里省略了 setter、getter 方法，但是实际开发中这个是必须的，否则无法成功注入。另外，@Component 这个注解也还是需要添加的。

@Component 
@ConfigurationProperties(prefix = "person") 
public class Person { 

private String name; 
private Integer age; 
private String sex; 

}

这里 @ConfigurationProperties 有一个 prefix 参数，主要是用来指定该配置项在配置文件中的前缀。

3.测试，在 SpringBoot 环境中，编写个测试方法，注入 Person 类，即可通过 Person 对象取到配置文件的值。

@Import 【Spring 提供】

@Import 注解支持导入普通 java 类，并将其声明成一个bean。主要用于将多个分散的 java config 配置类融合成一个更大的 config 类。

@Import 注解在 4.2 之前只支持导入配置类。
在4.2之后 @Import 注解支持导入普通的 java 类,并将其声明成一个 bean。

@Import 三种使用方式

直接导入普通的 Java 类。
配合自定义的 ImportSelector 使用。
配合 ImportBeanDefinitionRegistrar 使用。

1. 直接导入普通的 Java 类

1.创建一个普通的 Java 类。

public class Circle { 

public void sayHi() { 
    System.out.println("Circle sayHi()"); 
    } 

}

2.创建一个配置类，里面没有显式声明任何的 Bean，然后将刚才创建的 Circle 导入。

@Import({Circle.class}) 
@Configuration 
public class MainConfig { 

}

3.创建测试类。

public static void main(String[] args) { 

ApplicationContext context = new AnnotationConfigApplicationContext(MainConfig.class); 
Circle circle = context.getBean(Circle.class); 
circle.sayHi(); 

}

4.运行结果：

> Circle sayHi()

可以看到我们顺利的从 IOC 容器中获取到了 Circle 对象，证明我们在配置类中导入的 Circle 类，确实被声明为了一个 Bean。

2. 配合自定义的 ImportSelector 使用

ImportSelector 是一个接口，该接口中只有一个 selectImports 方法，用于返回全类名数组。所以利用该特性我们可以给容器动态导入 N 个 Bean。

1.创建普通 Java 类 Triangle。

public class Triangle { 

public void sayHi(){ 
System.out.println("Triangle sayHi()"); 
} 

}

2.创建 ImportSelector 实现类，selectImports 返回 Triangle 的全类名。

public class MyImportSelector implements ImportSelector { 

@Override 
public String[] selectImports(AnnotationMetadata annotationMetadata) { 
return new String[]{"annotation.importannotation.waytwo.Triangle"}; 
} 

}

3.创建配置类，在原来的基础上还导入了 MyImportSelector。

@Import({Circle.class,MyImportSelector.class}) 
@Configuration 
public class MainConfigTwo { 

}

4.创建测试类

public static void main(String[] args) { 

ApplicationContext context = new AnnotationConfigApplicationContext(MainConfigTwo.class); 
Circle circle = context.getBean(Circle.class); 
Triangle triangle = context.getBean(Triangle.class); 
circle.sayHi(); 
triangle.sayHi(); 

}

5.运行结果：

> Circle sayHi()  
> Triangle sayHi()

可以看到 Triangle 对象也被 IOC 容器成功的实例化出来了。

3. 配合 ImportBeanDefinitionRegistrar 使用

ImportBeanDefinitionRegistrar 也是一个接口，它可以手动注册bean到容器中，从而我们可以对类进行个性化的定制。(需要搭配 @Import 与 @Configuration 一起使用。）

1.创建普通 Java 类 Rectangle。

public class Rectangle { 

    public void sayHi() { 
        System.out.println("Rectangle sayHi()"); 
    } 

}

2.创建 ImportBeanDefinitionRegistrar 实现类，实现方法直接手动注册一个名叫 rectangle 的 Bean 到 IOC 容器中。

public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar { 

@Override 
public void registerBeanDefinitions(AnnotationMetadata annotationMetadata, BeanDefinitionRegistry beanDefinitionRegistry) { 

RootBeanDefinition rootBeanDefinition = new RootBeanDefinition(Rectangle.class); 
// 注册一个名字叫做 rectangle 的 bean 
beanDefinitionRegistry.registerBeanDefinition("rectangle", rootBeanDefinition); 
} 

}

3.创建配置类，导入 MyImportBeanDefinitionRegistrar 类。

@Import({Circle.class, MyImportSelector.class, MyImportBeanDefinitionRegistrar.class}) 
@Configuration 
public class MainConfigThree { 

}

4.创建测试类。

public static void main(String[] args) { 
    ApplicationContext context = new AnnotationConfigApplicationContext(MainConfigThree.class); 
    Circle circle = context.getBean(Circle.class); 
    Triangle triangle = context.getBean(Triangle.class); 
    Rectangle rectangle = context.getBean(Rectangle.class); 
    circle.sayHi(); 
    triangle.sayHi(); 
    rectangle.sayHi(); 
}

5.运行结果

> Circle sayHi()  
> Triangle sayHi()  
> Rectangle sayHi()

嗯对，Rectangle 对象也被注册进来了。

@Conditional 【Spring提供】

@Conditional 注释可以实现只有在特定条件满足时才启用一些配置。

下面看一个简单的例子：

1.创建普通 Java 类 ConditionBean，该类主要用来验证 Bean 是否成功加载。

public class ConditionBean { 

    public void sayHi() { 
        System.out.println("ConditionBean sayHi()"); 
    } 

}

2.创建 Condition 实现类，@Conditional 注解只有一个 Condition 类型的参数，Condition 是一个接口，该接口只有一个返回布尔值的 matches() 方法，该方法返回 true 则条件成立，配置类生效。反之，则不生效。在该例子中我们直接返回 true。

public class MyCondition implements Condition { 

    @Override 
    public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) { 
        return true; 
    } 

}

3.创建配置类，可以看到该配置的 @Conditional 传了我们刚才创建的 Condition 实现类进去，用作条件判断。

@Configuration 
@Conditional(MyCondition.class) 
public class ConditionConfig { 

    @Bean 
    public ConditionBean conditionBean(){ 
        return new ConditionBean(); 
    } 

}

4.编写测试方法。

public static void main(String[] args) { 

    ApplicationContext context = new AnnotationConfigApplicationContext(ConditionConfig.class); 
    ConditionBean conditionBean = context.getBean(ConditionBean.class); 
    conditionBean.sayHi(); 

}

5.结果分析

因为 Condition 的 matches 方法直接返回了 true，配置类会生效，我们可以把 matches 改成返回 false，则配置类就不会生效了。

除了自定义 Condition，Spring 还为我们扩展了一些常用的 Condition。常用注解，可以参考：深入理解Spring中的各种注解

SpringBoot 启动过程

在看源码的过程中，我们会看到以下四个类的方法经常会被调用，我们需要对一下几个类有点印象：

ApplicationContextInitializer
ApplicationRunner
CommandLineRunner
SpringApplicationRunListener

下面开始源码分析，先从 SpringBoot 的启动类的 run() 方法开始看，以下是调用链：SpringApplication.run() -> run(new Class[]{primarySource}, args) -> new SpringApplication(primarySources)).run(args)。

一直在run，终于到重点了，我们直接看 new SpringApplication(primarySources)).run(args) 这个方法。

上面的方法主要包括两大步骤：

创建 SpringApplication 对象。
运行 run() 方法。

创建 SpringApplication 对象

public SpringApplication(ResourceLoader resourceLoader, Class... primarySources) { 

this.sources = new LinkedHashSet(); 
this.bannerMode = Mode.CONSOLE; 
this.logStartupInfo = true; 
this.addCommandLineProperties = true; 
this.addConversionService = true; 
this.headless = true; 
this.registerShutdownHook = true; 
this.additionalProfiles = new HashSet(); 
this.isCustomEnvironment = false; 
this.resourceLoader = resourceLoader; 
Assert.notNull(primarySources, "PrimarySources must not be null"); 
// 保存主配置类（这里是一个数组，说明可以有多个主配置类） 
this.primarySources = new LinkedHashSet(Arrays.asList(primarySources)); 
// 判断当前是否是一个 Web 应用 
this.webApplicationType = WebApplicationType.deduceFromClasspath(); 
// 从类路径下找到 META/INF/Spring.factories 配置的所有 ApplicationContextInitializer，然后保存起来 
this.setInitializers(this.getSpringFactoriesInstances(ApplicationContextInitializer.class)); 
// 从类路径下找到 META/INF/Spring.factories 配置的所有 ApplicationListener，然后保存起来 
this.setListeners(this.getSpringFactoriesInstances(ApplicationListener.class)); 
// 从多个配置类中找到有 main 方法的主配置类（只有一个） 
this.mainApplicationClass = this.deduceMainApplicationClass(); 

}

运行 run() 方法

public ConfigurableApplicationContext run(String... args) { 

// 创建计时器 
StopWatch stopWatch = new StopWatch(); 
stopWatch.start(); 
// 声明 IOC 容器 
ConfigurableApplicationContext context = null; 
Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList(); 
this.configureHeadlessProperty(); 
// 从类路径下找到 META/INF/Spring.factories 获取 SpringApplicationRunListeners 
SpringApplicationRunListeners listeners = this.getRunListeners(args); 
// 回调所有 SpringApplicationRunListeners 的 starting() 方法 
listeners.starting(); 
Collection exceptionReporters; 
try { 
// 封装命令行参数 
ApplicationArguments applicationArguments = new DefaultApplicationArguments(args); 
// 准备环境，包括创建环境，创建环境完成后回调 SpringApplicationRunListeners#environmentPrepared()方法，表示环境准备完成 
ConfigurableEnvironment environment = this.prepareEnvironment(listeners, applicationArguments); 
this.configureIgnoreBeanInfo(environment); 
// 打印 Banner 
Banner printedBanner = this.printBanner(environment); 
// 创建 IOC 容器（决定创建 web 的 IOC 容器还是普通的 IOC 容器） 
context = this.createApplicationContext(); 
exceptionReporters = this.getSpringFactoriesInstances(SpringBootExceptionReporter.class, new Class[]{ConfigurableApplicationContext.class}, context); 
/*

- 准备上下文环境，将 environment 保存到 IOC 容器中，并且调用 applyInitializers() 方法
- applyInitializers() 方法回调之前保存的所有的 ApplicationContextInitializer 的 initialize() 方法
- 然后回调所有的 SpringApplicationRunListener#contextPrepared() 方法 
- 最后回调所有的 SpringApplicationRunListener#contextLoaded() 方法 
  */
  this.prepareContext(context, environment, listeners, applicationArguments, printedBanner); 
  // 刷新容器，IOC 容器初始化（如果是 Web 应用还会创建嵌入式的 Tomcat），扫描、创建、加载所有组件的地方 
  this.refreshContext(context); 
  // 从 IOC 容器中获取所有的 ApplicationRunner 和 CommandLineRunner 进行回调 
  this.afterRefresh(context, applicationArguments); 
  stopWatch.stop(); 
  if (this.logStartupInfo) { 
  (new StartupInfoLogger(this.mainApplicationClass)).logStarted(this.getApplicationLog(), stopWatch); 
  } 
  // 调用 所有 SpringApplicationRunListeners#started()方法 
  listeners.started(context); 
  this.callRunners(context, applicationArguments); 
  } catch (Throwable var10) { 
  this.handleRunFailure(context, var10, exceptionReporters, listeners); 
  throw new IllegalStateException(var10); 
  } 
  try { 
  listeners.running(context); 
  return context; 
  } catch (Throwable var9) { 
  this.handleRunFailure(context, var9, exceptionReporters, (SpringApplicationRunListeners)null); 
  throw new IllegalStateException(var9); 
  } 
  }

小结：

run() 阶段主要就是回调本节开头提到过的4个监听器中的方法与加载项目中组件到 IOC 容器中，而所有需要回调的监听器都是从类路径下的 META/INF/Spring.factories 中获取，从而达到启动前后的各种定制操作。

SpringBoot 自动配置原理

@SpringBootApplication 注解

SpringBoot 项目的一切都要从 @SpringBootApplication 这个注解开始说起。

@SpringBootApplication 标注在某个类上说明：

这个类是 SpringBoot 的主配置类。
SpringBoot 就应该运行这个类的 main 方法来启动 SpringBoot 应用。

该注解的定义如下：

@SpringBootConfiguration 
@EnableAutoConfiguration 
@ComponentScan( 
excludeFilters = {@Filter( 
type = FilterType.CUSTOM, 
classes = {TypeExcludeFilter.class} 
), @Filter( 
type = FilterType.CUSTOM, 
classes = {AutoConfigurationExcludeFilter.class} 
)} 
) 
public @interface SpringBootApplication { 

}

可以看到 SpringBootApplication 注解是一个组合注解（关于组合注解文章的开头有讲到），其主要组合了一下三个注解：

@SpringBootConfiguration：该注解表示这是一个 SpringBoot 的配置类，其实它就是一个 @Configuration 注解而已。
@ComponentScan：开启组件扫描。
@EnableAutoConfiguration：从名字就可以看出来，就是这个类开启自动配置的。嗯，自动配置的奥秘全都在这个注解里面。

@EnableAutoConfiguration 注解

先看该注解是怎么定义的：

@AutoConfigurationPackage 
@Import({AutoConfigurationImportSelector.class}) 
public @interface EnableAutoConfiguration { 
}

@AutoConfigurationPackage

从字面意思理解就是自动配置包。点进去可以看到就是一个 @Import 注解：@Import({Registrar.class})，导入了一个 Registrar 的组件。关于 @Import 的用法文章上面也有介绍哦。

我们在 Registrar 类中的 registerBeanDefinitions 方法上打上断点，可以看到返回了一个包名，该包名其实就是主配置类所在的包。

一句话：@AutoConfigurationPackage 注解就是将主配置类（@SpringBootConfiguration标注的类）的所在包及下面所有子包里面的所有组件扫描到Spring容器中。所以说，默认情况下主配置类包及子包以外的组件，Spring 容器是扫描不到的。

@Import({AutoConfigurationImportSelector.class})

该注解给当前配置类导入另外的 N 个自动配置类。（该注解详细用法上文有提及）。

配置类导入规则

那具体的导入规则是什么呢？我们来看一下源码。在开始看源码之前，先啰嗦两句。就像小马哥说的，我们看源码不用全部都看，不用每一行代码都弄明白是什么意思，我们只要抓住关键的地方就可以了。

我们知道 AutoConfigurationImportSelector 的 selectImports 就是用来返回需要导入的组件的全类名数组的，那么如何得到这些数组呢？

在 selectImports 方法中调用了一个 getAutoConfigurationEntry() 方法。

调用链：在 getAutoConfigurationEntry() -> getCandidateConfigurations() -> loadFactoryNames()。

在这里 loadFactoryNames() 方法传入了 EnableAutoConfiguration.class 这个参数。先记住这个参数，等下会用到。

loadFactoryNames() 中关键的三步：

从当前项目的类路径中获取所有 META-INF/spring.factories 这个文件下的信息。
将上面获取到的信息封装成一个 Map 返回。
从返回的 Map 中通过刚才传入的 EnableAutoConfiguration.class 参数，获取该 key 下的所有值。

META-INF/spring.factories 探究

听我这样说完可能会有点懵，我们来看一下 META-INF/spring.factories 这类文件是什么就不懵了。当然在很多第三方依赖中都会有这个文件，一般每导入一个第三方的依赖，除了本身的jar包以外，还会有一个 xxx-spring-boot-autoConfigure，这个就是第三方依赖自己编写的自动配置类。我们现在就以 spring-boot-autocongigure 这个依赖来说。

可以看到 EnableAutoConfiguration 下面有很多类，这些就是我们项目进行自动配置的类。

一句话：将类路径下 META-INF/spring.factories 里面配置的所有 EnableAutoConfiguration 的值加入到 Spring 容器中。

HttpEncodingAutoConfiguration

通过上面方式，所有的自动配置类就被导进主配置类中了。但是这么多的配置类，明显有很多自动配置我们平常是没有使用到的，没理由全部都生效吧。

接下来我们以 HttpEncodingAutoConfiguration为例来看一个自动配置类是怎么工作的。为啥选这个类呢？主要是这个类比较的简单典型。

先看一下该类标有的注解：

@Configuration @EnableConfigurationProperties({HttpProperties.class}) 
@ConditionalOnWebApplication( type = Type.SERVLET ) @ConditionalOnClass({CharacterEncodingFilter.class}) 
@ConditionalOnProperty( 
    prefix = "spring.http.encoding", value = {"enabled"}, matchIfMissing = true ) 
public class HttpEncodingAutoConfiguration { }

@Configuration：标记为配置类。
@ConditionalOnWebApplication：web应用下才生效。
@ConditionalOnClass：指定的类（依赖）存在才生效。
@ConditionalOnProperty：主配置文件中存在指定的属性才生效。
@EnableConfigurationProperties({HttpProperties.class})：启动指定类的ConfigurationProperties功能；将配置文件中对应的值和 HttpProperties 绑定起来；并把 HttpProperties 加入到 IOC 容器中。

因为 @EnableConfigurationProperties({HttpProperties.class})把配置文件中的配置项与当前 HttpProperties 类绑定上了。

然后在 HttpEncodingAutoConfiguration 中又引用了 HttpProperties ，所以最后就能在 HttpEncodingAutoConfiguration 中使用配置文件中的值了。

最终通过 @Bean 和一些条件判断往容器中添加组件，实现自动配置。（当然该Bean中属性值是从 HttpProperties 中获取）

HttpProperties

HttpProperties 通过 @ConfigurationProperties 注解将配置文件与自身属性绑定。

所有在配置文件中能配置的属性都是在 xxxProperties 类中封装着；配置文件能配置什么就可以参照某个功能对应的这个属性类。

@ConfigurationProperties( prefix = "spring.http" )// 从配置文件中获取指定的值和bean的属性进行绑定 public class HttpProperties { }

小结：

SpringBoot启动会加载大量的自动配置类。
我们看需要的功能有没有SpringBoot默认写好的自动配置类。
我们再来看这个自动配置类中到底配置了那些组件（只要我们要用的组件有，我们就不需要再来配置了）。
给容器中自动配置类添加组件的时候，会从properties类中获取某些属性。我们就可以在配置文件中指定这些属性的值。
xxxAutoConfiguration：自动配置类给容器中添加组件。
xxxProperties：封装配置文件中相关属性。

不知道小伙伴们有没有发现，很多需要待加载的类都放在类路径下的META-INF/Spring.factories 文件下，而不是直接写死这代码中，这样做就可以很方便我们自己或者是第三方去扩展，我们也可以实现自己 starter，让SpringBoot 去加载。现在明白为什么 SpringBoot 可以实现零配置，开箱即用了吧！

SpringBoot 的启动原理

https://segmentfault.com/a/1190000017792883