当我们的执行 java -jar xxx.jar 的时候底层到底做了什么？

大家都知道我们常用的 ​​SpringBoot​​​ 项目最终在线上运行的时候都是通过启动 ​​java -jar xxx.jar​​ 命令来运行的。

那你有没有想过一个问题，那就是当我们执行 ​​java -jar​​​ 命令后，到底底层做了什么就启动了我们的 ​​SpringBoot​​ 应用呢？

或者说一个 ​​SpringBoot​​ 的应用到底是如何运行起来的呢？今天阿粉就带大家来看下。

认识 jar

在介绍 ​​java -jar​​​ 运行原理之前我们先看一下 ​​jar​​​ 包里面都包含了哪些内容，我们准备一个 ​​SpringBoot​​​ 项目，通过在 https://start.spring.io/ 上我们可以快速创建一个 ​​SpringBoot​​​ 项目，下载一个对应版本和报名的 ​​zip​​ 包。

下载后的项目我们在 ​​pom​​​ 依赖里面可以看到有如下依赖，这个插件是我们构建可执行 ​​jar​​​ 的前提，所以如果想要打包成一个 ​​jar​​​ 那必须在 ​​pom​​​ 有增加这个插件，从 ​​start.spring.io​​ 上创建的项目默认是会带上这个插件的。

<build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
1.
2.
3.
4.
5.
6.
7.
8.

接下来我们执行 ​​mvn package​​​，执行完过后在项目的 ​​target​​​ 目录里面我们可以看到有如下两个 ​​jar​​​ 包，我们分别把这两个 ​​jar​​​ 解压一下看看里面的内容，​​.original​​​ 后缀的 jar 需要把后面的 ​​.original​​​ 去掉就可以解压了。​​jar​​​ 文件的解压跟我们平常的 ​​zip​​​ 解压是一样的，​​jar​​​ 文件采用的是 ​​zip​​​ 压缩格式存储，所以任何可以解压 ​​zip​​​ 文件的软件都可以解压 ​​jar​​ 文件。

解压过后，我们对比两种解压文件，可以发现，两个文件夹中的内容还是有很大区别的，如下所示，左侧是 ​​demo-jar-0.0.1-SNAPSHOT.jar​​​ 右侧是对应的 ​​original jar​​。

其中有一些相同的文件夹和文件，比如 ​​META-INF​​​，​​application.properties​​​ 等，而且我们可以明显的看到左侧的压缩包中有项目需要依赖的所有库文件，存放于 ​​lib​​ 文件夹中。

所以我们可以大胆的猜测，左侧的压缩包就是 ​​spring-boot-maven-plugin​​ 这个插件帮我们把依赖的库以及相应的文件调整了一下目录结构而生成的，事实其实也是如此。

java -jar 原理

首先我们要知道的是这个 ​​java -jar​​​ 不是什么新的东西，而是 ​​java​​​ 本身就自带的命令，而且​​ java -jar​​​ 命令在执行的时候，命令本身对于这个 ​​jar​​​ 是不是 ​​SpringBoot​​​ 项目是不感知的，只要是符合 ​​Java​​​ 标准规范的​​ jar​​ 都可以通过这个命令启动。

而在 ​​Java​​​ 官方文档显示，当 ​​-jar​​​ 参数存在的时候，​​jar​​​ 文件资源里面必须包含用 ​​Main-Class​​​ 指定的一个启动类，而且同样根据规范这个资源文件 ​​MANIFEST.MF​​​ 必须放在 ​​/META-INF/​​​ 目录下。对比我们上面解压后的文件，可以看到在左侧的资源文件 ​​MANIFEST.MF​​ 文件中有如图所示的一行。


可以看到这里的 ​​Main-Class​​​ 属性配置的是 ​​org.springframework.boot.loader.JarLauncher​​​，而如果小伙伴更仔细一点的话，会发现我们项目的启动类也在这个文件里面，是通过 ​​Start-Class​​​ 字段来表示的，​​Start-Class​​​ 这个属性不是 ​​Java​​ 官方的属性。

