springboot启动流程学习

已于 2022-12-13 20:10:36 修改
阅读量225 收藏
点赞数
分类专栏： 33 文章标签： spring boot 学习 java
于 2022-12-13 20:07:10 首次发布
原文链接：https://blog.csdn.net/A_art_xiang/article/details/121954905
版权

文章目录

SpringApplication初始化

// An highlighted block
package com.nwd;

import cn.hutool.extra.spring.EnableSpringUtil;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@EnableSpringUtil
public class AopTestApplication {

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

}

/**
  * 先创建SpringApplication对象，再执行run()方法
  */
public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {
		return new SpringApplication(primarySources).run(args);
	}

1.确定应用程序类型
2.获取bootstrappers：初始启动引导器
3.获取ApplicationContextInitializer初始化器
4.获取ApplicationListener 应用监听器
5.设置程序运行的主类

// An highlighted block
public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
		this.resourceLoader = resourceLoader;
		Assert.notNull(primarySources, "PrimarySources must not be null");
		this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
		this.webApplicationType = WebApplicationType.deduceFromClasspath();
		this.bootstrappers = new ArrayList<>(getSpringFactoriesInstances(Bootstrapper.class));
		setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
		setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
		this.mainApplicationClass = deduceMainApplicationClass();
	}

执行run()方法

// An highlighted block
// org.springframework.boot.SpringApplication#run(java.lang.String...)
public ConfigurableApplicationContext run(String... args) {
   // 应用停止监听器
   StopWatch stopWatch = new StopWatch();
   stopWatch.start(); // 记录应用的启动时间
 
   // 创建引导上下文（Context环境）createBootstrapContext()
   DefaultBootstrapContext bootstrapContext = createBootstrapContext();
   ConfigurableApplicationContext context = null;
   // 设置headless属性方法（java.awt.headless），让当前应用进入headless模式（自力更生模式，详情自行百度）
   configureHeadlessProperty();
   //获取所有 RunListener（运行监听器）【为了方便所有Listener进行事件感知】
   SpringApplicationRunListeners listeners = getRunListeners(args);
   // 遍历 SpringApplicationRunListener 调用 starting 方法，相当于通知所有对系统正在启动过程感兴趣的人，项目正在 starting。
   listeners.starting(bootstrapContext, this.mainApplicationClass);
   try {
      // 保存命令行参数；ApplicationArguments
      ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
      // 准备运行时环境
      ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, applicationArguments);
      configureIgnoreBeanInfo(environment);
      // 打印banner
      Banner printedBanner = printBanner(environment);
      // 创建IOC容器
      // 根据项目类型（Servlet）创建容器，当前会创建 AnnotationConfigServletWebServerApplicationContext
      context = createApplicationContext();
      context.setApplicationStartup(this.applicationStartup);
      // 准备ApplicationContext IOC容器的基本信息
      prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);
      // 刷新IOC容器，调用IOC容器的经典初始化过程，创建容器中的所有组件
      refreshContext(context);
      // 容器刷新完成后工作，方法是空的
      afterRefresh(context, applicationArguments);
      // 监控花费的时间
      stopWatch.stop();
      if (this.logStartupInfo) {
         new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
      }
      // 所有监听器 调用 listeners.started(context); 通知所有的监听器 started
      listeners.started(context);
      // 调用所有runners
      callRunners(context, applicationArguments);
   }
   // 如果有异常，调用Listener 的 failed方法
   catch (Throwable ex) {
      handleRunFailure(context, ex, listeners);
      throw new IllegalStateException(ex);
   }
 
   try {
      // 调用所有监听器的 running 方法 listeners.running(context); 通知所有的监听器 running
      listeners.running(context);
   }
   // running如果有问题。继续通知 failed 。调用所有 Listener 的 failed；通知所有的监听器 failed
   catch (Throwable ex) {
      handleRunFailure(context, ex, null);
      throw new IllegalStateException(ex);
   }
   return context;
}

（1）创建引导上下文（Context环境）

