32 SpringBoot啟動原理與流程

阿新 • • 發佈：2018-12-29

1 啟動原理

1.1 入口(Springboot27Application.java)

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

1.2 開始啟動(SpringBootApplication.java)

public static ConfigurableApplicationContext run 
(Class<?> primarySource, String... args) {
	return run(new Class[]{primarySource}, args);
}
	
public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {
	/*
		專案啟動分為2步
			1: new SpringApplication(primarySources)
				建立SpringApplication物件
				
			2: .run(args)
				執行run方法
	*/ 

	return (new SpringApplication(primarySources)).run(args);
}

1.2.1 建立SpringApplication物件

public SpringApplication(Class... primarySources) {
	this((ResourceLoader)null, primarySources);
}

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));
	
	// 1 獲取應用型別
	this.webApplicationType = WebApplicationType.deduceFromClasspath();
	
	// 從類路徑下找到META-INF/spring.factories配置的所有ApplicationContextInitializer,然後儲存起來
	this.setInitializers(this.getSpringFactoriesInstances(ApplicationContextInitializer.class));
	
	// 3 從類路徑下找到META-INF/spring.factories配置的所有ApplicationListener
	this.setListeners(this.getSpringFactoriesInstances(ApplicationListener.class));
	
	// 4 從多個配置類中找到有main方法的主配置類
	this.mainApplicationClass = this.deduceMainApplicationClass();
}

1.2.1.1 獲取應用型別

static WebApplicationType deduceFromClasspath() {
	// 根據容器中指定的類是否存在來判斷應用型別
	if (ClassUtils.isPresent("org.springframework.web.reactive.DispatcherHandler", (ClassLoader)null) && !ClassUtils.isPresent("org.springframework.web.servlet.DispatcherServlet", (ClassLoader)null) && !ClassUtils.isPresent("org.glassfish.jersey.servlet.ServletContainer", (ClassLoader)null)) {
		return REACTIVE;
	} else {
		String[] var0 = SERVLET_INDICATOR_CLASSES;
		int var1 = var0.length;

		for(int var2 = 0; var2 < var1; ++var2) {
			String className = var0[var2];
			if (!ClassUtils.isPresent(className, (ClassLoader)null)) {
				return NONE;
			}
		}

		return SERVLET;
	}
}

1.2.1.2 配置的所有ApplicationContextInitializer

private <T> Collection<T> getSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes, Object... args) {
	ClassLoader classLoader = this.getClassLoader();
	Set<String> names = new LinkedHashSet(SpringFactoriesLoader.loadFactoryNames(type, classLoader));
	......
	return instances;
}

SpringFactoriesLoader.loadFactoryNames

public static List<String> loadFactoryNames(Class<?> factoryClass, @Nullable ClassLoader classLoader) {
	String factoryClassName = factoryClass.getName();
	return (List)loadSpringFactories(classLoader).getOrDefault(factoryClassName, Collections.emptyList());
}

private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
	MultiValueMap<String, String> result = (MultiValueMap)cache.get(classLoader);
	if (result != null) {
		return result;
	} else {
		try {
			// 從類路徑下找到META-INF/spring.factories配置的所有ApplicationContextInitializer
			// eg: org/springframework/boot/spring-boot-autoconfigure/2.1.0.RELEASE/spring-boot-autoconfigure-2.1.0.RELEASE.jar!/META-INF/spring.factories
			# Application Context Initializers
			org.springframework.context.ApplicationContextInitializer=\
			org.springframework.boot.context.ConfigurationWarningsApplicationContextInitializer,\
			org.springframework.boot.context.ContextIdApplicationContextInitializer,\
			org.springframework.boot.context.config.DelegatingApplicationContextInitializer,\
			org.springframework.boot.web.context.ServerPortInfoApplicationContextInitializer
			
			/*
				從類路徑下找到META-INF/spring.factories配置的所有ApplicationContextInitializer
				
				eg: org/springframework/boot/spring-boot-autoconfigure/2.1.0.RELEASE/spring-boot-autoconfigure-2.1.0.RELEASE.jar!/META-INF/spring.factories
					# Application Context Initializers
					org.springframework.context.ApplicationContextInitializer=\
					org.springframework.boot.context.ConfigurationWarningsApplicationContextInitializer,\
					org.springframework.boot.context.ContextIdApplicationContextInitializer,\
					org.springframework.boot.context.config.DelegatingApplicationContextInitializer,\
					org.springframework.boot.web.context.ServerPortInfoApplicationContextInitializer
			*/
			Enumeration<URL> urls = classLoader != null ? classLoader.getResources("META-INF/spring.factories") : ClassLoader.getSystemResources("META-INF/spring.factories");
			......
			// 儲存起來
			cache.put(classLoader, result);
			return result;
		} catch (IOException var13) {
			throw new IllegalArgumentException("Unable to load factories from location [META-INF/spring.factories]", var13);
		}
	}
}

