《SpringBoot系列六》：SpringBoot应用jar包启动原理

小灰灰 2023-09-30 11:24 4阅读 0赞

#### 1、maven打包 ####

Spring Boot项目的pom.xml文件中默认使用`spring-boot-maven-plugin`插件进行打包：

<build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

在执行完maven clean package之后，会生成来个jar相关文件：

1.  test-0.0.1-SNAPSHOT.jar
2.  test-0.0.1-SNAPSHOT.jar.original

#### 2、Jar包目录结构 ####

以笔者的`test-0.0.1-SNAPSHOT.jar`为例，来看一下jar的目录结构，其中都包含哪些目录和文件？

![请添加图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA56eD5aS054ix5YGl6Lqr_size_16_color_FFFFFF_t_70_g_se_x_16]

**可以概述为：**

> spring-boot-learn-0.0.1-SNAPSHOT  
> ├── META-INF  
> │ └── MANIFEST.MF  
> ├── BOOT-INF  
> │ ├── classes  
> │ │ └── 应用程序  
> │ └── lib  
> │ └── 第三方依赖jar  
> └── org  
> └── springframework  
> └── boot  
> └── loader  
> └── springboot启动程序

其中主要包括三大目录：META-INF、BOOT-INF、org。

##### 1）**META-INF内容** #####

META-INF记录了相关jar包的基础信息，包括：入口程序。具体内容如下：

> Manifest-Version: 1.0  
> Spring-Boot-Classpath-Index: BOOT-INF/classpath.idx  
> Implementation-Title: tms-start  
> Implementation-Version: 0.0.1-SNAPSHOT  
> Spring-Boot-Layers-Index: BOOT-INF/layers.idx  
> Start-Class: com.saint.StartApplication  
> Spring-Boot-Classes: BOOT-INF/classes/  
> Spring-Boot-Lib: BOOT-INF/lib/  
> Build-Jdk-Spec: 1.8  
> Spring-Boot-Version: 2.4.5  
> Created-By: Maven Jar Plugin 3.2.0  
> Main-Class: org.springframework.boot.loader.JarLauncher

*  **Main-Class**是`org.springframework.boot.loader.JarLauncher`，即jar启动的Main函数；
 *  **Start-Class**是`com.saint.StartApplication`，即我们自己SpringBoot项目的启动类；也是下文提到的**项目的引导类**。

##### 2）**BOOT-INF内容** #####

1.  BOOT-INF/classes目录：存放应用编译后的class文件源码；
2.  BOOT-INF/lib目录：存放应用依赖的所有三方jar包文件；

##### 3）org内容 #####

org目录下存放着所有SpringBoot相关的class文件，比如：JarLauncher、LaunchedURLClassLoader。

![请添加图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA56eD5aS054ix5YGl6Lqr_size_18_color_FFFFFF_t_70_g_se_x_16]

#### 3、可执行Jar（JarLauncher） ####

从jar包内META-INF/MANIFEST.MF文件中的`Main-Class`属性值为`org.springframework.boot.loader.JarLauncher`，可以看出**main函数是JarLauncher**，即：SpringBoot应用中的Main-class属性指向的class为`org.springframework.boot.loader.JarLauncher`。

其实吧，主要是 Java官方文档规定：java -jar命令引导的具体启动类必须配置在MANIFEST.MF资源的Main-class属性中；又根据“JAR文件规范”，MANIFEST.MF资源必须存放在/META-INF/目录下。所以main函数才是`JarLauncher`。

**JarLauncher类继承图如下：**

![请添加图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA56eD5aS054ix5YGl6Lqr_size_11_color_FFFFFF_t_70_g_se_x_16]

从`JarLauncher`的类注释我们看出JarLauncher的作用：

*  加载内部/BOOT-INF/lib下的所有三方依赖jar；
 *  加载内部/BOOT-INF/classes下的所有应用class；

##### 1）JarLauncher的运行步骤？ #####

