首页 > 编程语言 >可能是全网最全的SpringBoot启动流程源码分析（最新3.x版本）

可能是全网最全的SpringBoot启动流程源码分析（最新3.x版本）

时间：2023-08-15 14:37:59浏览次数：54  
标签：SpringBoot 最全 args SpringApplication listener application 源码 context void 

@SpringBootApplication(
    scanBasePackages = {"com.javaedge.base"}
)
public class BaseApplication {
    public BaseApplication() {
    }

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

1 启动入口

静态辅助类，可用于运行使用默认配置（即我们添加的一系列注解）的指定源的 SpringApplication 。

  • primarySource - 要载入的主要源，即指定源，这里为传入的Application.class Class\<?> ：泛型决定了任何类都可以传入
  • args - 应用程序参数（通常从main方法传递）
  • 返回：正在运行的ApplicationContext
public static ConfigurableApplicationContext run(Class<?> primarySource, String... args) {
  return run(new Class<?>[] { primarySource }, args);
}
public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {
  return new SpringApplication(primarySources).run(args);
}

构造一个SpringApplication的实例，然后再调用这里实例的run方法就表示启动SpringBoot。因此，想要分析SpringBoot的启动过程，我们需要熟悉：

  • SpringApplication的构造过程
  • SpringApplication的run方法执行过程

2 SpringApplication的构造过程

创建新 SpringApplication 实例。应用程序上下文将从指定的主要源加载 bean。实例可以在调用 run(String...)之前自定义。

public SpringApplication(Class<?>... primarySources) {
		this(null, primarySources);
	}
@SuppressWarnings({ "unchecked", "rawtypes" })
	public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
		this.resourceLoader = resourceLoader;
		Assert.notNull(primarySources, "PrimarySources must not be null");
		this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
    
    // 判断是否是web程序：
    // jakarta.servlet.Servlet
    // org.springframework.web.context.ConfigurableWebApplicationContext
    // 须都在类加载器中存在，并设置到webEnvironment属性
		this.webApplicationType = WebApplicationType.deduceFromClasspath();

    // 从 META-INF/spring.factories 中找K=ApplicationContextInitializer的类并实例化后
    // 设置到SpringApplication的initializers属性。即找出所有的应用程序初始化器
		this.bootstrapRegistryInitializers = new ArrayList<>(
				getSpringFactoriesInstances(BootstrapRegistryInitializer.class));
    
		setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));

    // 从spring.factories文件中找出key为ApplicationListener的类并实例化后
    // 设置到SpringApplication的listeners属性。即找出所有的应用程序事件监听器
		setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
    // 找出main类，这里是 BaseApplication 类
		this.mainApplicationClass = deduceMainApplicationClass();
	}

ApplicationContextInitializer

可能是全网最全的SpringBoot启动流程源码分析（最新3.x版本）_应用程序

应用程序初始化器，做一些初始化的工作。

用于在刷新之前初始化 Spring ConfigurableApplicationContext 的回调接口。 通常用于需要对应用程序上下文进行某种编程初始化的 Web 应用程序中。如针对上下文的环境注册属性源或激活配置文件。

ApplicationContextInitializer 鼓励处理器检测 Spring 的 Ordered 接口是否已实现或 @Order 注解是否存在，并在调用之前对实例进行相应的排序（如果有）

@FunctionalInterface
public interface ApplicationContextInitializer<C extends ConfigurableApplicationContext> {

	/**
	 * Initialize the given application context.
	 * @param applicationContext the application to configure
	 */
	void initialize(C applicationContext);

}

ApplicationListener

可能是全网最全的SpringBoot启动流程源码分析（最新3.x版本）_bootstrap_02

ApplicationEvent监听器：

@FunctionalInterface
public interface ApplicationListener<E extends ApplicationEvent> extends EventListener {

	void onApplicationEvent(E event);

	static <T> ApplicationListener<PayloadApplicationEvent<T>> forPayload(Consumer<T> consumer) {
		return event -> consumer.accept(event.getPayload());
	}

}

SpringApplicationEvent

可能是全网最全的SpringBoot启动流程源码分析（最新3.x版本）_bootstrap_03