// An highlighted block
private DefaultBootstrapContext createBootstrapContext() {
   DefaultBootstrapContext bootstrapContext = new DefaultBootstrapContext(); // 创建默认的引导上下文
   // 获取到所有之前的 bootstrappers 挨个执行 intitialize() 来完成对引导启动器上下文环境设置
   this.bootstrappers.forEach((initializer) -> initializer.intitialize(bootstrapContext));
   return bootstrapContext;
}

（2）bootstrapper其实是个接口

// An highlighted block
public interface Bootstrapper {
 
   /**
    * Initialize the given {@link BootstrapRegistry} with any required registrations.
    * @param registry the registry to initialize
    */
   void intitialize(BootstrapRegistry registry);
}

（3）获取所有 RunListener（运行监听器）

// An highlighted block
private SpringApplicationRunListeners getRunListeners(String[] args) {
   Class<?>[] types = new Class<?>[] { SpringApplication.class, String[].class };
   return new SpringApplicationRunListeners(logger,
         getSpringFactoriesInstances(SpringApplicationRunListener.class, types, this, args),
         this.applicationStartup);
}

（4）准备运行时环境

// An highlighted block
// org.springframework.boot.SpringApplication#prepareEnvironment
private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners,
      DefaultBootstrapContext bootstrapContext, ApplicationArguments applicationArguments) {
   // Create and configure the environment
   // 返回或者创建基础环境信息对象。StandardServletEnvironment
   ConfigurableEnvironment environment = getOrCreateEnvironment();
   // 配置环境信息，通过命令行参数或者配置文件获取配置属性值
   configureEnvironment(environment, applicationArguments.getSourceArgs());
   // 绑定环境信息
   ConfigurationPropertySources.attach(environment);
   // 所有监听器遍历调用 listener.environmentPrepared()；通知所有的监听器当前环境准备完成
   listeners.environmentPrepared(bootstrapContext, environment);
   DefaultPropertiesPropertySource.moveToEnd(environment);
   // 激活额外的环境
   configureAdditionalProfiles(environment);
   // 绑定一些值
   bindToSpringApplication(environment);
   if (!this.isCustomEnvironment) {
      environment = new EnvironmentConverter(getClassLoader()).convertEnvironmentIfNecessary(environment,
            deduceEnvironmentClass());
   }
   ConfigurationPropertySources.attach(environment);
   return environment;
}

（5）创建IOC容器

// An highlighted block
// org.springframework.boot.SpringApplication#createApplicationContext
protected ConfigurableApplicationContext createApplicationContext() {
   // 根据项目类型（Servlet）创建容器，当前会创建 AnnotationConfigServletWebServerApplicationContext
   return this.applicationContextFactory.create(this.webApplicationType);
}

（6）准备ApplicationContext IOC容器的基本信息

// An highlighted block
// org.springframework.boot.SpringApplication#prepareContext
private void prepareContext(DefaultBootstrapContext bootstrapContext, ConfigurableApplicationContext context,
      ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,
      ApplicationArguments applicationArguments, Banner printedBanner) {
   // 保存基础环境信息
   context.setEnvironment(environment);
   // IOC容器的后置处理流程（注册一些组件、读取配置文件资源、注册资源加载器、准备类型转换器等等）
   postProcessApplicationContext(context);
   // 应用初始化器：applyInitializers
   // 遍历所有的 ApplicationContextInitializer 。调用 initialize方法。来对ioc容器进行初始化扩展功能
   applyInitializers(context);
   // 遍历所有的 listener 调用 contextPrepared方法。
   listeners.contextPrepared(context);
   bootstrapContext.close(context);
   if (this.logStartupInfo) {
      logStartupInfo(context.getParent() == null);
      logStartupProfileInfo(context);
   }
   // Add boot specific singleton beans
   ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
   beanFactory.registerSingleton("springApplicationArguments", applicationArguments);
   if (printedBanner != null) {
      beanFactory.registerSingleton("springBootBanner", printedBanner);
   }
   if (beanFactory instanceof DefaultListableBeanFactory) {
      ((DefaultListableBeanFactory) beanFactory)
            .setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
   }
   if (this.lazyInitialization) {
      context.addBeanFactoryPostProcessor(new LazyInitializationBeanFactoryPostProcessor());
   }
   // Load the sources
   Set<Object> sources = getAllSources();
   Assert.notEmpty(sources, "Sources must not be empty");
   load(context, sources.toArray(new Object[0]));
   // 所有的监听器 调用 contextLoaded。通知所有的监听器 contextLoaded
   listeners.contextLoaded(context);
}

