你了解 SpringBoot java -jar 的启动原理吗？

• Z时代
• 2024-01-10
• 分类：技术分享

电话面试中，面试官问了一个问题：你知道java -jar 启动 Spring Boot 项目，和传统的 jar 有什么不一样的吗？

问题大概是这样，当时不太清楚怎么回答，面试结束之后知道面试估计是挂了，请教了一下面试官这个问题应该从哪方面去考虑呢？

大概记得面试官说，... 自定义类加载器知道吗？ ...（中间一些内容就没听进去了）

我：原来是从这方面去考虑呀，感谢面试官的指点！

事后赶紧学了学，也走读了下启动过程的源码，终于知道他说的自定义类加载器了，也就知道他问这个问题的目的所在了。

凡是你接触过一点点 Spring Boot 项目，你一定知道通过 java -jar xxx.jar 命令便能把一个 Spring Boot 服务启动起来。（如果你还没接触过，这里的内容可以日后再看，先轻微了解一下 Spring Boot 项目的玩法）

一个看似简陋的 java -jar 究竟干了什么，就把咱们手写的应用（咱们的项目可能叫 XXXApplication.java）启动了呢？

这就是本文的目的，解读一下 java -jar都做了什么。

至少面试的时候能搭上话，能说两句，不会像我一样只能哦哦哦的。。。

先有个概览

了解一个技术点，直接扎到源码堆里，云里雾里，很难受，容易让人望而生畏。

这时候可以先从整体或者非源码的角度了解一下它的运作机制，心里有个底，如果再感兴趣，就可以找一些细节，慢慢击破，可能效果更好，更能让人坚持下去。

这也是我后面准备学习源码的思路，就写一下。

虽然也是这样劝自己，可是还是看不懂，尴尬了，哈哈哈...

咱们就先拿这个java -jar xxx.jar来说：

Spring Boot 在可执行 Fat jar 包中定义了自己的一套规则，比如第三方依赖 jar 包在 /lib目录下，jar 包的 URL 路径使用自定义的规则并且这个规则需要使用 org.springframework.boot.loader.jar.Handler处理器处理。

Fat jar 的 Main-Class 使用 org.springframework.boot.loader.JarLauncher，也就是 执行java -jar xxx.jar首先会触发 JarLauncher的main方法的执行，而不是咱们的应用的xxx.xxx.xxx.XXXApplication。

不过不用急，JarLauncher#main 会执行一些逻辑，做一些物料准备，最终会触发咱们的 XXXApplication#main 启动应用。

先看个启动过程概览，日后研究不会慌！

还不会画时序图，不搞个呢又感觉少了些直观的东西，就勉强搞了个，这张图的主要目的是提供启动过程的调用关系。

怕时序图表达不够完善，再把简要代码贴一下，哈哈。。。

提示：后面的东西需要一些耐心。

了解一些 Spring Boot 的抽象概念

了解一下 Spring Boot Loader 所抽象出来的一些概念，对走读 Spring Boot loader 源码有些帮助

Launcher：各种 Launcher 的基础抽象类，用于启动应用程序，跟Archive配合使用。

目前有3种实现，分别是

1. JarLauncher
2. WarLauncher
3. PropertiesLauncher

继承关系如下

Archive：归档文件的基础抽象类。

1. JarFileArchive 就是 jar 包文件的抽象。

   它提供了一些方法比如 getUrl 会返回这个 Archive 对应的 URL。getManifest 方法会获得 Manifest 数据等。

2. ExplodedArchive 是文件目录的抽象。

JarFile：对 jar 包的封装，每个 JarFileArchive 都会对应一个 JarFile。JarFile 被构造的时候会解析内部结构，去获取 jar 包里的各个文件或文件夹，这些文件或文件夹会被封装到 Entry 中，也存储在 JarFileArchive 中。如果 Entry 是个jar，会解析成 JarFileArchive。