由此我们先大胆的猜测一下，当我们在执行​​ java -jar​​​ 的时候，由于我们的 ​​jar​​​ 里面存在 ​​MANIFEST.MF​​​ 文件，并且其中包含了 ​​Main-Class​​​ 属性且配置了 ​​org.springframework.boot.loader.JarLauncher​​​ 类，通过调用 ​​JarLauncher​​​ 类结合 ​​Start-Class​​ 属性引导出我们项目的启动类进行启动。接下来我们就通过源码来验证一下这个猜想。

因为 ​​JarLauncher​​​ 类是在 ​​spring-boot-loader​​​ 模块，所以我们在 ​​pom​​ 文件中增加如下依赖，就可以下载源码进行跟踪了。

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-loader</artifactId>
   <scope>provided</scope>
</dependency>
1.
2.
3.
4.
5.

通过源码我们可以看到 ​​JarLauncher​​ 类的代码如下

package org.springframework.boot.loader;

import org.springframework.boot.loader.archive.Archive;
import org.springframework.boot.loader.archive.Archive.EntryFilter;

public class JarLauncher extends ExecutableArchiveLauncher {

 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 boolean isPostProcessingClassPathArchives(){
  return false;
 }

 @Override
 protected boolean isNestedArchive(Archive.Entry entry){
  return NESTED_ARCHIVE_ENTRY_FILTER.matches(entry);
 }

 @Override
 protected String getArchiveEntryPathPrefix(){
  return "BOOT-INF/";
 }

 public static void main(String[] args) throws Exception {
  new JarLauncher().launch(args);
 }

}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.

其中有两个点我们可以关注一下，第一个是这个类有一个 ​​main​​​ 方法，这也是为什么 ​​java -jar​​​ 命令可以进行引导的原因，毕竟 ​​java​​​ 程序都是通过 ​​main​​​ 方法进行运行的。其次是这里面有两个路径 ​​BOOT-INF/classes/​​​ 和 ​​BOOT-INF/lib/ ​​这两个路径正好是我们的源码路径和第三方依赖路径。

而 ​​JarLauncher​​​ 类里面的 ​​main()​​​ 方法主要是运行 ​​Launcher​​​ 里面的 ​​launch()​​ 方法，这几个类的关系图如下所示

跟着代码我们可以看到最终调用的是这个 ​​run()​​ 方法

而这里的参数 ​​mainClass​​ 和 ​​launchClass​​ 都是通过通过下面的逻辑获取的，都是通过资源文件里面的 ​​Start-Class​​ 来进行获取的，这里正是我们项目的启动类，由此可以看到我们上面的猜想是正确的。

扩展

上面的类图当中我们还可以看到除了有 ​​JarLauncher​​​ 以外还有一个 ​​WarLauncher​​​ 类，确实我们的 ​​SpringBoot​​​ 项目也是可以配置成 ​​war​​​ 进行部署的。我们只需要将打包插件里面的 ​​jar​​​ 更换成 ​​war​​​ 即可。大家可以自行尝试重新打包解压进行分析，这里 ​​war​​​ 包部署方式只研究学习就好了，​​SpringBoot​​​ 应用还是尽量都使用 ​​Jar​​ 的方式进行部署。

总结

通过上面的内容我们知道了当我们在执行 ​​java -jar​​​ 的时候，根据 ​​java​​​ 官方规范会引导 ​​jar​​​ 包里面 ​​MANIFEST.MF​​​ 文件中的 ​​Main-Class​​​ 属性对应的启动类，该启动类中必须包含 ​​main()​​ 方法。

而对于我们 ​​SpringBoot​​​ 项目构建的 ​​ja​​​r 包，除了 ​​Main-Class​​​ 属性外还会有一个 ​​Start-Class​​​ 属性绑定的是我们项目的启动类，当我们在执行 ​​java -jar​​​ 的时候优先引导的是 ​​org.springframework.boot.loader.JarLauncher#main​​​ 方法，该方法内部会通过引导 ​​Start-Class​​ 属性来启动我们的应用代码。

通过上面的分析相比大家对于 ​​SpringBoot​​​ 是如何通过 ​​java -jar​​ 进行启动了有了一个详细的了解，下次再有人问 ​​​SpringBoot​​ 项目是如何启动的，请把这篇文章转发给他。

文章转载自公众号：Java极客技术