（7）IOC容器的经典初始化过程
spring容器创建及加载

  1. 创建BeanFactory对象 ConfigurableListableBeanFactory beanFactory =
    obtainFreshBeanFactory();
  2. 设置beanFactory准备完成进行的后置处理工作 postProcessBeanFactory(beanFactory);
  3. 调用上下文中注册为bean的工厂处理器 invokeBeanFactoryPostProcessors(beanFactory);
    执行BeanFactoryPostProcessor
    BeanFactoryPostProcessor：BeanFactory的后置处理器。在BeanFactory标准初始化之后执行的。
    两个接口：BeanFactoryPostProcessor、BeanDefinitionRegistryPostProcessor

执行BeanFactoryPostProcessor

先执行BeanDefinitionRegistryPostProcessor

1）获取所有的BeanDefinitionRegistryPostProcessor

2）先执行实现了PriorityOrdered优先级接口的BeanDefinitionRegistryPostProcessor，执行postProcessor.postProcessBeanDefinitionRegistry(registry);

3）再执行实现了Ordered顺序接口的BeanDefinitionRegistryPostProcessor，执行postProcessor.postProcessBeanDefinitionRegistry(registry);

4）最后执行没有实现任何优先级或者顺序接口的BeanDefinitionRegistryPostProcessor，执行postProcessor.postProcessBeanDefinitionRegistry(registry);

再执行BeanFactoryPostProcessor的方法

1）获取所有的BeanFactoryPostProcessor

2）先执行实现了PriorityOrdered优先级接口的BeanFactoryPostProcessor，执行postProcessor.postProcessBeanFactory(beanFactory);

3）再执行实现了Ordered顺序接口的BeanFactoryPostProcessor，执行postProcessor.postProcessBeanFactory(beanFactory);

4）最后执行没有实现任何优先级或者顺序接口的BeanFactoryPostProcessor，执行postProcessor.postProcessBeanFactory(beanFactory);
  1. 注册BeanPostProcessors（bean的后置处理器）
    registerBeanPostProcessors(beanFactory);
    【拦截bean的创建过程】

几个接口（不同接口类型的BeanPostProcessor，在Bean创建前后的执行时机是不一样的）：

BeanPostProcessor 、

DestructionAwareBeanPostProcessor、

InstantationAwareBeanPostProcessor、

SmartInstantationAwareBeanPostProcessor、

MergedBeanDefinitionPostProcessor【放在internalPostProcessors里】。

（1）获取所有的BeanPostProcessor，后置处理器都默认可以通过PriorityOrdered、Ordered接口来指定优先级

（2）先注册PriorityOrdered优先级接口的BeanPostProcessor。

把每一个BeanPostProcessor添加到beanFactory中。beanFactory.addBeanPostProcessor(postProcessor);

（3）再注册实现Ordered接口的。

（4）最后注册没有实现任何优先级接口的。

（5）最终注册MergedBeanDefinitionPostProcessor。

（6）注册一个ApplicationListenerDetector，在Bean创建完之后检查是否是ApplicationListenerDetector，如果是，applicationContext.addApplicationListener((ApplicationListener<?>) bean);

  1. registerListeners();给容器中将项目里面的ApplicationListener注册进来

（1）从容器中拿到所有的ApplicationListener组件。

（2）将每个监听器添加到事件派发器中。

（3）派发之前步骤产生的事件。

  1. finishBeanFactoryInitialization(beanFactory);初始化所有剩下的单实例bean

链接: https://blog.csdn.net/A_art_xiang/article/details/121954905
链接: https://blog.csdn.net/A_art_xiang/article/details/122437676