JarFile是Springboot-loader 继承 JDK JarFile提供的类。

比如一个 JarFileArchive 对应的URL为：

jar:file:C:UsersAdministratorDesktopdemodemotargetjarlauncher-0.0.1-SNAPSHOT.jar!/

它对应的 JarFile 为：

C:UsersAdministratorDesktopdemodemotargetjarlauncher-0.0.1-SNAPSHOT.jar

这个 JarFile 有很多Entry，比如：

META-INF/
META-INF/MANIFEST.MF
......
BOOT-INF/lib/spring-boot-starter-1.5.10.RELEASE.jar
BOOT-INF/lib/spring-boot-1.5.10.RELEASE.jar
...

JarFileArchive 内部的一些依赖 jar 对应的 URL

（SpringBoot 使用 org.springframework.boot.loader.jar.Handler 处理器来处理这些URL）

jar:file:C:/Users/Administrator/Desktop/demo/demo/target/jarlauncher-0.0.1-SNAPSHOT.jar!/lib/spring-boot-1.5.10.RELEASE.jar!/
jar:file:C:/Users/Administrator/Desktop/demo/demo/target/jarlauncher-0.0.1-SNAPSHOT.jar!/lib/spring-boot-1.5.10.RELEASE.jar!/org/springframework/boot/loader/JarLauncher.class

我们看到如果有 jar 包中包含 jar，或者 jar 包中包含 jar 包里面的 class 文件，那么会使用 !/ 分隔开，这种方式只有 org.springframework.boot.loader.jar.Handler 能处理，它是 SpringBoot 内部扩展出来一种URL协议（其实这个非常重要，对于后面说的自定义加载器，拓展URL协议是基石）。

可执行 jar 目录结构

注意：咱们以 Spring Boot 1.5.10 版本来分析

本来想直接用 Spring Boot 2.3.x 作为 debug 环境的，也看了一圈网文，发现比 2.3.x 比 1.x 版本多了一些概念，比如分层的JarModel，自己又不会，弄过来直接搪塞过去也不太好，就先放弃了，最终使用不算太老的 1.5.10 版本。

SpringBoot 提供了一个插件 spring-boot-maven-plugin 用于把程序打包成一个可执行的jar包。

在 pom 文件里加入这个插件即可：

<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>

然后我们在 Terminal 执行 maven package 打包完生成的 jarlauncher-0.0.1-SNAPSHOT.jar （我们称之为 Fat jar）内部的结构如下：

├─BOOT-INF
│  ├─classes
│  │  └─application.properties
│  │  └─com
│  │      └─example
│  │          └─jarlauncher
│  │              └─JarlauncherApplication.class
│  └─lib
│      ├─spring-boot-1.5.10.RELEASE.jar
│      ├─spring-boot-loader-1.5.10.RELEASE.jar
│      ├─.......
├─META-INF
│  └─MANIFEST.MF
│  └─maven
│      └─com.example
│          └─demo
│              ├─pom.properties
│              ├─pom.xml
└─org
└─springframework
└─boot
└─loader
├─ExecutableArchiveLauncher.class
├─JarLauncher.class
├─LaunchedURLClassLoader.class
├─Launcher.class
├─MainMethodRunner.class
└─......

打包出来 fat jar 内部有三个文件夹：

1. META-INF 文件夹：程序入口，其中 MANIFEST.MF（资源清单） 用于描述 jar 包的信息
2. BOOT-INF 目录：放置我们的程序代码和第三方依赖的jar包
3. org目录：Spring Boot loader 相关的源代码，我们程序启动就靠他了

MANIFEST.MF文件的内容：

