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

电话面试中，面试官问了一个问题：你知道 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:\Users\Administrator\Desktop\demo\demo\target\jarlauncher-0.0.1-SNAPSHOT.jar!/

它对应的 JarFile 为：

C:\Users\Administrator\Desktop\demo\demo\target\jarlauncher-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 …

public abstract class ExecutableArchiveLauncher extends Launcher {
    private final Archive archive;
    // 构造器会初始化代表 fat jar 的 Archive
    public ExecutableArchiveLauncher() {this.archive = createArchive();
    }
    // 由父类 Launcher 实现
    protected final 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) {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);
        }
        // 最终会 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
                public boolean matches(Entry entry) {return isNestedArchive(entry);
                }
            }));
        // 空实现，没用
        postProcessClassPathArchives(archives);
        return archives;
    }

}

JarLauncher 的 launch 方法：

protected void launch(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) {
        throw new IllegalStateException("No'Start-Class'manifest entry specified in" + this);
    }
    return mainClass;
}

// launch 重载方法
protected void launch(String[] args, String mainClass, ClassLoader classLoader)
    throws Exception {
    // 设置 LaunchedURLClassLoader 为线程上下文加载器
    Thread.currentThread().setContextClassLoader(classLoader);
    // 创建一个 MainMethodRunner 并运行
    createMainMethodRunner(mainClass, args, classLoader).run();}

MainMethodRunner 的 run 方法：

public void run() 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) {
                throw new AssertionError("Package" + name + "has already been"
                        + "defined but it could not be found");
            }
        }
        // 调用 父类 loadClass 走正常的加载委派流程
        return super.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) {throw new ClassNotFoundException(name, e);
                        }
                    } else {throw new ClassNotFoundException(name);
                    }
                }
            }, acc);
    } catch (java.security.PrivilegedActionException pae) {throw (ClassNotFoundException) pae.getException();}
    if (result == null) {throw new 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，然后加载个类试试好不好使？

public class LaunchedURLClassLoaderTest {public static void main(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 包启动原理

完结，撒花。

你学会了吗？