weixin_42293526
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于Hutool包对数据库的增删改查操作
诗和远方，任重道远
07-04 1万+
这里就不介绍数据库的配置了，请参考 上一篇-如何正确使用Hutool和Guava这两个丰富的工具集，自己学习测试，样例 一、增删改操作 @Test @Ignore public void crudTest() throws SQLException { // 增 Long id = db.insertForGeneratedKey(Entity.create("user").set(...
java执行bat、exe等cmd命令
furenqiang的博客
07-05 3062
java执行cmd
Springboot结合Netty对接硬件，实现主动发送报文和接受硬件报文（ModbusRTU或者TCP以及DTU）
Crazy_Cw的博客
08-30 1万+
Springboot结合Netty对接硬件，实现主动发送报文和接受硬件报文（ModbusRTU或者TCP以及DTU）
Java 在Windows上通过代码开启和关闭exe程序
qq_51767561的博客
03-25 3039
开启和关闭exe程序的代码 import cn.hutool.core.collection.CollUtil; import cn.hutool.core.io.FileUtil; import lombok.extern.slf4j.Slf4j; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController;..
SpringBoot应用启动流程源码解析
08-19
SpringBoot应用启动流程源码解析是SpringBoot框架的核心部分，理解启动流程的源码解析对于深入学习和mastering SpringBoot非常重要。本文将通过详细的示例代码，介绍SpringBoot应用启动流程的源码解析，帮助大家更好...
springboot关于容器启动事件总结
08-25
在本文中，我们将总结 SpringBoot 容器启动事件的相关知识点，并提供实例代码以供大家学习。 一、容器启动事件的分类 在 SpringBoot 中，容器启动事件可以分为两种：ApplicationStartingEvent 和 ...
Springboot启动报错时实现异常定位
08-19
本文将主要介绍SpringBoot启动报错时实现异常定位的方法，通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值。 知识点一：Spring Boot框架简介 Spring Boot是一个基于Spring框架的子项目...
SpringBoot经典学习笔记_springboot_SpringBoot经典学习笔记_
09-30
SpringBoot是由Pivotal团队开发的框架，旨在简化Spring应用的初始搭建以及开发过程，通过“约定优于配置”的理念，使得Java开发者能够快速构建可运行的应用。 1. **SpringBoot简介** SpringBoot基于Spring框架，但...
SpringBoot 集成FluentMybatis 学习项目
11-04
SpringBoot以其简洁的配置和强大的依赖管理能力，大大简化了Web应用的搭建过程。而FluentMybatis则提供了一种流畅的API，使得SQL操作更为直观和易于维护。 首先，我们来看`SpringBoot`。SpringBoot是由Pivotal团队...
异步线程的使用
weixin_45168162的博客
04-20 1339
异步线程的使用 @Async注解异步线程不生效解决方案（二） @Async需要在不同类使用才会产生异步效果，方法一定要从另一个类中调用，也就是从类的外部调用，类的内部调用是无效的 没有走Spring的代理类。因为@Transactional和@Async注解的实现都是基于Spring的AOP，而AOP的实现是基于动态代理模式实现的。那么注解失效的原因就很明显了，有可能因为调用方法的是对象本身而不是代理对象，因为没有经过Spring容器管理 @SpringBootApplication启动类当中没有
hutool SpringUtil.getBean() NullPointerException
m0_49804107的博客
08-12 8082
hutool SpringUtil.getBean() NullPointerException
springboot实现定时任务不同任务异步执行，同一任务同步执行
zsj777的专栏
05-25 2513
Springboot @Scheduled 默认是单线程的， 也就是说当我们定义了多个定时任务时，如果有本应该是相同时间触发的定时任务， 会进行排队， 如果某个定时任务执行时间过长， 就会导致其他定时并未按照设置时间来触发执行。 异步任务可以部分解决这个问题， 在定时任务上再加上@Asyns注解，定时任务就会被作为异步任务多线程执行。 但是异步任务同样存在一个问题，如果任务执行顺序对结果没有影响，则可以用异步任务解决。但是如果同样的任务必须同步执行，但又不希望不同的定时任务之间也排队等待，则可以通过一
Spring Boot @Enable*注解的工作原理
qq_40091033的博客
05-13 895
作用：启用某种功能特性的注解 @Enable*注解的种类举例： （1）@EnableConfigurationProperties：用来启用将配置文件属性注入到bean中这一特性，和@ConfigurationProperties注解一起使用。 （2）@EnableAsync启用异步特性，与@Async（相当于对方法或类进行一个标记，具体开启异步任务由TaskExecutor来进行）一起使用 @Async作用 具体作用 Enable*原理一 原理二 import java.util.concurrent.T
springboot-自定义Enable*配置注解
iechenyb专栏
02-01 1806
1 定义EnableScanner注解，作用是对指定的packages文件夹下的类进行特殊处理，比如设置特殊值等！ ​ package com.cyb.myenable; import java.lang.annotation.Documented; import java.lang.annotation.ElementType; import java.lang.annotation.Ret...
Java常用类库以及简介，具体使用细节进行百度（爬虫爬取的数据）
吟啸徐行
03-27 2万+
来至于互联网 Office文档的Java处理包 POI [推荐] Apache POI是一个开源的Java读写Excel、WORD等微软OLE2组件文档的项目。目前POI已经有了Ruby版本。 结构： HSSF － 提供读写Microsoft Excel XL... Java常用工具包 Jodd [推荐] Jodd 是一个开源的 Java 工具集， 包含一些实用的工具类和小
Hutool Http客户端工具类-HttpUtil使用
热门推荐
旭东怪的博客
02-18 3万+
HttpUtil是应对简单场景下Http请求的工具类封装，这个工具类可以保证在一个方法之内完成Http请求。 1HttpUtil.get() 用于请求普通页面，然后返回页面内容的字符串，同时提供一些重载方法用于指定请求参数。 // 最简单的HTTP请求，可以自动通过header等信息判断编码，不区分HTTP和HTTPS String result1= HttpUtil.get("https://www.baidu.com"); // 当无法识别页面编码的时候，可以自定义请求页面的编码 Strin.
Hutool，一个贼好用的 Java 工具类库，Java开发必备利器
Thinkingcao的专栏
11-24 3063
工欲善其事必先利其器！ 今天给大家介绍一款超级强力的Java工具类库Hutool 。 一、简介 Hutool是一个小而全的Java工具类库，通过静态方法封装，降低相关API的学习成本，提高工作效率，使Java拥有函数式语言般的优雅，让Java语言也可以“甜甜的”。 Hutool中的工具方法来自于每个用户的精雕细琢，它涵盖了Java开发底层代码中的方方面面，它既是大型项目开发中解决小问题的利器，也是小型项目中的效率担当； Hutool是项目中“util”包友好的替代，它节省了开发人员对项目中公用类和公用工具方
推荐一款超厉害的国产Java工具类Hutool
初念初恋的博客
11-16 5443
Hutool是一个小而全的Java工具类库，通过静态方法封装，降低相关API的学习成本，提高工作效率，使Java拥有函数式语言般的优雅，让Java语言也可以“甜甜的”；
Springboot启动过程
最新发布
06-01
Spring Boot 启动过程可以分为以下几个步骤： 1. 加载配置文件：Spring Boot 会加载 application.properties 或 application.yml 文件中的配置，这些配置文件可以放在 classpath 下的 /config 目录中，也可以是 / 目录下。 2. 启动 Spring 应用上下文：Spring Boot 会创建一个 Spring 应用上下文，将加载的配置文件和各种 Bean 加载到应用上下文中。 3. 扫描和加载 Bean：Spring Boot 会扫描应用程序的类路径中的 @Component、@Service、@Controller、@Repository 等注解标记的类，并将它们加载到 Spring 的应用上下文中。 4. 启动自动配置：Spring Boot 会根据 classpath 中的 jar 包、类、注解等信息，自动配置 Spring 应用程序上下文中需要的各种组件。 5. 启动 Tomcat（或其他 Web 容器）：Spring Boot 会启动嵌入式的 Tomcat 容器，并将 Spring 应用上下文部署到 Tomcat 中。 6. 运行应用程序：Tomcat 启动后，Spring Boot 会启动 Web 应用程序，并将 HTTP 请求映射到相应的 Controller 上进行处理。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值