Manifest-Version: 1.0
Implementation-Title: demo
Implementation-Version: 0.0.1-SNAPSHOT
Archiver-Version: Plexus Archiver
Built-By: Administrator
Implementation-Vendor-Id: com.example
Spring-Boot-Version: 1.5.10.RELEASE
Implementation-Vendor: Pivotal Software, Inc.
Main-Class: org.springframework.boot.loader.JarLauncher
Start-Class: com.example.jarlauncher.JarlauncherApplication
Spring-Boot-Classes: BOOT-INF/classes/
Spring-Boot-Lib: BOOT-INF/lib/
Created-By: Apache Maven 3.5.2
Build-Jdk: 1.8.0_162
Implementation-URL: http://projects.spring.io/spring-boot/demo/

我们看到，它的 Main-Class 是 org.springframework.boot.loader.JarLauncher，当我们使用 java -jar 执行jar包的时候会调用 JarLauncher 的main方法，而不是调用我们编写的 com.example.jarlauncher.JarlauncherApplication。

接下来咱们走读一下代码，看看实际怎么运行的吧！

JarLauncher的执行过程

提示：走读的时候时不时结合概览中的时序图，可能好些。

JarLauncher 的 main 方法：

public static void main(String[] args) {
// 构造JarLauncher，然后调用它的launch方法
new JarLauncher().launch(args);
}

JarLauncher 被构造的时候会调用父类 ExecutableArchiveLauncher 的构造方法。

ExecutableArchiveLauncher 的构造方法内部会去构造 Archive，这里构造了 JarFileArchive。构造JarFileArchive的过程中还会构造很多东西，比如JarFile，Entry …

publicabstractclassExecutableArchiveLauncherextendsLauncher{
privatefinal Archive archive;
// 构造器会初始化代表 fat jar 的 Archive
publicExecutableArchiveLauncher(){
this.archive = createArchive();
}
// 由父类 Launcher 实现
protectedfinal Archive createArchive()throws Exception {
ProtectionDomain protectionDomain = getClass().getProtectionDomain();
CodeSource codeSource = protectionDomain.getCodeSource();
URI location = (codeSource == null ? null : codeSource.getLocation().toURI());
String path = (location == null ? null : location.getSchemeSpecificPart());
if (path == null) {
thrownew IllegalStateException("Unable to determine code source archive");
}
File root = new File(path);
if (!root.exists()) {
thrownew IllegalStateException(
"Unable to determine code source archive from " + root);
}
// 最终会 new 一个 Arichive，内部生产的 JarFile-->这个逼对FatJar资源加载非常重要
return (root.isDirectory() ? new ExplodedArchive(root)
: new JarFileArchive(root));
}
@Override
protected List<Archive> getClassPathArchives()throws Exception {
List<Archive> archives = new ArrayList<Archive>(
// 获取内部所有有的 Arichive
this.archive.getNestedArchives(new EntryFilter() {
@Override
publicbooleanmatches(Entry entry){
return isNestedArchive(entry);
}
}));
// 空实现，没用
postProcessClassPathArchives(archives);
return archives;
}
}

JarLauncher 的 launch方法：

