精盡Spring Boot源碼分析 - Jar 包的啟動實現

精盡Spring Boot源碼分析 – Jar 包的啟動實現

該系列文章是筆者在學習 Spring Boot 過程中總結下來的，裏面涉及到相關源碼，可能對讀者不太友好，請結合我的源碼注釋 Spring Boot 源碼分析 GitHub 地址進行閱讀

Spring Boot 版本：2.2.x

最好對 Spring 源碼有一定的了解，可以先查看我的 《死磕 Spring 之 IoC 篇 – 文章導讀》 系列文章

如果該篇內容對您有幫助，麻煩點擊一下「推薦」，也可以關注博主，感激不盡~

概述

Spring Boot 提供了 Maven 插件 spring-boot-maven-plugin，可以很方便的將我們的 Spring Boot 項目打成 jar 包或者 war 包。

考慮到部署的便利性，我們絕大多數（99.99%）的場景下，都會選擇打成 jar 包，這樣一來，我們就無需將項目部署於 Tomcat、Jetty 等 Servlet 容器中。

那麼，通過 Spring Boot 插件生成的 jar 包是如何運行，並啟動 Spring Boot 應用的呢？這個就是本文的目的，我們一起來弄懂 Spring Boot jar 包的運行原理。

這裡，我通過 Spring Boot Maven Plugin 生成了一個 jar 包，其裏面的結構如下所示：

BOOT-INF 目錄，裏面保存了我們自己 Spring Boot 項目編譯後的所有文件，其中 classes 目錄下面就是編譯後的 .class 文件，包括項目中的配置文件等，lib 目錄下就是我們引入的第三方依賴
META-INF 目錄，通過 MANIFEST.MF 文件提供 jar 包的元數據，聲明 jar 的啟動類等信息。每個 Java jar 包應該是都有這個文件的，參考 Oracle 官方對於 jar 的說明，裏面有一個 Main-Class 配置用於指定啟動類
org.springframework.boot.loader 目錄，也就是 Spring Boot 的 spring-boot-loader 工具模塊，它就是 java -jar xxx.jar 啟動 Spring Boot 項目的秘密所在，上面的 Main-Class 指定的就是該工具模塊中的一個類

MANIFEST.MF

META-INF/MANIFEST.MF 文件如下：

Manifest-Version: 1.0
Implementation-Title: spring-boot-study
Implementation-Version: 1.0.0-SNAPSHOT
Built-By: jingping
Implementation-Vendor-Id: org.springframework.boot.demo
Spring-Boot-Version: 2.0.3.RELEASE
Main-Class: org.springframework.boot.loader.JarLauncher # spring-boot-loader 中的啟動類
Start-Class: org.springframework.boot.demo.Application # 你的 Spring Boot 項目中的啟動類
Spring-Boot-Classes: BOOT-INF/classes/ # 你的 Spring Boot 項目編譯後的 .class 文件所在目錄
Spring-Boot-Lib: BOOT-INF/lib/ # 你的 Spring Boot 項目所引入的第三方依賴所在目錄
Created-By: Apache Maven 3.6.3
Build-Jdk: 1.8.0_251
Implementation-URL: //projects.spring.io/spring-boot/#/spring-boot-starter-parent/info-dependencies/dwzq-info/info-stock-project/sp-provider

參考 Oracle 官方對該的說明：

Main-Class：Java 規定的 jar 包的啟動類，這裡設置為 spring-boot-loader 項目的 JarLauncher 類，進行 Spring Boot 應用的啟動
Start-Class：Spring Boot 規定的主啟動類，這裡通過 Spring Boot Maven Plugin 插件打包時，會設置為我們定義的 Application 啟動類

為什麼不直接將我們的 Application 啟動類設置為 Main-Class 啟動呢？

因為通過 Spring Boot Maven Plugin 插件打包後的 jar 包，我們的 .class 文件在 BOOT-INF/classes/ 目錄下，在 Java 默認的 jar 包加載規則下找不到我們的 Application 啟動類，也就需要通過 JarLauncher 啟動加載。

當然，還有一個原因，Java 規定可執行器的 jar 包禁止嵌套其它 jar 包，在 BOOT-INF/lib 目錄下有我們 Spring Boot 應用依賴的所有第三方 jar 包，因此spring-boot-loader 項目自定義實現了 ClassLoader 實現類 LaunchedURLClassLoader，支持加載 BOOT-INF/classes 目錄下的 .class 文件，以及 BOOT-INF/lib 目錄下的 jar 包。