1.  在解压jar包后的根目录下运行 java org.springframework.boot.loader.JarLauncher。项目引导类（`META-INF/MANIFEST.MF`文件中的`Start-Class`属性）被JarLauncher加载并执行。
2.  如果直接运行`Start-Class`（示例的StartApplication）类，会报错ClassNotFoundException。
3.  Spring Boot依赖的JAR文件均存放在BOOT-INF/lib目录下。`JarLauncher`会将这些JAR文件作为`Start-Class`的类库依赖。
    
    这也是为什么JarLauncher能够引导，而直接运行`Start-Class`却不行。

##### 2）JarLauncher实现原理？ #####

因为org.springframework.boot.loader.JarLauncher类存在于org.springframework.boot:spring-boot-loader中，所以看源码之前需要先引入maven依赖：

<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-loader</artifactId>
    </dependency>

**再看JarLauncher源码：**

public class JarLauncher extends ExecutableArchiveLauncher {
        
    
    	static final String BOOT_INF_CLASSES = "BOOT-INF/classes/";
    
    	static final String BOOT_INF_LIB = "BOOT-INF/lib/";
    
    	public JarLauncher() {
        
    	}
    
    	protected JarLauncher(Archive archive) {
        
    		super(archive);
    	}
    
    	@Override
    	protected boolean isNestedArchive(Archive.Entry entry) {
        
    		if (entry.isDirectory()) {
        
    			return entry.getName().equals(BOOT_INF_CLASSES);
    		}
    		return entry.getName().startsWith(BOOT_INF_LIB);
    	}
    
    	public static void main(String[] args) throws Exception {
        
    		new JarLauncher().launch(args);
    	}
    
    }

`JarLauncher#main()`中新建了`JarLauncher`并调用父类Launcher中的launch()方法启动程序；

*  BOOT\_INF\_CLASSES、BOOT\_INF\_LIB变量对应BOOT-INF/classes和lib路径；
 *  `isNestedArchive(Archinve.Entry entry)`方法用于判断**FAT JAR资源的相对路径**是否为nestedArchive嵌套文档。进而决定这些FAT JAR**是否会被launch**。
    
     *  当方法返回false时，说明FAT JAR被解压至文件目录。

###### 1> Archive的概念 ######

archive即归档文件，这个概念在linux下比较常见；通常就是一个tar/zip格式的压缩包；而jar正是zip格式的。

SpringBoot抽象了Archive的概念，一个Archive可以是jar（JarFileArchive），也可以是文件目录（ExplodedArchive）；这样也就统一了访问资源的逻辑层；

public interface Archive extends Iterable<Archive.Entry>, AutoCloseable {
        
        ....
    }

`Archive`继承自**Archive.Entry**，Archive.Entry有两种实现：

1.  **JarFileArchive.JarFileEntry** \--> 基于java.util.jar.JarEntry实现，表示FAT JAR嵌入资源。
2.  **ExplodedArchive.FileEntry** \--> 基于文件系统实现；
3.  两者的主要差别是`ExplodedArchive`相比于`JarFileArchive`多了一个获取文件的getFile()方法；
    
        public File getFile() {
              
            return this.file;
        }
4.  也就是说一个在jar包环境下寻找资源，一个在文件夹目录下寻找资源；

所以从实现层面证明了**JarLauncher支持JAR和文件系统两种启动方式**。

**当执行java -jar命令时，将调用/META-INF /MANIFEST.MF文件的Main-Class属性的main()方法，实际上调用的是JarLauncher\#launch(args)方法；**

##### 3） Launcher\#launch(args)方法 #####

protected void launch(String[] args) throws Exception {
        
        if (!isExploded()) {
        
            // phase1：注册jar URL处理器
            JarFile.registerUrlProtocolHandler();
        }
        // phase2：创建ClassLoader
        ClassLoader classLoader = createClassLoader(getClassPathArchivesIterator());
        String jarMode = System.getProperty("jarmode");
        String launchClass = (jarMode != null && !jarMode.isEmpty()) ? JAR_MODE_LAUNCHER : getMainClass();
        // phase3：调用实际的引导类launch
        launch(args, launchClass, classLoader);
    }

`launch()`方法分三步：

1.  注册jar URL处理器；
2.  为所有的Archive创建可以加载jar in jar目录的ClassLoader；
3.  调用实际的引导类（Start-Class）；

