电话面试中，面试官问了一个问题：你知道 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 种实现，分别是
JarLauncher
WarLauncher
PropertiesLauncher
继承关系如下
Archive：归档文件的基础抽象类。
JarFileArchive 就是 jar 包文件的抽象。
它提供了一些方法比如 getUrl 会返回这个 Archive 对应的 URL。getManifest 方法会获得 Manifest 数据等。
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.jarBOOT-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 内部有三个文件夹：
META-INF 文件夹：程序入口，其中 MANIFEST.MF（资源清单） 用于描述 jar 包的信息
BOOT-INF 目录：放置我们的程序代码和第三方依赖的 jar 包
org 目录：Spring Boot loader 相关的源代码，我们程序启动就靠他了
MANIFEST.MF 文件的内容：
Manifest-Version: 1.0Implementation-Title: demoImplementation-Version: 0.0.1-SNAPSHOTArchiver-Version: Plexus ArchiverBuilt-By: AdministratorImplementation-Vendor-Id: com.exampleSpring-Boot-Version: 1.5.10.RELEASEImplementation-Vendor: Pivotal Software, Inc.Main-Class: org.springframework.boot.loader.JarLauncherStart-Class: com.example.jarlauncher.JarlauncherApplicationSpring-Boot-Classes: BOOT-INF/classes/Spring-Boot-Lib: BOOT-INF/lib/Created-By: Apache Maven 3.5.2Build-Jdk: 1.8.0_162Implementation-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。
我这给个 GitHub 代码模板吧，点击去克隆
注意一点，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包启动原理
完结，撒花。
你学会了吗？
评论 (1 条评论)