protectedvoidlaunch(String[] args){
try {
// 在系统属性中设置注册了自定义的URL协议处理器：org.springframework.boot.loader.jar.Handler。
// 初始化URL的时候，如果URL中没有指定处理器，会去系统属性中查询
JarFile.registerUrlProtocolHandler();
// getClassPathArchives方法会去找lib目录下对应的第三方依赖JarFileArchive，同时也会找项目自身的JarFileArchive
// 根据getClassPathArchives得到的JarFileArchive集合去创建类加载器ClassLoader。这里会构造一个LaunchedURLClassLoader类加载器，这个类加载器继承URLClassLoader，并使用这些JarFileArchive集合的URL构造成URLClassPath
// 多说两句句，
// 1.URLClassPath这个属性很重要，自定义ClassLoader，findClass就靠它了！
// 2.可以关注一下构造LaunchedURLClassLoader时，archive.getUrl方法，这里就涉及到自定义URL协议处理器了，JarFile等。毕竟实现jar in jar功能靠他们这些小罗罗。
ClassLoader classLoader = createClassLoader(getClassPathArchives());
// getMainClass方法会去项目自身的Archive中的Manifest中找出key为Start-Class的类
// 调用重载方法launch
launch(args, getMainClass(), classLoader);
}
catch (Exception ex) {
ex.printStackTrace();
System.exit(1);
}
}
// Archive的getMainClass方法，不过由ExecutableArchiveLauncher实现
// 这里会找出Start-Class标识的com.example.jarlauncher.JarlauncherApplication这个类
public String getMainClass()throws Exception {
Manifest manifest = getManifest();
String mainClass = null;
if (manifest != null) {
mainClass = manifest.getMainAttributes().getValue("Start-Class");
}
if (mainClass == null) {
thrownew IllegalStateException(
"No 'Start-Class' manifest entry specified in " + this);
}
return mainClass;
}
// launch重载方法
protectedvoidlaunch(String[] args, String mainClass, ClassLoader classLoader)
throws Exception {
// 设置 LaunchedURLClassLoader 为线程上下文加载器
Thread.currentThread().setContextClassLoader(classLoader);
// 创建一个MainMethodRunner 并运行
createMainMethodRunner(mainClass, args, classLoader).run();
}

MainMethodRunner 的 run 方法：

publicvoidrun()throws Exception {
// 使用线程上下文类加载器加载主类
Class<?> mainClass = Thread.currentThread().getContextClassLoader()
.loadClass(this.mainClassName);
// 反射执行，至此咱们的应用程序就启动起来啦，good，启动流程走读结束，开心！可以跟面试官扯些了
Method mainMethod = mainClass.getDeclaredMethod("main", String[].class);
mainMethod.invoke(null, new Object[] { this.args });
}

Start-Class的main方法调用之后，内部会构造Spring容器，启动内置Servlet容器等过程（后面的就不说了，不是本文关注的点，况且也没细研究呢😂）

好了，到这里咱们已经把 java -jar 的启动过程整体了解了一遍，开心吧！

关于自定义的类加载器

看看传说中的 LaunchedURLClassLoader有什么神奇的

LaunchedURLClassLoader 重写了 loadClass 方法，走读一下

protected Class<?> loadClass(String name, boolean resolve)
throws ClassNotFoundException {
Handler.setUseFastConnectionExceptions(true);
try {
try {
// 在调用 findClass 之前定义 package，确保嵌套JAR清单与包相关联
definePackageIfNecessary(name);
}
catch (IllegalArgumentException ex) {
if (getPackage(name) == null) {
thrownew AssertionError("Package " + name + " has already been "
+ "defined but it could not be found");
}
}
// 调用 父类 loadClass 走正常的加载委派流程
returnsuper.loadClass(name, resolve);
}
finally {
Handler.setUseFastConnectionExceptions(false);
}
}

其实只看上面 1.5.10 版本的 loadClass 实现，毫无亮点，基本就是普通的双亲委派过程。

而且 LaunchedURLClassLoader 使用的 findClass 是从父类 URLClassLoader 继承的。

最终 loadClass 会走到 LaunchedURLClassLoader 的父类 URLClassLoader#findClass