###### 1> phase1 注册jar URL处理器 ######

private static final String PROTOCOL_HANDLER = "java.protocol.handler.pkgs";
    
    	private static final String HANDLERS_PACKAGE = "org.springframework.boot.loader";
    
    public static void registerUrlProtocolHandler() {
        
        String handlers = System.getProperty(PROTOCOL_HANDLER, "");
        System.setProperty(PROTOCOL_HANDLER, ("".equals(handlers) ? HANDLERS_PACKAGE
                                              : handlers + "|" + HANDLERS_PACKAGE));
        // 重置缓存的UrlHandlers;
        resetCachedUrlHandlers();
    }
    
    private static void resetCachedUrlHandlers() {
        
        try {
        
            // 由URL类实现：通过URL.setURLStreamHandlerFactory()获得URLStreamHandler。
            URL.setURLStreamHandlerFactory(null);
        }
        catch (Error ex) {
        
            // Ignore
        }
    }

`JarFile#resetCachedUrlHandlers()`方法利用**java.net.URLStreamHandler扩展机制**，实现由`URL#getURLStreamHandler(String)`提供。

**URL\#getURLStreamHandler(String protocol)方法：**

*  首先，URL的关联协议（Protocol）对应一种URLStreamHandler实现类。
 *  JDK内建了一些协议的实现，这些实现均存放在`sun.net.www.protocol`包下，并且类名必须为Handler，其类全名模式为`sun.net.www.protocol.${protocol}.Handler`（包名前缀.协议名.Handler），其中`${protocol}表示协议名`。
 *  如果需要扩展，则必须继承URLStreamHandler类，通过配置Java系统属性`java.protocol.handler.pkgs`，追加URLStreamHandler实现类的package，多个package以“|”分割。
 *  所以对于SpringBoot的JarFile，`registerURLProtocolHandler()`方法将`package org.springframework.boot.loader`追加到java系统属性`java.protocol.handler.pkgs`中。
 *  也就是说，org.springframework.boot.loader包下存在协议对应的Handler类，即org.springframework.boot.loader.jar.Handler；并且按照类名模式，其实现协议为JAR。

另外：在`URL#getURLStreamHandler()`方法中，处理器先读取Java系统属性`java.protocol.handler.pkgs`，**无论其是否存在，继续读取**`sun.net.www.protocol`包；所以**JDK内建`URLStreamHandler`实现是兜底的**。

**为什么SpringBoot要选择覆盖URLStreamHandler？**

*  Spring BOOT FAT JAR除包含传统Java Jar资源之外，还包含依赖的JAR文件；即存在jar in jar的情况；
 *  默认情况下，JDK提供的ClassLoader只能识别jar中的class文件以及加载classpath下的其他jar包中的class文件，对于jar in jar的包无法加载；
 *  当SpringBoot FAT JAR被java -jar命令引导时，其内部的JAR文件无法被内嵌实现`sun.net.www.protocol.jar.Handler`当做class Path，故需要定义了一套URLStreamHandler实现类和JarURLConnection实现类，用来加载jar in jar包的class类文件；

###### 2> phase2 创建可以加载jar in jar目录的ClassLoader ######

*  获取所有的Archive，然后针对每个Archive分别创建ClassLoader；

ClassLoader classLoader = createClassLoader(getClassPathArchivesIterator());
    
    /**
     * 获取所有的Archive（包含jar in jar的情况）
     */
    protected Iterator<Archive> getClassPathArchivesIterator() throws Exception {
        
        return getClassPathArchives().iterator();
    }
    
    /**
     * 针对每个Archive分别创建ClassLoader
     */
    protected ClassLoader createClassLoader(List<Archive> archives) throws Exception {
        
        List<URL> urls = new ArrayList<>(archives.size());
        for (Archive archive : archives) {
        
            urls.add(archive.getUrl());
        }
        return createClassLoader(urls.toArray(new URL[0]));
    }

###### 3> phase3 调用实际的引导类（Start-Class） ######

// case1： 通过ExecutableArchiveLauncher#getMainClass()获取MainClass
    String launchClass = (jarMode != null && !jarMode.isEmpty()) ? JAR_MODE_LAUNCHER : getMainClass();
    // 2、运行实际的引导类
    launch(args, launchClass, classLoader);