接下來，我們一起來看看 Spring Boot 的 JarLauncher 這個類

1. JarLauncher

類圖：

上面的 WarLauncher 是針對 war 包的啟動類，和 JarLauncher 差不多，感興趣的可以看一看，這裡我們直接來看到 JarLauncher 這個類

public class JarLauncher extends ExecutableArchiveLauncher {

	static final String BOOT_INF_CLASSES = "BOOT-INF/classes/";

	static final String BOOT_INF_LIB = "BOOT-INF/lib/";

	public JarLauncher() {
	}

	protected JarLauncher(Archive archive) {
		super(archive);
	}

	@Override
	protected boolean isNestedArchive(Archive.Entry entry) {
		// 只接受 `BOOT-INF/classes/` 目錄
		if (entry.isDirectory()) {
			return entry.getName().equals(BOOT_INF_CLASSES);
		}
		// 只接受 `BOOT-INF/lib/` 目錄下的 jar 包
		return entry.getName().startsWith(BOOT_INF_LIB);
	}

	/**
	 * 這裡是 java -jar 啟動 SpringBoot 打包後的 jar 包的入口
	 * 可查看 jar 包中的 META-INF/MANIFEST.MF 文件（該文件用於對 Java 應用進行配置）
	 * 參考 Oracle 官方對於 jar 的說明（//docs.oracle.com/javase/8/docs/technotes/guides/jar/jar.html）
	 * 該文件其中會有一個配置項：Main-Class: org.springframework.boot.loader.JarLauncher
	 * 這個配置表示會調用 JarLauncher#main(String[]) 方法，也就當前方法
	 */
	public static void main(String[] args) throws Exception {
		// <1> 創建當前類的實例對象，會創建一個 Archive 對象（當前應用），可用於解析 jar 包（當前應用）中所有的信息
		// <2> 調用其 launch(String[]) 方法
		new JarLauncher().launch(args);
	}
}

可以看到它有個 main(String[]) 方法，前面說到的 META-INF/MANIFEST.MF 文件中的 Main-Class 配置就是指向了這個類，也就會調用這裡的 main 方法，會做下面兩件事：

創建一個 JarLauncher 實例對象，在 ExecutableArchiveLauncher 父類中會做以下事情：

public abstract class ExecutableArchiveLauncher extends Launcher {

	private final Archive archive;

	public ExecutableArchiveLauncher() {
		try {
			// 為當前應用創建一個 Archive 對象，可用於解析 jar 包（當前應用）中所有的信息
			this.archive = createArchive();
		}
		catch (Exception ex) {
			throw new IllegalStateException(ex);
		}
	}
	
	protected final Archive createArchive() throws Exception {
		// 獲取 jar 包（當前應用）所在的絕對路徑
		ProtectionDomain protectionDomain = getClass().getProtectionDomain();
		CodeSource codeSource = protectionDomain.getCodeSource();
		URI location = (codeSource != null) ? codeSource.getLocation().toURI() : null;
		String path = (location != null) ? location.getSchemeSpecificPart() : null;
		if (path == null) {
			throw new IllegalStateException("Unable to determine code source archive");
		}
		// 當前 jar 包
		File root = new File(path);
		if (!root.exists()) {
			throw new IllegalStateException("Unable to determine code source archive from " + root);
		}
		// 為當前 jar 包創建一個 JarFileArchive（根條目），需要通過它解析出 jar 包中的所有信息
		// 如果是文件夾的話則創建 ExplodedArchive（根條目）
		return (root.isDirectory() ? new ExplodedArchive(root) : new JarFileArchive(root));
	}
}

會為當前應用創建一個 Archive 對象，可用於解析 jar 包（當前應用）中所有的信息，可以把它理解為一個「根」對象，可以通過它獲取我們所需要的類信息

調用 JarLauncher#launch(String[]) 方法，也就是調用父類 Launcher 的這個方法

2. Launcher

org.springframework.boot.loader.Launcher，Spring Boot 應用的啟動器

2. launch 方法

public abstract class Launcher {