所有的ApplicationContextInitializer

1.2.1.3 配置的所有ApplicationListener

原理與 1.2.1.2 中一致

所有ApplicationListener

1.2.1.4 配置的所有ApplicationListener

1.2.2 執行run方法

public ConfigurableApplicationContext run(String... args) {
	// 1 監聽
	StopWatch stopWatch = new StopWatch();
	stopWatch.start();
	
	// 2 宣告一個空的IOC容器
	ConfigurableApplicationContext context = null;
	Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList();
	this.configureHeadlessProperty();
	
	// 3 獲取SpringApplicationRunListeners: 底層使用getSpringFactoriesInstances()方法獲取,原理與1.2.1.2中一致(從類路徑下META-INF/spring.factories)
	SpringApplicationRunListeners listeners = this.getRunListeners(args);
	
	// 4 回撥所有的獲取SpringApplicationRunListener.starting()方法
	listeners.starting();

	Collection exceptionReporters;
	try {
		// 5 封裝命令列引數(專案啟動時,可以在命令列中指定引數)
		ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
		
		//6 準備環境,建立環境完成後回撥SpringApplicationRunListener.environmentPrepared()；表示環境準備完成
		ConfigurableEnvironment environment = this.prepareEnvironment(listeners, applicationArguments);
		
		this.configureIgnoreBeanInfo(environment);
		
		// 7 列印banner圖示
		Banner printedBanner = this.printBanner(environment);
		
		// 8 建立ApplicationContext : 建立IOC容器
		context = this.createApplicationContext();
		exceptionReporters = this.getSpringFactoriesInstances(SpringBootExceptionReporter.class, new Class[]{ConfigurableApplicationContext.class}, context);
		
		/*
			9 準備上下文環境 
				將配置好的環境放入IOC容器
				
				applyInitializers()：回撥之前儲存的所有的ApplicationContextInitializer的initialize方法(1.2.1.2)
				
				回撥所有的SpringApplicationRunListener的contextPrepared()；
				
				prepareContext執行完成以後回撥所有的SpringApplicationRunListener的contextLoaded()
		*/
		this.prepareContext(context, environment, listeners, applicationArguments, printedBanner);
		
	
        // 10 重新整理容器 : ioc容器初始化（如果是web應用還會建立嵌入式的Tomcat）
		// 掃描，建立，載入所有元件的地方；（配置類，元件，自動配置）
		this.refreshContext(context);
		
		this.afterRefresh(context, applicationArguments);
		stopWatch.stop();
		if (this.logStartupInfo) {
			(new StartupInfoLogger(this.mainApplicationClass)).logStarted(this.getApplicationLog(), stopWatch);
		}

		listeners.started(context);
		
		/*
			11 從ioc容器中獲取所有的ApplicationRunner和CommandLineRunner進行回撥
				ApplicationRunner先回調,CommandLineRunner再回調
		*/
		this.callRunners(context, applicationArguments);
	} catch (Throwable var10) {
		this.handleRunFailure(context, var10, exceptionReporters, listeners);
		throw new IllegalStateException(var10);
	}

	try {
		listeners.running(context);
		
		//整個SpringBoot應用啟動完成以後返回啟動的ioc容器；
		return context;
	} catch (Throwable var9) {
		this.handleRunFailure(context, var9, exceptionReporters, (SpringApplicationRunListeners)null);
		throw new IllegalStateException(var9);
	}
}

1.2.2.1 獲取SpringApplicationRunListeners

3 獲取SpringApplicationRunListeners

1.2.2.2 準備環境