应用程序的：

  • 启动事件，ApplicationStartingEvent。一旦一个 SpringApplication 开始，事件就会尽早发布 - 在 or ApplicationContext 可用之前Environment，但在注册之后ApplicationListener。事件的来源是本身SpringApplication，但要注意不要在这个早期阶段过多地使用其内部状态，因为它可能会在生命周期的后期被修改
  • 失败事件，ApplicationFailedEvent
  • 准备事件，ApplicationPreparedEvent 事件发布为 当一个SpringApplication正在启动并且ApplicationContext已完全准备好但未refresh。将加载 Bean 定义，并在此阶段可以使用
  • ApplicationEnvironmentPreparedEvent
  • ContextClosedEvent

应用程序事件监听器跟监听事件是绑定的，如：

  • ConfigServerBootstrapApplicationListener只跟ApplicationEnvironmentPreparedEvent事件绑定
  • LiquibaseServiceLocatorApplicationListener只跟ApplicationStartedEvent事件绑定
  • LoggingApplicationListener跟所有事件绑定

3 SpringApplication的执行

先看一些事件和监听器概念：

  • SpringApplicationRunListeners类
  • SpringApplicationRunListener类

3.1 SpringApplicationRunListeners

用于监听SpringApplication的run方法的执行。用于SpringApplicationRunListener监听器的批量执行。

finish：run方法结束之前调用；对应事件的类型是ApplicationReadyEvent或ApplicationFailedEvent

class SpringApplicationRunListeners {

  // Log日志类
	private final Log log;

  // 持有SpringApplicationRunListener集合
	private final List<SpringApplicationRunListener> listeners;

	private final ApplicationStartup applicationStartup;

  // run方法执行时立马执行；对应事件类型ApplicationStartingEvent
	void starting(ConfigurableBootstrapContext bootstrapContext, Class<?> mainApplicationClass) {
		doWithListeners("spring.boot.application.starting", (listener) -> listener.starting(bootstrapContext),
				(step) -> {
					if (mainApplicationClass != null) {
						step.tag("mainApplicationClass", mainApplicationClass.getName());
					}
				});
	}

  // ApplicationContext创建之前并且环境信息准备好的时候调用；对应事件类型ApplicationEnvironmentPreparedEvent
	void environmentPrepared(ConfigurableBootstrapContext bootstrapContext, ConfigurableEnvironment environment) {
		doWithListeners("spring.boot.application.environment-prepared",
				(listener) -> listener.environmentPrepared(bootstrapContext, environment));
	}

  // ApplicationContext创建好并且在source加载之前调用一次；没有具体的对应事件
	void contextPrepared(ConfigurableApplicationContext context) {
		doWithListeners("spring.boot.application.context-prepared", (listener) -> listener.contextPrepared(context));
	}

  // ApplicationContext创建并加载之后，并在refresh之前调用
  // 对应事件类型ApplicationPreparedEvent
	void contextLoaded(ConfigurableApplicationContext context) {
		doWithListeners("spring.boot.application.context-loaded", (listener) -> listener.contextLoaded(context));
	}


	void started(ConfigurableApplicationContext context, Duration timeTaken) {
		doWithListeners("spring.boot.application.started", (listener) -> listener.started(context, timeTaken));
	}

	void ready(ConfigurableApplicationContext context, Duration timeTaken) {
		doWithListeners("spring.boot.application.ready", (listener) -> listener.ready(context, timeTaken));
	}

	void failed(ConfigurableApplicationContext context, Throwable exception) {
		doWithListeners("spring.boot.application.failed",
				(listener) -> callFailedListener(listener, context, exception), (step) -> {
					step.tag("exception", exception.getClass().toString());
					step.tag("message", exception.getMessage());
				});
	}

	private void callFailedListener(SpringApplicationRunListener listener, ConfigurableApplicationContext context,
			Throwable exception) {
		try {
			listener.failed(context, exception);
		}
		catch (Throwable ex) {
			if (exception == null) {
				ReflectionUtils.rethrowRuntimeException(ex);
			}
			if (this.log.isDebugEnabled()) {
				this.log.error("Error handling failed", ex);
			}
			else {
				String message = ex.getMessage();
				message = (message != null) ? message : "no error message";
				this.log.warn("Error handling failed (" + message + ")");
			}
		}
	}

	private void doWithListeners(String stepName, Consumer<SpringApplicationRunListener> listenerAction) {
		doWithListeners(stepName, listenerAction, null);
	}