	/**
	 * Launch the application. This method is the initial entry point that should be
	 * called by a subclass {@code public static void main(String[] args)} method.
	 * @param args the incoming arguments
	 * @throws Exception if the application fails to launch
	 */
	protected void launch(String[] args) throws Exception {
		// <1> 註冊 URL（jar）協議的處理器
		JarFile.registerUrlProtocolHandler();
		// <2> 先從 `archive`（當前 jar 包應用）解析出所有的 JarFileArchive
		// <3> 創建 Spring Boot 自定義的 ClassLoader 類加載器，可加載當前 jar 中所有的類
		ClassLoader classLoader = createClassLoader(getClassPathArchives());
		// <4> 獲取當前應用的啟動類（你自己寫的那個 main 方法）
		// <5> 執行你的那個 main 方法
		launch(args, getMainClass(), classLoader);
	}
}

會做以下幾件事：

調用 JarFile#registerUrlProtocolHandler() 方法，註冊 URL（jar）協議的處理器，主要是使用自定義的 URLStreamHandler 處理器處理 jar 包
調用 getClassPathArchives() 方法，先從 archive（當前 jar 包應用）解析出所有的 JarFileArchive，這個 archive 就是在上面創建 JarLauncher 實例對象過程中創建的
調用 createClassLoader(List<Archive>) 方法，創建 Spring Boot 自定義的 ClassLoader 類加載器，可加載當前 jar 包中所有的類，包括依賴的第三方包
調用 getMainClass() 方法，獲取當前應用的啟動類（你自己寫的那個 main 方法所在的 Class 類對象）
調用 launch(...) 方法，執行你的項目中那個啟動類的 main 方法（反射）

你可以理解為會創建一個自定義的 ClassLoader 類加載器，主要可加載 BOOT-INF/classes 目錄下的類，以及 BOOT-INF/lib 目錄下的 jar 包中的類，然後調用你 Spring Boot 應用的啟動類的 main 方法

接下來我們逐步分析上面的每個步驟

2.1 registerUrlProtocolHandler 方法

備註：註冊 URL（jar）協議的處理器

這個方法在 org.springframework.boot.loader.jar.JarFile 中，這個類是 java.util.jar.JarFile 的子類，對它進行擴展，提供更多的功能，便於操作 jar 包

public static void registerUrlProtocolHandler() {
    // <1> 獲取系統變量中的 `java.protocol.handler.pkgs` 配置的 URLStreamHandler 路徑
    String handlers = System.getProperty(PROTOCOL_HANDLER, "");
    // <2> 將 Spring Boot 自定義的 URL 協議處理器路徑（`org.springframework.boot.loader`）添加至系統變量中
    // JVM 啟動時會獲取 `java.protocol.handler.pkgs` 屬性，多個用 `|` 分隔，以他們作為包名前綴，然後使用 `包名前綴.協議名.Handler` 作為該協議的實現
    // 那麼這裡就會將 `org.springframework.boot.loader.jar.Handler` 作為 jar 包協議的實現
    System.setProperty(PROTOCOL_HANDLER,
            ("".equals(handlers) ? HANDLERS_PACKAGE : handlers + "|" + HANDLERS_PACKAGE));
    // <3> 重置已緩存的 URLStreamHandler 處理器們，避免重複創建
    resetCachedUrlHandlers();
}

方法的處理過程如下：

獲取系統變量中的 java.protocol.handler.pkgs 配置的 URLStreamHandler 路徑
將 Spring Boot 自定義的 URL 協議處理器路徑（org.springframework.boot.loader）添加至系統變量中

JVM 啟動時會獲取 java.protocol.handler.pkgs 屬性，多個用 | 分隔，以他們作為包名前綴，然後使用 包名前綴.協議名.Handler 作為該協議的實現

那麼這裡就會將 org.springframework.boot.loader.jar.Handler 作為 jar 包協議的實現，用於處理 jar 包

重置已緩存的 URLStreamHandler 處理器們，避免重複創建