private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments) {
	// 判斷環境是否存在,存在及獲取,不存在及建立
	ConfigurableEnvironment environment = this.getOrCreateEnvironment();
	
	// 配置環境
	this.configureEnvironment((ConfigurableEnvironment)environment, applicationArguments.getSourceArgs());
	
	// 建立環境完成後回撥SpringApplicationRunListener.environmentPrepared()；表示環境準備完成
	listeners.environmentPrepared((ConfigurableEnvironment)environment);
	
	this.bindToSpringApplication((ConfigurableEnvironment)environment);
	if (!this.isCustomEnvironment) {
		environment = (new EnvironmentConverter(this.getClassLoader())).convertEnvironmentIfNecessary((ConfigurableEnvironment)environment, this.deduceEnvironmentClass());
	}

	ConfigurationPropertySources.attach((Environment)environment);
	return (ConfigurableEnvironment)environment;
}

1.2.2.3 準備上下文環境

private void prepareContext(ConfigurableApplicationContext context, ConfigurableEnvironment environment, SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments, Banner printedBanner) {
	// 將配置好的環境放入IOC容器
	context.setEnvironment(environment);
	
	// 後置處理
	this.postProcessApplicationContext(context);
	
	// 回撥之前儲存的所有的ApplicationContextInitializer的initialize方法
	this.applyInitializers(context);
	
	// 回撥所有的SpringApplicationRunListener的contextPrepared(1.2.1.3)
	listeners.contextPrepared(context);
	
	// 日誌記錄
	if (this.logStartupInfo) {
		this.logStartupInfo(context.getParent() == null);
		this.logStartupProfileInfo(context);
	}

	ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
	
	// 將命令列引數註冊進來
	beanFactory.registerSingleton("springApplicationArguments", applicationArguments);
	
	// 將banner註冊
	if (printedBanner != null) {
		beanFactory.registerSingleton("springBootBanner", printedBanner);
	}

	if (beanFactory instanceof DefaultListableBeanFactory) {
		((DefaultListableBeanFactory)beanFactory).setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
	}

	Set<Object> sources = this.getAllSources();
	Assert.notEmpty(sources, "Sources must not be empty");
	this.load(context, sources.toArray(new Object[0]));
	
	// 回撥所有的SpringApplicationRunListener的contextLoaded()
	listeners.contextLoaded(context);
}

32 SpringBoot啟動原理與流程