	private void doWithListeners(String stepName, Consumer<SpringApplicationRunListener> listenerAction,
			Consumer<StartupStep> stepAction) {
		StartupStep step = this.applicationStartup.start(stepName);
		this.listeners.forEach(listenerAction);
		if (stepAction != null) {
			stepAction.accept(step);
		}
		step.end();
	}

}

SpringApplicationRunListener目前只有一个实现类EventPublishingRunListener：

可能是全网最全的SpringBoot启动流程源码分析（最新3.x版本）_spring_04

/**
 * SpringApplicationRunListener to publish SpringApplicationEvents.
 * Uses an internal ApplicationEventMulticaster for the events that are fired
 * before the context is actually refreshed.
 */
class EventPublishingRunListener implements SpringApplicationRunListener, Ordered {

	private final SpringApplication application;

	private final String[] args;

	private final SimpleApplicationEventMulticaster initialMulticaster;

	@Override
	public void starting(ConfigurableBootstrapContext bootstrapContext) {
		multicastInitialEvent(new ApplicationStartingEvent(bootstrapContext, this.application, this.args));
	}

	@Override
	public void environmentPrepared(ConfigurableBootstrapContext bootstrapContext,
			ConfigurableEnvironment environment) {
		multicastInitialEvent(
				new ApplicationEnvironmentPreparedEvent(bootstrapContext, this.application, this.args, environment));
	}

	@Override
	public void contextPrepared(ConfigurableApplicationContext context) {
		multicastInitialEvent(new ApplicationContextInitializedEvent(this.application, this.args, context));
	}

	@Override
	public void contextLoaded(ConfigurableApplicationContext context) {
		for (ApplicationListener<?> listener : this.application.getListeners()) {
			if (listener instanceof ApplicationContextAware contextAware) {
				contextAware.setApplicationContext(context);
			}
			context.addApplicationListener(listener);
		}
		multicastInitialEvent(new ApplicationPreparedEvent(this.application, this.args, context));
	}

	@Override
	public void started(ConfigurableApplicationContext context, Duration timeTaken) {
		context.publishEvent(new ApplicationStartedEvent(this.application, this.args, context, timeTaken));
		AvailabilityChangeEvent.publish(context, LivenessState.CORRECT);
	}

	@Override
	public void ready(ConfigurableApplicationContext context, Duration timeTaken) {
		context.publishEvent(new ApplicationReadyEvent(this.application, this.args, context, timeTaken));
		AvailabilityChangeEvent.publish(context, ReadinessState.ACCEPTING_TRAFFIC);
	}

	@Override
	public void failed(ConfigurableApplicationContext context, Throwable exception) {
		ApplicationFailedEvent event = new ApplicationFailedEvent(this.application, this.args, context, exception);
		if (context != null && context.isActive()) {
			// Listeners have been registered to the application context so we should
			// use it at this point if we can
			context.publishEvent(event);
		}
		else {
			// An inactive context may not have a multicaster so we use our multicaster to
			// call all the context's listeners instead
			if (context instanceof AbstractApplicationContext abstractApplicationContext) {
				for (ApplicationListener<?> listener : abstractApplicationContext.getApplicationListeners()) {
					this.initialMulticaster.addApplicationListener(listener);
				}
			}
			this.initialMulticaster.setErrorHandler(new LoggingErrorHandler());
			this.initialMulticaster.multicastEvent(event);
		}
	}

  // 广播事件出去
	private void multicastInitialEvent(ApplicationEvent event) {
		refreshApplicationListeners();
		this.initialMulticaster.multicastEvent(event);
	}

	private void refreshApplicationListeners() {
		this.application.getListeners().forEach(this.initialMulticaster::addApplicationListener);
	}

	private static class LoggingErrorHandler implements ErrorHandler {

		private static final Log logger = LogFactory.getLog(EventPublishingRunListener.class);

		@Override
		public void handleError(Throwable throwable) {
			logger.warn("Error calling ApplicationEventListener", throwable);
		}

	}

}

它把监听过程封装成SpringApplicationEvent事件，并让内部属性initialMulticaster，ApplicationEventMulticaster接口的实现类SimpleApplicationEventMulticaster广播出去：

可能是全网最全的SpringBoot启动流程源码分析（最新3.x版本）_bootstrap_05

