共计 7255 个字符，预计需要花费 19 分钟才能阅读完成。
很多初学者会比拟困惑，Spring Boot 是如何做到将利用代码和所有的依赖打包成一个独立的 Jar 包，因为传统的 Java 我的项目打包成 Jar 包之后，须要通过 -classpath 属性来指定依赖，才可能运行。咱们明天就来剖析解说一下 SpringBoot 的启动原理。
Spring Boot 打包插件
Spring Boot 提供了一个名叫 spring-boot-maven-plugin 的 maven 我的项目打包插件，如下：
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>能够不便的将 Spring Boot 我的项目打成 jar 包。这样咱们就不再须要部署 Tomcat、Jetty 等之类的 Web 服务器容器啦。
咱们先看一下 Spring Boot 打包后的构造是什么样的，关上 target 目录咱们发现有两个 jar 包：
其中，springboot-0.0.1-SNAPSHOT.jar 是通过 Spring Boot 提供的打包插件采纳新的格局打成 Fat Jar，蕴含了所有的依赖；
而 springboot-0.0.1-SNAPSHOT.jar.original 则是 Java 原生的打包形式生成的，仅仅只蕴含了我的项目自身的内容。
SpringBoot FatJar 的组织构造
咱们将 Spring Boot 打的可执行 Jar 开展后的构造如下所示：
- BOOT-INF 目录：蕴含了咱们的我的项目代码（classes 目录），以及所须要的依赖（lib 目录）；
- META-INF 目录：通过
MANIFEST.MF文件提供 Jar 包的元数据，申明了 jar 的启动类； org.springframework.boot.loader：Spring Boot 的加载器代码，实现的 Jar in Jar 加载的魔法源。
咱们看到，如果去掉 BOOT-INF 目录，这将是一个十分一般且规范的 Jar 包，包含元信息以及可执行的代码局部，其 /META-INF/MAINFEST.MF 指定了 Jar 包的启动元信息，org.springframework.boot.loader 执行对应的逻辑操作。
MAINFEST.MF 元信息
元信息内容如下所示：
Manifest-Version: 1.0
Spring-Boot-Classpath-Index: BOOT-INF/classpath.idx
Implementation-Title: springboot
Implementation-Version: 0.0.1-SNAPSHOT
Spring-Boot-Layers-Index: BOOT-INF/layers.idx
Start-Class: com.listenvision.SpringbootApplication
Spring-Boot-Classes: BOOT-INF/classes/
Spring-Boot-Lib: BOOT-INF/lib/
Build-Jdk-Spec: 1.8
Spring-Boot-Version: 2.5.6
Created-By: Maven Jar Plugin 3.2.0
Main-Class: org.springframework.boot.loader.JarLauncher它相当于一个 Properties 配置文件，每一行都是一个配置我的项目。重点来看看两个配置项：
- Main-Class 配置项：Java 规定的 jar 包的启动类，这里设置为 spring-boot-loader 我的项目的 JarLauncher 类，进行 Spring Boot 利用的启动。
- Start-Class 配置项：Spring Boot 规定的主启动类，这里设置为咱们定义的 Application 类。
- Spring-Boot-Classes 配置项：指定加载利用类的入口。
- Spring-Boot-Lib 配置项: 指定加载利用依赖的库。
启动原理
Spring Boot 的启动原理如下图所示：
源码剖析
JarLauncher
JarLauncher 类是针对 Spring Boot jar 包的启动类，残缺的类图如下所示：
其中的 WarLauncher 类，是针对 Spring Boot war 包的启动类。启动类 org.springframework.boot.loader.JarLauncher 并非为我的项目中引入类，而是 spring-boot-maven-plugin 插件 repackage 追加进去的。
接下来咱们先来看一下 JarLauncher 的源码，比较简单，如下图所示：
public class JarLauncher extends ExecutableArchiveLauncher {
private static final String DEFAULT_CLASSPATH_INDEX_LOCATION = "BOOT-INF/classpath.idx";
static final EntryFilter NESTED_ARCHIVE_ENTRY_FILTER = (entry) -> {if (entry.isDirectory()) {return entry.getName().equals("BOOT-INF/classes/");
}
return entry.getName().startsWith("BOOT-INF/lib/");
};
public JarLauncher() {}
protected JarLauncher(Archive archive) {super(archive);
}
@Override
protected ClassPathIndexFile getClassPathIndex(Archive archive) throws IOException {
// Only needed for exploded archives, regular ones already have a defined order
if (archive instanceof ExplodedArchive) {String location = getClassPathIndexFileLocation(archive);
return ClassPathIndexFile.loadIfPossible(archive.getUrl(), location);
}
return super.getClassPathIndex(archive);
}
private String getClassPathIndexFileLocation(Archive archive) throws IOException {Manifest manifest = archive.getManifest();
Attributes attributes = (manifest != null) ? manifest.getMainAttributes() : null;
String location = (attributes != null) ? attributes.getValue(BOOT_CLASSPATH_INDEX_ATTRIBUTE) : null;
return (location != null) ? location : DEFAULT_CLASSPATH_INDEX_LOCATION;
}
@Override
protected boolean isPostProcessingClassPathArchives() {return false;}
@Override
protected boolean isSearchCandidate(Archive.Entry entry) {return entry.getName().startsWith("BOOT-INF/");
}
@Override
protected boolean isNestedArchive(Archive.Entry entry) {return NESTED_ARCHIVE_ENTRY_FILTER.matches(entry);
}
public static void main(String[] args) throws Exception {
// 调用基类 Launcher 定义的 launch 办法
new JarLauncher().launch(args);
}
}次要看它的 main 办法，调用的是基类 Launcher 定义的 launch 办法，而 Launcher 是 ExecutableArchiveLauncher 的父类。上面咱们来看看Launcher 基类源码：
Launcher
public abstract class Launcher {
private static final String JAR_MODE_LAUNCHER = "org.springframework.boot.loader.jarmode.JarModeLauncher";
protected void launch(String[] args) throws Exception {if (!isExploded()) {JarFile.registerUrlProtocolHandler();
}
ClassLoader classLoader = createClassLoader(getClassPathArchivesIterator());
String jarMode = System.getProperty("jarmode");
String launchClass = (jarMode != null && !jarMode.isEmpty()) ? JAR_MODE_LAUNCHER : getMainClass();
launch(args, launchClass, classLoader);
}
@Deprecated
protected ClassLoader createClassLoader(List<Archive> archives) throws Exception {return createClassLoader(archives.iterator());
}
protected ClassLoader createClassLoader(Iterator<Archive> archives) throws Exception {List<URL> urls = new ArrayList<>(50);
while (archives.hasNext()) {urls.add(archives.next().getUrl());
}
return createClassLoader(urls.toArray(new URL[0]));
}
protected ClassLoader createClassLoader(URL[] urls) throws Exception {return new LaunchedURLClassLoader(isExploded(), getArchive(), urls, getClass().getClassLoader());
}
protected void launch(String[] args, String launchClass, ClassLoader classLoader) throws Exception {Thread.currentThread().setContextClassLoader(classLoader);
createMainMethodRunner(launchClass, args, classLoader).run();}
protected MainMethodRunner createMainMethodRunner(String mainClass, String[] args, ClassLoader classLoader) {return new MainMethodRunner(mainClass, args);
}
protected abstract String getMainClass() throws Exception;
protected Iterator<Archive> getClassPathArchivesIterator() throws Exception {return getClassPathArchives().iterator();}
@Deprecated
protected List<Archive> getClassPathArchives() throws Exception {throw new IllegalStateException("Unexpected call to getClassPathArchives()");
}
protected final Archive createArchive() throws Exception {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");
}
File root = new File(path);
if (!root.exists()) {throw new IllegalStateException("Unable to determine code source archive from" + root);
}
return (root.isDirectory() ? new ExplodedArchive(root) : new JarFileArchive(root));
}
protected boolean isExploded() {return false;}
protected Archive getArchive() {return null;}
}- launch 办法会首先创立类加载器，而后判断是否 jar 是否在
MANIFEST.MF文件中设置了jarmode属性。 - 如果没有设置，launchClass 的值就来自
getMainClass()返回，该办法由PropertiesLauncher子类实现，返回 MANIFEST.MF 中配置的Start-Class属性值。 - 调用
createMainMethodRunner办法，构建一个MainMethodRunner对象并调用其 run 办法。
PropertiesLauncher
@Override
protected String getMainClass() throws Exception {
// 加载 jar 包 target 目录下的 MANIFEST.MF 文件中 Start-Class 配置，找到 springboot 的启动类
String mainClass = getProperty(MAIN, "Start-Class");
if (mainClass == null) {throw new IllegalStateException("No'" + MAIN + "'or'Start-Class'specified");
}
return mainClass;
}MainMethodRunner
指标类 main 办法的执行器，此时的 mainClassName 被赋值为 MANIFEST.MF 中配置的 Start-Class 属性值，也就是 com.listenvision.SpringbootApplication，之后便是通过反射执行 SpringbootApplication 的 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 {Class<?> mainClass = Class.forName(this.mainClassName, false, Thread.currentThread().getContextClassLoader());
Method mainMethod = mainClass.getDeclaredMethod("main", String[].class);
mainMethod.setAccessible(true);
mainMethod.invoke(null, new Object[] {this.args});
}
}总结
- jar 包相似于 zip 压缩文件，只不过相比 zip 文件多了一个
META-INF/MANIFEST.MF文件，该文件在构建 jar 包时主动创立。 - Spring Boot 提供了一个插件 spring-boot-maven-plugin，用于把程序打包成一个可执行的 jar 包。
- 应用 java -jar 启动 Spring Boot 的 jar 包，首先调用的入口类是
JarLauncher，外部调用Launcher的 launch 后构建MainMethodRunner对象，最终通过反射调用 SpringbootApplication 的 main 办法实现启动成果。
正文完