private static void resetCachedUrlHandlers() {    try {        URL.setURLStreamHandlerFactory(null);    } catch (Error ex) {        // Ignore    }}

2.2 getClassPathArchives 方法

備註：從 archive（當前 jar 包應用）解析出所有的 JarFileArchive

該方法在 org.springframework.boot.loader.ExecutableArchiveLauncher 子類中實現，如下：

@Overrideprotected List<Archive> getClassPathArchives() throws Exception {    // <1> 創建一個 Archive.EntryFilter 類，用於判斷 Archive.Entry 是否匹配，過濾 jar 包（當前應用）以外的東西    // <2> 從 `archive`（當前 jar 包）解析出所有 Archive 條目信息    List<Archive> archives = new ArrayList<>(this.archive.getNestedArchives(this::isNestedArchive));    postProcessClassPathArchives(archives);    // <3> 返回找到的所有 JarFileArchive    // `BOOT-INF/classes/` 目錄對應一個 JarFileArchive（因為就是當前應用中的內容）    // `BOOT-INF/lib/` 目錄下的每個 jar 包對應一個 JarFileArchive    return archives;}

過程如下：

創建一個 Archive.EntryFilter 實現類，用於判斷 Archive.Entry 是否匹配，過濾掉 jar 包（當前應用）以外的東西

public class JarLauncher extends ExecutableArchiveLauncher {	static final String BOOT_INF_CLASSES = "BOOT-INF/classes/";	static final String BOOT_INF_LIB = "BOOT-INF/lib/";	@Override	protected boolean isNestedArchive(Archive.Entry entry) {		// 只接受 `BOOT-INF/classes/` 目錄		if (entry.isDirectory()) {			return entry.getName().equals(BOOT_INF_CLASSES);		}		// 只接受 `BOOT-INF/lib/` 目錄下的 jar 包		return entry.getName().startsWith(BOOT_INF_LIB);	}}

從 archive（當前 jar 包）解析出所有 Archive 條目信息，這個 archive 在上面 1. JarLauncher 講到過，創建 JarLauncher 實例化對象的時候會初始化 archive，是一個 JarFileArchive 對象，也就是我們打包後的 jar 包，那麼接下來需要從中解析出所有的 Archive 對象

// JarFileArchive.java@Overridepublic List<Archive> getNestedArchives(EntryFilter filter) throws IOException {    List<Archive> nestedArchives = new ArrayList<>();    // 遍歷 jar 包（當前應用）中所有的 Entry    for (Entry entry : this) {        // 進行過濾，`BOOT-INF/classes/` 目錄或者 `BOOT-INF/lib/` 目錄下的 jar 包        if (filter.matches(entry)) {            // 將 Entry 轉換成 JarFileArchive            nestedArchives.add(getNestedArchive(entry));        }    }    // 返回 jar 包（當前應用）找到的所有 JarFileArchive    // `BOOT-INF/classes/` 目錄對應一個 JarFileArchive（因為就是當前應用中的內容）    // `BOOT-INF/lib/` 目錄下的每個 jar 包對應一個 JarFileArchive    return Collections.unmodifiableList(nestedArchives);}

返回 jar 包（當前應用）找到的所有 JarFileArchive：

BOOT-INF/classes/ 目錄對應一個 JarFileArchive（因為就是當前 Spring Boot 應用編譯後的內容）
BOOT-INF/lib/ 目錄下的每個 jar 包對應一個 JarFileArchive

返回從 jar 包中找到的所有 JarFileArchive

這一步驟就是從 jar 包中解析出我們需要的東西來，如上描述，每個 JarFileArchive 會對應一個 JarFile 對象

2.3 createClassLoader 方法

備註：創建 Spring Boot 自定義的 ClassLoader 類加載器，可加載當前 jar 中所有的類

protected ClassLoader createClassLoader(List<Archive> archives) throws Exception {    // <1> 獲取所有 JarFileArchive 對應的 URL    List<URL> urls = new ArrayList<>(archives.size());    for (Archive archive : archives) {        urls.add(archive.getUrl());    }    // <2> 創建 Spring Boot 自定義的 ClassLoader 類加載器，並設置父類加載器為當前線程的類加載器    // 通過它解析這些 URL，也就是加載 `BOOT-INF/classes/` 目錄下的類和 `BOOT-INF/lib/` 目錄下的所有 jar 包    return createClassLoader(urls.toArray(new URL[0]));}protected ClassLoader createClassLoader(URL[] urls) throws Exception {    return new LaunchedURLClassLoader(urls, getClass().getClassLoader());}

該過程如下：

獲取所有 JarFileArchive 對應的 URL
創建 Spring Boot 自定義的 ClassLoader 類加載器，並設置父類加載器為當前線程的類加載器

可以看到 LaunchedURLClassLoader 為自定義類加載器，這樣就能從我們 jar 包中的 BOOT-INF/classes/ 目錄下和 BOOT-INF/lib/ 目錄下的所有三方依賴包中加載出 Class 類對象

2.4 getMainClass 方法

備註：獲取當前應用的啟動類（你自己寫的那個 main 方法）

// ExecutableArchiveLauncher.java@Overrideprotected String getMainClass() throws Exception {    // 獲取 jar 包（當前應用）的 Manifest 對象，也就是 META-INF/MANIFEST.MF 文件中的屬性    Manifest manifest = this.archive.getManifest();    String mainClass = null;    if (manifest != null) {        // 獲取啟動類（當前應用自己的啟動類）        mainClass = manifest.getMainAttributes().getValue("Start-Class");    }    if (mainClass == null) {        throw new IllegalStateException("No 'Start-Class' manifest entry specified in " + this);    }    // 返回當前應用的啟動類    return mainClass;}

過程如下：

獲取 jar 包（當前應用）的 Manifest 對象，也就是 META-INF/MANIFEST.MF 文件中的屬性
獲取啟動類（當前應用自己的啟動類），也就是 Start-Class 配置，並返回

可以看到，這一步就是找到你 Spring Boot 應用的啟動類，前面 ClassLoader 類加載器都準備好了，那麼現在不就可以直接調用這個類的 main 方法來啟動應用了

2.5 launch 方法

備註：執行你的 Spring Boot 應用的啟動類的 main 方法

protected void launch(String[] args, String mainClass, ClassLoader classLoader) throws Exception {    // 設置當前線程的 ClassLoader 為剛創建的類加載器    Thread.currentThread().setContextClassLoader(classLoader);    // 創建一個 MainMethodRunner 對象（main 方法執行器）    // 執行你的 main 方法（反射）    createMainMethodRunner(mainClass, args, classLoader).run();}protected MainMethodRunner createMainMethodRunner(String mainClass, String[] args, ClassLoader classLoader) {    return new MainMethodRunner(mainClass, args);}

整個過程很簡單，先設置當前線程的 ClassLoader 為剛創建的類加載器，然後創建一個 MainMethodRunner 對象（main 方法執行器），執行你的 main 方法（反射），啟動 Spring Boot 應用

public class MainMethodRunner {	private final String mainClassName;	private final String[] args;	public MainMethodRunner(String mainClass, String[] args) {		this.mainClassName = mainClass;		this.args = (args != null) ? args.clone() : null;	}	public void run() throws Exception {		// 根據名稱加載 main 方法所在類的 Class 對象		Class<?> mainClass = Thread.currentThread().getContextClassLoader().loadClass(this.mainClassName);		// 獲取 main 方法		Method mainMethod = mainClass.getDeclaredMethod("main", String[].class);		// 執行這個 main 方法（反射）		mainMethod.invoke(null, new Object[] { this.args });	}}

這裡就是通過反射調用你的 Spring Boot 應用的啟動類的 main 方法

LaunchedURLClassLoader

org.springframework.boot.loader.LaunchedURLClassLoader 是 spring-boot-loader 中自定義的類加載器，實現對 jar 包中 BOOT-INF/classes 目錄下的類和 BOOT-INF/lib 下第三方 jar 包中的類的加載。

public class LaunchedURLClassLoader extends URLClassLoader {	static {		ClassLoader.registerAsParallelCapable();	}	/**	 * Create a new {@link LaunchedURLClassLoader} instance.	 * @param urls the URLs from which to load classes and resources	 * @param parent the parent class loader for delegation	 */	public LaunchedURLClassLoader(URL[] urls, ClassLoader parent) {		super(urls, parent);	}	/**	 * 重寫類加載器中加載 Class 類對象方法	 */	@Override	protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {		Handler.setUseFastConnectionExceptions(true);		try {			try {				// 判斷這個類是否有對應的 Package 包				// 沒有的話會從所有 URL（包括內部引入的所有 jar 包）中找到對應的 Package 包並進行設置				definePackageIfNecessary(name);			}			catch (IllegalArgumentException ex) {				// Tolerate race condition due to being parallel capable				if (getPackage(name) == null) {					// This should never happen as the IllegalArgumentException indicates					// that the package has already been defined and, therefore,					// getPackage(name) should not return null.					throw new AssertionError("Package " + name + " has already been defined but it could not be found");				}			}			// 加載對應的 Class 類對象			return super.loadClass(name, resolve);		}		finally {			Handler.setUseFastConnectionExceptions(false);		}	}	/**	 * Define a package before a {@code findClass} call is made. This is necessary to	 * ensure that the appropriate manifest for nested JARs is associated with the	 * package.	 * @param className the class name being found	 */	private void definePackageIfNecessary(String className) {		int lastDot = className.lastIndexOf('.');		if (lastDot >= 0) {			// 獲取包名			String packageName = className.substring(0, lastDot);			// 沒找到對應的 Package 包則進行解析			if (getPackage(packageName) == null) {				try {					// 遍歷所有的 URL，從所有的 jar 包中找到這個類對應的 Package 包並進行設置					definePackage(className, packageName);				}				catch (IllegalArgumentException ex) {					// Tolerate race condition due to being parallel capable					if (getPackage(packageName) == null) {						// This should never happen as the IllegalArgumentException						// indicates that the package has already been defined and,						// therefore, getPackage(name) should not have returned null.						throw new AssertionError(								"Package " + packageName + " has already been defined but it could not be found");					}				}			}		}	}	private void definePackage(String className, String packageName) {		try {			AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {				// 把類路徑解析成類名並加上 .class 後綴				String packageEntryName = packageName.replace('.', '/') + "/";				String classEntryName = className.replace('.', '/') + ".class";				// 遍歷所有的 URL（包括應用內部引入的所有 jar 包）				for (URL url : getURLs()) {					try {						URLConnection connection = url.openConnection();						if (connection instanceof JarURLConnection) {							JarFile jarFile = ((JarURLConnection) connection).getJarFile();							// 如果這個 jar 中存在這個類名，且有對應的 Manifest							if (jarFile.getEntry(classEntryName) != null && jarFile.getEntry(packageEntryName) != null									&& jarFile.getManifest() != null) {								// 定義這個類對應的 Package 包								definePackage(packageName, jarFile.getManifest(), url);								return null;							}						}					}					catch (IOException ex) {						// Ignore					}				}				return null;			}, AccessController.getContext());		}		catch (java.security.PrivilegedActionException ex) {			// Ignore		}	}}

上面的代碼就不一一講述了，LaunchedURLClassLoader 重寫了 ClassLoader 的 loadClass(String, boolean) 加載 Class 類對象方法，在加載對應的 Class 類對象之前新增了一部分邏輯，會嘗試從 jar 包中定義 Package 包對象，這樣就能加載到對應的 Class 類對象。

總結

Spring Boot 提供了 Maven 插件 spring-boot-maven-plugin，可以很方便的將我們的 Spring Boot 項目打成 jar 包，jar 包中主要分為三個模塊：

BOOT-INF 目錄，裏面保存了我們自己 Spring Boot 項目編譯後的所有文件，其中 classes 目錄下面就是編譯後的 .class 文件，包括項目中的配置文件等，lib 目錄下就是我們引入的第三方依賴
META-INF 目錄，通過 MANIFEST.MF 文件提供 jar 包的元數據，聲明 jar 的啟動類等信息。每個 Java jar 包應該是都有這個文件的，參考 Oracle 官方對於 jar 的說明，裏面有一個 Main-Class 配置用於指定啟動類
org.springframework.boot.loader 目錄，也就是 Spring Boot 的 spring-boot-loader 子模塊，它就是 java -jar xxx.jar 啟動 Spring Boot 項目的秘密所在，上面的 Main-Class 指定的就是裏面的一個類

通過 java -jar 啟動應用時，根據 Main-Class 配置會調用 org.springframework.boot.loader.JarLauncher 的main(String[]) 方法；其中會先創建一個自定義的 ClassLoader 類加載器，可從BOOT-INF目錄下加載出我們 Spring Boot 應用的 Class 類對象，包括依賴的第三方 jar 包中的 Class 類對象；然後根據 Start-Class 配置調用我們 Spring Boot 應用啟動類的 main(String[]) 方法（反射），這樣也就啟動了應用，至於我們的 main(String[]) 方法中做了哪些事情，也就是後續所講的內容。

Tags: Spring Boot 源碼解析精盡Spring Boot源碼分析