广播出去的事件对象会被SpringApplication中的listeners属性进行处理。

可能是全网最全的SpringBoot启动流程源码分析（最新3.x版本）_应用程序_06

所以SpringApplicationRunListener和ApplicationListener之间的关系是通过ApplicationEventMulticaster广播出去的SpringApplicationEvent所联系。

可能是全网最全的SpringBoot启动流程源码分析（最新3.x版本）_应用程序_07

创建所有 Spring 运行监听器并发布应用启动事件

调用 getSpringFactoriesInstances 获取配置的监听器名称，并实例化所有的类。

SpringApplicationRunListener 所有监听器配置在 pring.factories ：

可能是全网最全的SpringBoot启动流程源码分析（最新3.x版本）_spring_08

3.2 run

public ConfigurableApplicationContext run(String... args) {
    // 开始执行，记录开始时间
		long startTime = System.nanoTime();
		DefaultBootstrapContext bootstrapContext = createBootstrapContext();
		ConfigurableApplicationContext context = null;
    // 设置系统属性 java.awt.headless 的值，默认为true
		configureHeadlessProperty();
    
    // 获取SpringApplicationRunListeners，内部只有一个EventPublishingRunListener
    // 创建所有 Spring 运行监听器并发布应用启动事件
		SpringApplicationRunListeners listeners = getRunListeners(args);
    
    // 会封装成SpringApplicationEvent事件然后广播出去给SpringApplication中的listeners所监听
    // 这里接受ApplicationStartedEvent事件的listener会执行相应操作
		listeners.starting(bootstrapContext, this.mainApplicationClass);
		try {
      // 初始化默认应用参数类
			ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
      
      // 根据运行监听器和应用参数来准备 Spring 环境
			ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, applicationArguments);
			Banner printedBanner = printBanner(environment);
      
      // 创建Spring容器，即创建应用上下文
			context = createApplicationContext();
			context.setApplicationStartup(this.applicationStartup);
     // 准备应用上下文
			prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);
			refreshContext(context);
      
      // 容器创建完成之后执行额外一些操作
			afterRefresh(context, applicationArguments);
			Duration timeTakenToStartup = Duration.ofNanos(System.nanoTime() - startTime);
			if (this.logStartupInfo) {
				new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), timeTakenToStartup);
			}
      // 广播出ApplicationReadyEvent事件给相应的监听器执行
      // 发布应用上下文启动完成事件
			listeners.started(context, timeTakenToStartup);
			callRunners(context, applicationArguments);
		}
		catch (Throwable ex) {
			if (ex instanceof AbandonedRunException) {
				throw ex;
			}
			handleRunFailure(context, ex, listeners);
			throw new IllegalStateException(ex);
		}
		try {
			if (context.isRunning()) {
				Duration timeTakenToReady = Duration.ofNanos(System.nanoTime() - startTime);
        // 发布应用上下文就绪事件
				listeners.ready(context, timeTakenToReady);
			}
		}
		catch (Throwable ex) {
			if (ex instanceof AbandonedRunException) {
				throw ex;
			}
      // 过程报错的话会执行一些异常操作
      // 然后广播出ApplicationFailedEvent事件给相应的监听器执行
			handleRunFailure(context, ex, null);
			throw new IllegalStateException(ex);
		}
    // 返回Spring容器
		return context;
	}
设置系统属性 java.awt.headless 的值
private void configureHeadlessProperty() {
  System.setProperty(SYSTEM_PROPERTY_JAVA_AWT_HEADLESS,
      System.getProperty(SYSTEM_PROPERTY_JAVA_AWT_HEADLESS, Boolean.toString(this.headless)));
}

对于一个 Java 服务器来说经常要处理一些图形元素，例如地图的创建或者图形和图表等。这些API基本上总是需要运行一个X-server以便能使用AWT（Abstract Window Toolkit，抽象窗口工具集）。然而运行一个不必要的 X-server 并不是一种好的管理方式。有时你甚至不能运行 X-server,因此最好的方案是运行 headless 服务器，来进行简单的图像处理。

参考：www.cnblogs.com/princessd8251/p/4000016.html

标签：SpringBoot,最全,args,SpringApplication,listener,application,源码,context,void
From： https://blog.51cto.com/JavaEdge/7088335

