Spring Boot 有一个很方便的功能就是可以将应用打成可执行的 Jar。那么大家有没想过这个 Jar 是怎么运行起来的呢？本篇博客就来介绍下 Spring Boot 可执行 Jar 包的运行原理。

打可执行 Jar 包

将 Spring Boot 应用打成可执行 Ja r包很容易，只需要在 pom 中加上一个 Spring Boot 提供的插件，然后在执行mvn package即可。

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

注意： 如果你的项目没有继承spring-boot-starter-parent这个POM，你需要做如下配置，将目标绑定到repackage。

  1. <plugin>
  2.     <groupId>org.springframework.boot</groupId>
  3.     <artifactId>spring-boot-maven-plugin</artifactId>
  4.     <executions>
  5.         <execution>
  6.             <goals>
  7.                 <goal>repackage</goal>
  8.             </goals>
  9.         </execution>
  10.     </executions>
  11. </plugin>

关于这个插件的详细使用，可以参考官网

运行完mvn package后，我们会在 target 目录下看到两个 jar 文件。myproject-0.0.1-SNAPSHOT.jar 和 myproject-0.0.1-SNAPSHOT.jar.original。第一个 jar 文件就是我们应用的可执行 jar 包，第二个 Jar 文件是应用原始的 jar 包。

.jar.original是maven在SpringBoot重新打包之前的原始jar包，内部只包含了项目的用户类，不包含其他的依赖jar包，生成之后，SpringBoot重新打包之后，最后生成.jar包，内部包含了原始jar包以及其他的引用依赖。以下提及的jar包都是SpringBoot二次加工打的包。

可执行 Jar 包内部结构

将打出来的可执行 Jar 解压开我们能看到下面的结构：

  1. Copy可执行 jar 目录结构
  2. ├─BOOT-INF
  3. │  ├─classes
  4. │  └─lib
  5. ├─META-INF
  6. │  ├─maven
  7. │  ├─app.properties
  8. │  ├─MANIFEST.MF      
  9. └─org
  10.     └─springframework
  11.         └─boot
  12.             └─loader
  13.                 ├─archive
  14.                 ├─data
  15.                 ├─jar
  16.                 └─util
  • BOOT-INF：这个文件夹下有两个文件夹classes用来存放用户类，也就是原始jar.original里的类；还有一个是lib，就是这个原始jar.original引用的依赖。
  • META-INF：这里是通过java -jar启动的入口信息，记录了入口类的位置等信息。
  • org: Springboot loader的代码，通过它来启动。

我们先来重点关注两个地方：META-INF 下面的 Jar 包描述文件和 BOOT-INF 这个目录。

  1. Manifest-Version: 1.0
  2. Archiver-Version: Plexus Archiver
  3. Built-By: Adrian
  4. Start-Class: cn.jmfen.sport.activitycenter.ActivityCenterAdminApplication  //以活动系统为例
  5. Spring-Boot-Classes: BOOT-INF/classes/
  6. Spring-Boot-Lib: BOOT-INF/lib/
  7. Spring-Boot-Version: 2.1.1.RELEASE
  8. Created-By: Apache Maven 3.6.3
  9. Build-Jdk: 1.8.0_211
  10. Main-Class: org.springframework.boot.loader.JarLauncher
  • Main-Class：记录了java -jar的启动入口，当使用该命令启动时就会调用这个入口类的main方法，显然可以看出，Springboot转移了启动的入口，不是用户编写的xxx.xxx.BootStrap的那个入口类。
  • Start-Class：记录了用户编写的xxx.xxx.BootStrap的那个入口类，当内嵌的jar包加载完成之后，会使用LaunchedURLClassLoader线程加载类来加载这个用户编写的入口类。

在上面我们看到一个熟悉的配置Main-Class: org.springframework.boot.loader.JarLauncher。我们大概能猜到这个类是整个系统的入口。

再看下 BOOT-INF 这个目录下面，我们会发现里面是我们项目打出来的 class 文件和项目依赖的 Jar 包。看到这里，你可能已经猜到 Spring Boot 是怎么启动项目的了。

JarLauncher

  1. Copypublic class JarLauncher extends ExecutableArchiveLauncher {
  3.     static final String BOOT_INF_CLASSES = "BOOT-INF/classes/";
  5.     static final String BOOT_INF_LIB = "BOOT-INF/lib/";
  7.     public JarLauncher() {
  8.     }
  10.     protected JarLauncher(Archive archive) {
  11.         super(archive);
  12.     }
  14.     @Override
  15.     protected boolean isNestedArchive(Archive.Entry entry) {
  16.         if (entry.isDirectory()) {
  17.             return entry.getName().equals(BOOT_INF_CLASSES);
  18.         }
  19.         return entry.getName().startsWith(BOOT_INF_LIB);
  20.     }
  22.     public static void main(String[] args) throws Exception {
  23.         //项目入口，重点在launch这个方法中
  24.         new JarLauncher().launch(args);
  25.     }
  27. }
  28. Copy//launch方法
  29. protected void launch(String[] args) throws Exception {
  30.     JarFile.registerUrlProtocolHandler();
  31.     //创建LaunchedURLClassLoader。如果根类加载器和扩展类加载器没有加载到某个类的话，就会通过LaunchedURLClassLoader这个加载器来加载类。这个加载器会从Boot-INF下面的class目录和lib目录下加载类。
  32.     ClassLoader classLoader = createClassLoader(getClassPathArchives());
  33.     //这个方法会读取jar描述文件中的Start-Class属性，然后通过反射调用到这个类的main方法。
  34.     launch(args, getMainClass(), classLoader);
  35. }

简单总结

  • Spring Boot 可执行 Jar 包的入口点是 JarLauncher 的 main 方法；
  • 这个方法的执行逻辑是先创建一个 LaunchedURLClassLoader，这个加载器加载类的逻辑是：先判断根类加载器和扩展类加载器能否加载到某个类，如果都加载不到就从 Boot-INF 下面的 class 和 lib 目录下去加载；
  • 读取Start-Class属性，通过反射机制调用启动类的 main 方法，这样就顺利调用到我们开发的 Spring Boot 主启动类的 main 方法了。

远程调试

这边介绍个调试 JarLauncher 启动的小技巧：IDEA 远程调试。

step1：我们以下面的方式启动我们的 Spring Boot 应用

  1. Copy java -Xdebug -Xrunjdwp:transport=dt_socket,address=5005,server=y,suspend=y -jar App.jar

step2：在 idea 中进行如下配置

SpringBoot 可执行jar包原理 - 图1

然后点击下面的执行按钮执行即可：
SpringBoot 可执行jar包原理 - 图2