1 啟動原理 1.1 入口(Springboot27Application.java) @SpringBootApplication public class Springboot27Application { public static void main(String

SpringBoot啟動原理及相關流程

一、springboot啟動原理及相關流程概覽 springboot是基於spring的新型的輕量級框架，最厲害的地方當屬自動配

Nginx 啟動原理與模型

操作 sele -s 這樣的影響非阻塞 select images load Nginx 在啟動後，在 unix 系統中會以 daemon 的方式在後臺運行，後臺進程包含一個 master 進程和多個 worker 進程。 master 進程主要用來管理 worker

帶著萌新看springboot原始碼11（springboot啟動原理原始碼上）

　　通過前面這麼多講解，springboot原理應該也大概有個輪廓了，一些基本的配置，從客戶端url到controller（配置一些要用的元件，servlet三大元件，處理器對映器，攔截器，檢視解析器這些都說過了），然後通過Dao和資料庫打交道（配置資料來源、Druid監控都說了，其實我後面要

窺看 SpringBoot 的原理與使用

一：SpringBoot的啟動 1. 繼承spring-boot-starter-parent專案 2. 匯入spring-boot-dependencies專案依賴二：Spring Boot 主類及目錄結構介紹 Spring Boot 與傳統專案最大的區別是，傳統專案都是打成 WAR 包部

Springboot啟動logback與slf4j的jar衝突

使用Maven管理SpringBoot專案，啟動的時候遇到異常： Exception in thread "main" java.lang.IllegalArgumentException: LoggerFactory is not a Logback LoggerContext but Lo

springboot 啟動原理詳解

前言 SpringBoot為我們做的自動配置，確實方便快捷，但是對於新手來說，如果不大懂SpringBoot內部啟動原理，以後難免會吃虧。所以這次博主就跟你們一起一步步揭開SpringBoot的神祕面紗，讓它不在神祕。正文我們開發任何一個Spring Boot

基於上下文的自適應變長編碼CAVLC原理與流程

CAVLC -CAVLC概念 AVLC的全稱是Context-Adaptive Varialbe-Length Coding，即基於上下文的自適應變長編碼。CAVLC的本質是變長編碼，它的特性主要體現在自適應能力上，CAVLC可以根據已編碼句法元素的情況動態的選擇編碼中使用

詳解SpringBoot——啟動原理及自定義starter

模塊開始 print handler man comm toc ade ogg 一、引言 SpringBoot的一大優勢就是Starter，由於SpringBoot有很多開箱即用的Starter依賴，使得我們開發變得簡單，我們不需要過多的關註框架的配置。在日常開發中，

springboot 啟動原理

@SpringBootApplication public class Application { public static void main(String[] args) { SpringApplication.run(Application.class, args);

springboot啟動原理及原始碼賞析

springboot啟動原理剖析 2019年8月1日 15:42 我們開發任何一個Spring Boot專案

SpringBoot啟動原理

背景 1> 大家都知道SpringBoot是通過main函式啟動的，這裡面跟蹤程式碼到處都沒有找到while(true)，為什麼啟動後可以一直跑？ 2> SpringBoot預設使用tomcat作為web容器。大家也可以通過在pom檔案中exclusion掉tomcat，denpendency j

知識儲備：SpringBoot啟動執行流程原理解析

SpringBoot專案通過SpringApplication.run()執行，分為兩步首先new了一個SpringApplication，之後再呼叫run()方法，下面我們就看看這兩步 1.建立SpringApplication 通過debug進入到Sprin

SpringBoot學習筆記一之【Idea下建立springboot示例、啟動原理分析與兩種部署啟動方式】

1、使用背景首先說下我們為什麼使用springboot，原因有以下幾點 1、快速建立獨立執行的spring專案以及與主流框架繼承 2、使用嵌入式的Servlet容器，無需打成war包 3、starters自動依賴於版本控制 4、大量的自動配置，簡化開發，也可修改預設值 5、

SpringBoot啟動流程分析（五）：SpringBoot自動裝配原理實現

SpringBoot系列文章簡介 SpringBoot原始碼閱讀輔助篇：　　Spring IoC容器與應用上下文的設計與實現 SpringBoot啟動流程原始碼分析： SpringBoot啟動流程分析（一）：SpringApplication類初始化過程 SpringBoot啟動流程分析（二）

SpringBoot啟動流程分析原理（一）

>我們都知道`SpringBoot`自問世以來，一直有一個響亮的口號"約定優於配置"，其實一種按約定程式設計的軟體設計正規化，目的在於減少軟體開發人員在工作中的各種繁瑣的配置，我們都知道傳統的SSM框架的組合，會伴隨著大量的繁瑣的配置；稍有不慎，就可能各種bug，被人發現還以為我們技術很菜。而`SpringB

SpringBoot啟動流程原理解析（二）

>在上一章我們分析了SpingBoot啟動流程中例項化SpingApplication的過程。 `return new SpringApplication(primarySources).run(args);` 這篇文章咱麼說下`run()`方法開始之後都做了那些事情。繼續往下跟著原始碼進入到`run()

springboot之啟動原理解析

tor 支持告訴定制 root init listen 執行流程 config 本文轉載自：https://www.cnblogs.com/shamo89/p/8184960.html 前言 SpringBoot為我們做的自動配置，確實方便快捷，但是對於新手來說，如

Struts2工作原理與Struts2工作流程

Struts2官方工作原理圖 Struts2的工作原理： 1.客戶端初始化一個紙箱Servlet容器（比如Tomcat）的請求。 2.HttpServletRequest請求經過一系列的Filter（過濾器）。（這些過濾器中有個ActionContextCleanU

Webpack原理與實踐（一）：打包流程

寫在前面的話在閱讀 webpack4.x 原始碼的過程中，參考了《深入淺出webpack》一書和眾多大神的文章，結合自己的一點體會，總結如下。總述 webpack 就像一條生產線，要經過一系列處理流程後才能將原始檔轉換成輸出結果。這條生產線上的每個處理流程的職責都是單一的，多個流程之間有存在依賴關

32 SpringBoot啟動原理與流程

1 啟動原理

1.1 入口(Springboot27Application.java)

1.2 開始啟動(SpringBootApplication.java)

1.2.1 建立SpringApplication物件

1.2.1.1 獲取應用型別

1.2.1.2 配置的所有ApplicationContextInitializer

1.2.1.3 配置的所有ApplicationListener

1.2.1.4 配置的所有ApplicationListener

1.2.2 執行run方法

1.2.2.1 獲取SpringApplicationRunListeners

1.2.2.2 準備環境

1.2.2.3 準備上下文環境

相關推薦