相关文章

  • 驱动的医疗创新：开发智慧医疗领域的在线问诊系统源码
    随着信息技术的迅速发展，医疗领域也在不断进行着创新和变革。其中，代码驱动的医疗创新在近年来成为了一个备受关注的话题。本文将探讨如何利用代码驱动的方法，开发智慧医疗领域的在线问诊系统，为患者和医生提供更便捷、高效的医疗服务。一、背景智慧医疗作为信息技术与医疗相结合的新兴......
  • 基于微信小程序的微海商城设计与实现-计算机毕业设计源码+LW文档
    摘 要随着互联网技术的发展，传统的商品销售迎来了机遇，我国是个人口大国，商品的需求量大，如何推广商品的销售是企业非常关注的事情。随着电子商务多元化的发展，各种类型的商品逐渐转移到线上销售。在互联网的帮助下，带动企业打开销路，促进商品销售的可持续发展。同时，通过基于微信小程......
  • 基于微信小程序的房屋租赁小程序设计与实现-计算机毕业设计源码+LW文档
    摘要随着计算机技术的不断发展，有效地促进了社会各行业的进步，信息化逐渐运用到人们的生活中。传统模式的房屋租赁管理满足不了现代人的生活追求、服务质量和服务速度。使用管理系统进行管理，成本大大减小，同时可借助互联网强大的流量入口，使得推广的难度也大大降低。因此设计一个管理......
  • 基于微信小程序的居民疫情服务系统-计算机毕业设计源码+LW文档
    摘 要新冠病毒传播迅速，已经严重影响了人类生命安全，防控手段成为大众关注的重点。另外，随着目前信息化手段的进步，使用技术手段可以有效的对新冠疫情进行防控管理。在社区，人员多，出入流动性大，如果单靠人工进行管理，很难进行有效的统计。为此提出开发基于微信小程序的居民疫情服务系统......
  • SpringBoot3集成Redis
    目录一、简介二、工程搭建1、工程结构2、依赖管理3、Redis配置三、Redis用法1、环境搭建2、数据类型3、加锁机制四、Mybatis缓存1、基础配置2、自定义实现五、参考源码标签：Redis.Mybatis.Lock；一、简介缓存在项目开发中，基本上是必选组件之一，Redis作为一个key-value存储系统，具......
  • 直播源码异步处理技术：处理用户请求的挑战
    在网络技术的快速发展背景下，直播源码平台已经成为了人们社交娱乐的重要工具，直播源码平台的用户会在平台内进行观看直播、短视频，与其他用户进行交流、交谈。由于直播源码平台用户数量的逐日增加，使得直播源码平台每天要应对、处理大量的用户请求，增加了平台的压力，为了应对每天处理大......
  • Mybatis操作数据库流程源码
    Java操作数据库需要经过3个大步骤：获取数据库连接执行SQL语句关闭数据库连接Mybatis将这几个步骤进行了封装，将获取数据库连接的给工作交给了SqlSessionFactory，将执行SQL的工作交给了SqlSession。1获取SqlSession在程序启动时，会根据配置创建SqlSessionFactory：SqlSessionFa......
  • SpringBoot 3.0日志系统设计LoggingSystem详解
    0前言SpringBoot对日志的配置和加载进行了封装，让我们可以很方便地使用一些日志框架，只需要定义对应日志框架的配置文件，如LogBack、Log4j、Log4j2等，代码内部便可以直接使用。如我们在resources目录下定义了一个logbackxml文件，文件内容是logback相关配置，然后就可以直接在代码在使用L......
  • 知识付费到底使用哪个平台好，网课平台兔知云课堂源码
    知识付费平台分成两类。一类是学浪就是抖音的亲儿子，还有一类是所谓的第三方小程序平台，大多数的老师呢还是选择学浪，有的老师没办法入住，一些课程我们选择第三方平台。那么这两个到底有什么样的区别，或者优缺点呢？我们来对比一下。首先雪浪的优点呢就是首先是免费，另外课程录好之后，我......
  • SpringBoot 启动流程追踪(第二篇)
    上一篇文章分析了除refresh方法外的流程，并着重分析了load方法，这篇文章就主要分析refresh方法，可以说refresh方法是springboot启动流程最重要的一环，没有之一。try{ //Allowspost-processingofthebeanfactoryincontextsubclasses. postProcessBeanFactory(bea......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99