**对于phase3，大致可以分为两步：**

*  首先通过`ExecutableArchiveLauncher#getMainClass()`获取mainClass（即：`/META-INF/MANIFEST.MF`资源中的`Start-Class`属性）；
 *  利用反射获取`mainClass`类中的main(Stirng\[\])方法并调用；

**<1> 获取mainClass：**  
![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA56eD5aS054ix5YGl6Lqr_size_16_color_FFFFFF_t_70_g_se_x_16 1]

*  `Start-Class`属性来自`/META_INF/MANIFEST.MF`资源中。`Launcher`的子类`JarLauncher`或`WarLauncher`没有实现`getMainClass()`方法。所以无论是Jar还是War，读取的SpringBoot启动类均来自此属性。

**<2> 执行mainClass的main()方法：**

*  获取mainClass之后，`MainMethodRunner#run()`方法利用反射获取mainClass类中的main(Stirng\[\])方法并调用。  
    ![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA56eD5aS054ix5YGl6Lqr_size_17_color_FFFFFF_t_70_g_se_x_16]

运行JarLauncher实际上是在同进程、同线程内调用Start-Class类的main(Stirng\[\])方法，并且在调用前准备好Class Path。

#### 4、WarLauncher ####

WarLauncher是可执行WAR的启动器。

WarLauncher与JarLauncher的差异很小，主要区别在于项目文件和JAR Class Path路径的不同。

*  相比于FAT Jar的目录，**WAR增加了WEB-INF/lib-provided**，并且该目录仅存放`<scope>provided</scope>`的JAR文件。
 *  传统的Servlet应用的Class Path路径仅关注WEB-INF/classes/和WEB-INF/lib/目录，因此**WEB-INF/lib-provided/中的JAR将被Servlet忽略**。
    
     *  **好处：打包后的WAR文件能够在Servlet容器中兼容运行**。

所以JarLauncher和WarLauncher并无本质区别。

#### 5、总结 ####

**Spring Boot应用Jar/War的启动流程：**

1.  Spring Boot应用打包之后，生成一个Fat jar，包含了应用依赖的所有三方jar包和SpringBoot Loader相关的类。
2.  Fat jar的启动Main函数是JarLauncher，它负责创建一个LaunchedURLClassLoader来加载BOOT-INF/classes目录以及`/BOOT-INF/lib`下面的jar，并利用反射获取`mainClass`类中的main(Stirng\[\])方法并调用。即：运行JarLauncher实际上是在同进程、同线程内调用Start-Class类的main(Stirng\[\])方法，并且在调用前准备好Class Path。

**其他点：**

1.  SpringBoot通过扩展JarFile、JarURLConnection及URLStreamHandler，实现了jar in jar中资源的加载。
2.  SpringBoot通过扩展URLClassLoader --> LauncherURLClassLoader，实现了jar in jar中class文件的加载。
3.  WarLauncher相比JarLauncher只是多加载`WEB-INF/lib-provided`目录下的jar文件。

[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA56eD5aS054ix5YGl6Lqr_size_16_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/6d9261bddddf4fd5b345edc6d5984846.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA56eD5aS054ix5YGl6Lqr,size_16,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA56eD5aS054ix5YGl6Lqr_size_18_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/1107e7f2f1fc48369b1f1e882cb19651.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA56eD5aS054ix5YGl6Lqr,size_18,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA56eD5aS054ix5YGl6Lqr_size_11_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/d8618be4fe1f4ef8a5a17b1107f803d4.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA56eD5aS054ix5YGl6Lqr,size_11,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA56eD5aS054ix5YGl6Lqr_size_16_color_FFFFFF_t_70_g_se_x_16 1]: https://img-blog.csdnimg.cn/002a593be9414f29a11296c2596bba5d.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA56eD5aS054ix5YGl6Lqr,size_16,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA56eD5aS054ix5YGl6Lqr_size_17_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/2cf6b75b8ac343c19cbf8119d2140257.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA56eD5aS054ix5YGl6Lqr,size_17,color_FFFFFF,t_70,g_se,x_16