protected Class<?> findClass(final String name)
throws ClassNotFoundException
{
final Class<?> result;
try {
result = AccessController.doPrivileged(
new PrivilegedExceptionAction<Class<?>>() {
public Class<?> run() throws ClassNotFoundException {
// 把类名解析成路径并加上.class后缀                     	
String path = name.replace('.', '/').concat(".class");
// 基于之前得到的第三方jar包依赖以及自己的jar包得到URL数组，进行遍历找出对应类名的资源
// 比如path是org/springframework/boot/loader/JarLauncher.class，它在jar:file:/Users/Format/Develop/gitrepository/springboot-analysis/springboot-executable-jar/target/executable-jar-1.0-SNAPSHOT.jar!/lib/spring-boot-loader-1.3.5.RELEASE.jar!/中被找出
// 那么找出的资源对应的URL为jar:file:/Users/Format/Develop/gitrepository/springboot-analysis/springboot-executable-jar/target/executable-jar-1.0-SNAPSHOT.jar!/lib/spring-boot-loader-1.3.5.RELEASE.jar!/org/springframework/boot/loader/JarLauncher.class                        
// 加载fatjar class的关键部分！！！
Resource res = ucp.getResource(path, false);
if (res != null) { // 找到了资源
try {
return defineClass(name, res);
} catch (IOException e) {
thrownew ClassNotFoundException(name, e);
}
} else {
thrownew ClassNotFoundException(name);
}
}
}, acc);
} catch (java.security.PrivilegedActionException pae) {
throw (ClassNotFoundException) pae.getException();
}
if (result == null) {
thrownew ClassNotFoundException(name);
}
return result;
}

上面的findClass的过程，都是在关键代码 Resource res = ucp.getResource(path, false); 这里完成的。

ucp 也即 JDK 提供的 sun.misc.URLClassPath

又画了个图，可以看到URLClassPath#getResource涉及哪些基础组件支持。

会用到 URL，URLStreamHandler，org.springframework.boot.loader.jar.Handler，最终获取到 Resource，完成 class load。

所以，

个人结论：LaunchedURLClassLoader 是借助他山之力，关键还在于 Spring Boot 对 URL jar 协议的拓展，Archeive，JarFile 的抽象

LaunchedURLClassLoader 加载测试

咱们手动模拟一下 JarLauncher 的加载过程，创建 LaunchedURLClassLoader，然后加载个类试试好不好使？

publicclassLaunchedURLClassLoaderTest{
publicstaticvoidmain(String[] args)throws Exception {
// 注册org.springframework.boot.loader.jar.Handler URL协议处理器
JarFile.registerUrlProtocolHandler();
// 构造LaunchedURLClassLoader类加载器，这里使用了1个URL，对应jar包中依赖包spring-boot-loader       
// 会使用 org.springframework.boot.loader.jar.Handler 处理器处理
LaunchedURLClassLoader classLoader = new LaunchedURLClassLoader(
new URL[]{
new URL("jar:file:C:/Users/Administrator/Desktop/demo/demo/target/jarlauncher-0.0.1-SNAPSHOT.jar!/BOOT-INF/lib/spring-boot-loader-1.5.10.RELEASE.jar!/")
},
DemoApplication.class.getClassLoader());
// 加载类
classLoader.loadClass("org.springframework.boot.loader.JarLauncher");
}
}

把这个 case 跑通之后，JarLauncher 的启动流程就没啥问题了吧？

赠送一个 IDEA Debug Fat Jar 启动的环境

说了这么多启动流程，如何才能直观的 debug 到 Spring Boot Loader 的执行过程呢？

下面咱们就来做这事，很简单，几分钟搞定。

代码准备

直接在 start.spring.io 初始化一个的 SpringBoot 应用就行，版本改成 1.5.10。

我这给个 Git 代码模板吧，点击去克隆

注意一点，maven 要添加 spring-boot-loader 的依赖，一起打到 jar 里去。

<!-- Spring Boot loader		-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-loader</artifactId>
</dependency>

然后 mvn package，把应用打包成可执行 jar。

IDEA 配置

1、配置以 Jar 应用的方式启动

2、配置 Jar 路径，然后 Apply

3、找到启动类 JarLauncher，打上断点，debug 方式启动

References

springboot应用启动原理(二) 扩展URLClassLoader实现嵌套jar加载--推荐阅读研究

SpringBoot可执行jar包启动原理

完结，撒花。

你学会了吗？

以上是 你了解 SpringBoot java -jar 的启动原理吗？ 的全部内容， 来源链接： utcz.com/a/24177.html