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

时间  2020-06-14
标签 了解 springboot java jar 启动 原理 栏目 Spring 繁體版
原文   原文链接

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

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

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

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

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

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

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

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

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

先有个概览

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

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

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

虽然也是这样劝本身，但是仍是看不懂，尴尬了，哈哈哈...

我们就先拿这个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 启动应用。

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

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

JarLauncher启动流程

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

JarLauncher代码段

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

了解一些 Spring Boot 的抽象概念

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

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

目前有3种实现，分别是

  1. JarLauncher
  2. WarLauncher
  3. PropertiesLauncher

继承关系以下

Launcher继承关系

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。

findClass

因此，

我的结论：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 配置

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

image-20200613172706071

二、配置 Jar 路径，而后 Apply

image-20200613172529276

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

image-20200613192631035

References

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

SpringBoot可执行jar包启动原理

完结，撒花。

你学会了吗？

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程