Maison >Java >javaDidacticiel >Que sont FatJar et Jar dans Springboot

Que sont FatJar et Jar dans Springboot

WBOYavant: 2023-05-11 09:58:131881parcourir

Introduction

Les applications Spring Boot peuvent être rapidement empaquetées à l'aide de spring-boot-maven-plugin , créez un spring-boot-maven-plugin快速打包，构建一个可执行jar。Spring Boot内嵌容器，通过java -jar命令便可以直接启动应用。

虽然是一个简单的启动命令，背后却藏着很多知识。今天带着大家探索FAT JAR启动的背后原理。本文主要包含以下几个部分：

JAR 是什么。首先需要了解jar是什么，才知道java -jar做了什么事情。
FatJar 有什么不同。 Spring Boot提供的可执行jar与普通的jar有什么区别。
启动时的类加载原理。启动过程中类加载器做了什么？Spring Boot又如何通过自定义类加载器解决内嵌包的加载问题。
启动的整个流程。最后整合前面三部分的内容，解析源码看如何完成启动。

JAR 是什么

JAR简介

JAR文件（Java归档，英语: Java ARchive）是一种软件包文件格式，通常用于将大量的Java类文件、相关的元数据和资源（文本、图片等）文件聚合到一个文件，以便分发Java平台应用软件或库。简单点理解其实就是一个压缩包，既然是压缩包那么为了提取JAR文件的内容，可以使用任何标准的unzip解压缩软件提取内容。或者使用Java虚拟机自带命令jar -xf foo.jar来解压相应的jar文件。

JAR 可以简单分为两类：

非可执行JAR。打包时，不用指定main-class，也不可运行。普通jar包可以供其它项目进行依赖。
可执行JAR。打jar包时，指定了main-class类，可以通过java -jar xxx.jar命令，执行main-class的main方法，运行jar包。可运行jar包不可被其他项目进行依赖。

JAR结构

包结构

不管是非可行JAR还是可执行JAR解压后都包含两部分：META-INF目录(元数据)和package目录(编译后的class)。这种普通的jar不包含第三方依赖包，只包含应用自身的配置文件、class 等。

.
├── META-INF
│   ├── MANIFEST.MF  #定义
└── org  # 包路径(存放编译后的class)
    └── springframework

描述文件MANIFEST.MF

JAR包的配置文件是META-INF文件夹下的MANIFEST.MF文件。主要配置信息如下：

Manifest-Version：用来定义manifest文件的版本，例如：Manifest-Version: 1.0
Created-By：声明该文件的生成者，一般该属性是由jar命令行工具生成的，例如：Created-By: Apache Ant 1.5.1
Signature-Version：定义jar文件的签名版本
Class-Path：应用程序或者类装载器使用该值来构建内部的类搜索路径，可执行jar包里需要设置这个。

上面是普通jar包的属性，可运行jar包的.MF文件中，还会有mian-class或start-class等属性。如果依赖了外部jar包，还会在MF文件中配置lib路径等信息。更多信息参见：maven为MANIFEST.MF文件添加内容的方法

至于可运行jar包和普通jar包的目录结构，没有什么特别固定的模式，总之，无论是什么结构，在.MF文件中，配置好jar包的信息，即可正常使用jar包了。

FatJar有什么不同

什么是FatJar？

普通的jar只包含当前 jar的信息，不含有第三方 jar。当内部依赖第三方jar时，直接运行则会报错，这时候需要将第三方jar内嵌到可执行jar里。将一个jar及其依赖的三方jar全部打到一个包中，这个包即为 FatJar。

SpringBoot FatJar解决方案

Spring Boot为了解决内嵌jar问题，提供了一套FatJar解决方案，分别定义了jar目录结构和 MANIFEST.MF。在编译生成可执行 jar 的基础上，使用spring-boot-maven-plugin按Spring Boot 的可执行包标准repackagejar exécutable. Spring Boot possède un conteneur intégré et l'application peut être démarrée directement via la commande java -jar.

Bien qu'il s'agisse d'une simple commande de démarrage, de nombreuses connaissances se cachent derrière elle. Aujourd'hui, je vais vous emmener explorer les principes derrière la startup

FAT JAR

. Cet article contient principalement les parties suivantes :

#🎜🎜#Qu'est-ce que JAR#🎜🎜#. Tout d’abord, vous devez comprendre ce qu’est jar avant de savoir ce que fait java -jar. #🎜🎜#
#🎜🎜##🎜🎜#FatJar Quelle est la différence #🎜🎜#. Quelle est la différence entre le jar exécutable fourni par Spring Boot et le jar ordinaire ? #🎜🎜#
#🎜🎜##🎜🎜#Principe de chargement des classes au démarrage #🎜🎜#. Que fait le chargeur de classe au démarrage ? Comment Spring Boot résout-il le problème de chargement des packages intégrés via un chargeur de classe personnalisé. #🎜🎜#
#🎜🎜##🎜🎜#L'ensemble du processus a commencé #🎜🎜#. Enfin, intégrez le contenu des trois parties précédentes et analysez le code source pour voir comment réaliser le démarrage. #🎜🎜#

Introduction à JAR

jar -xf foo.jar

#🎜🎜##🎜 🎜 #JAR non exécutable#🎜🎜#. Lors du packaging, vous n'avez pas besoin de spécifier main-class et il ne peut pas être exécuté. Les packages jar ordinaires peuvent être utilisés par d'autres projets. #🎜🎜#
#🎜🎜##🎜🎜#JAR exécutable#🎜🎜#. Lors de la construction d'un package jar, la classe main-class est spécifiée. Vous pouvez utiliser la commande java -jar xxx.jar pour exécuter la classe main-classcode> >main, exécute le package jar. Les packages jar exécutables #🎜🎜# ne peuvent pas #🎜🎜# être utilisés par d'autres projets. #🎜🎜#

Structure JAR

META-INF

package

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

MANIFEST.MF dans le <code>META-INF

#🎜🎜#Manifest-Version : utilisé pour définir la version du fichier manifeste, par exemple : Manifest-Version : 1.0#🎜🎜#
#🎜🎜#Created-By : Déclarez le générateur du fichier Généralement, cet attribut est généré par l'outil de ligne de commande jar, par exemple : Created-By : Apache Ant 1.5.1#🎜🎜#
#🎜🎜#Signature-Version : Définissez la version de signature du fichier jar #🎜🎜#
#🎜🎜#Class-Path : Application Ou le chargeur de classe utilise cette valeur pour créer le chemin de recherche de classe interne. Cela doit être défini dans le package jar exécutable. #🎜🎜#

mian-class

start-class

Qu'est-ce que FatJar ?

Solution SpringBoot FatJar

Spring Boot

MANIFEST.MF

spring-boot-maven-plugin

repackage

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

这个是SpringBoot官方提供的用于打包FatJar的插件，org.springframework.boot.loader下的类其实就是通过这个插件打进去的；

下面是此插件将 loader 相关类打入 FatJar 的一个执行流程：

org.springframework.boot.maven#execute->
org.springframework.boot.maven#repackage -> org.springframework.boot.loader.tools.Repackager#repackage->
org.springframework.boot.loader.tools.Repackager#writeLoaderClasses->
org.springframework.boot.loader.tools.JarWriter#writeLoaderClasses

最终的执行方法就是下面这个方法，通过注释可以看出，该方法的作用就是将 spring-boot-loader 的classes 写入到 FatJar 中。

/**
 * Write the required spring-boot-loader classes to the JAR.
 * @throws IOException if the classes cannot be written
 */
@Override
public void writeLoaderClasses() throws IOException {
	writeLoaderClasses(NESTED_LOADER_JAR);
}

打包结果

Spring Boot项目被编译以后，在targert目录下存在两个jar文件：一个是xxx.jar和xxx.jar.original。

其中xxx.jar.original是maven编译后的原始jar文件，即标准的java jar。该文件仅包含应用本地资源。如果单纯使用这个jar，无法正常运行，因为缺少依赖的第三方资源。
因此spring-boot-maven-plugin插件对这个xxx.jar.original再做一层加工，引入第三方依赖的jar包等资源，将其 "repackage" 为xxx.jar。可执行Jar的文件结构如下图所示：

.
├── BOOT-INF
│   ├── classes
│   │   ├── application.properties  # 用户-配置文件
│   │   └── com
│   │       └── glmapper
│   │           └── bridge
│   │               └── boot
│   │                   └── BootStrap.class  # 用户-启动类
│   └── lib
│       ├── jakarta.annotation-api-1.3.5.jar
│       ├── jul-to-slf4j-1.7.28.jar
│       ├── log4j-xxx.jar # 表示 log4j 相关的依赖简写
├── META-INF
│   ├── MANIFEST.MF
│   └── maven
│       └── com.glmapper.bridge.boot
│           └── guides-for-jarlaunch
│               ├── pom.properties
│               └── pom.xml
└── org
    └── springframework
        └── boot
            └── loader
                ├── ExecutableArchiveLauncher.class
                ├── JarLauncher.class
                ├── LaunchedURLClassLoader$UseFastConnectionExceptionsEnumeration.class
                ├── LaunchedURLClassLoader.class
                ├── Launcher.class
                ├── MainMethodRunner.class
                ├── PropertiesLauncher$1.class
                ├── PropertiesLauncher$ArchiveEntryFilter.class
                ├── PropertiesLauncher$PrefixMatchingArchiveFilter.class
                ├── PropertiesLauncher.class
                ├── WarLauncher.class
                ├── archive
                │   ├── # 省略
                ├── data
                │   ├── # 省略
                ├── jar
                │   ├── # 省略
                └── util
                    └── SystemPropertyUtils.class

META-INF: 存放元数据。MANIFEST.MF 是 jar 规范，Spring Boot 为了便于加载第三方 jar 对内容做了修改；
org: 存放Spring Boot 相关类，比如启动时所需的 Launcher 等；
BOOT-INF/class： 存放应用编译后的 class 文件；
BOOT-INF/lib： 存放应用依赖的 JAR 包。

Spring Boot的MANIFEST.MF和普通jar有些不同：

Spring-Boot-Version: 2.1.3.RELEASE
Main-Class: org.springframework.boot.loader.JarLauncher
Start-Class: com.rock.springbootlearn.SpringbootLearnApplication
Spring-Boot-Classes: BOOT-INF/classes/
Spring-Boot-Lib: BOOT-INF/lib/
Build-Jdk: 1.8.0_131

Main-Class： 是java -jar启动引导类，但这里不是项目中的类，而是Spring Boot内部的JarLauncher。
Start-Class： 这个才是正在要执行的应用内部主类

所以java -jar启动的时候，加载运行的是JarLauncher。Spring Boot内部如何通过JarLauncher 加载Start-Class 执行呢？为了更清楚加载流程，我们先介绍下java -jar是如何完成类加载逻辑的。

启动时的类加载原理

这里简单说下java -jar启动时是如何完成记载类加载的。Java 采用了双亲委派机制，Java语言系统自带有三个类加载器：

Bootstrap CLassloder： 最顶层的加载类，主要加载核心类库
Extention ClassLoader： 扩展的类加载器，加载目录%JRE_HOME%/lib/ext目录下的jar包和class文件。还可以加载-D java.ext.dirs选项指定的目录。
AppClassLoader: 是应用加载器。

默认情况下通过java -classpath，java -cp，java -jar使用的类加载器都是AppClassLoader。普通可执行jar通过java -jar启动后，使用AppClassLoader加载Main-class类。如果第三方jar不在AppClassLoader里，会导致启动时候会报ClassNotFoundException。

例如在Spring Boot可执行jar的解压目录下，执行应用的主函数，就直接报该错误：

Exception in thread "main" java.lang.NoClassDefFoundError: org/springframework/boot/SpringApplication
at com.glmapper.bridge.boot.BootStrap.main(BootStrap.java:13)
Caused by: java.lang.ClassNotFoundException: org.springframework.boot.SpringApplication
at java.net.URLClassLoader.findClass(URLClassLoader.java:381)
at java.lang.ClassLoader.loadClass(ClassLoader.java:424)
at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:338)
at java.lang.ClassLoader.loadClass(ClassLoader.java:357)
... 1 more

从异常堆栈来看，是因为找不到SpringApplication这个类；这里其实还是比较好理解的，BootStrap类中引入了SpringApplication，但是这个类是在BOOT-INF/lib下的，而java指令在启动时未指明classpath，依赖的第三方jar无法被加载。

Spring Boot JarLauncher启动时，会将所有依赖的内嵌 jar (BOOT-INF/lib 目录下) 和class（BOOT-INF/classes 目录）都加入到自定义的类加载器LaunchedURLClassLoader中，并用这个ClassLoder去加载MANIFEST.MF配置Start-Class，则不会出现类找不到的错误。

LaunchedURLClassLoader是URLClassLoader的子类， URLClassLoader会通过URL[] 来搜索类所在的位置。Spring Boot 则将所需要的内嵌文档组装成URL[]，最终构建LaunchedURLClassLoader类。

启动的整个流程

有了以上知识的铺垫，我们看下整个 FatJar 启动的过程会是怎样。为了以便查看源码和远程调试，可以在 pom.xml 引入下面的配置：

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

简单概括起来可以分为几步：

java -jar 启动，AppClassLoader 则会加载 MANIFEST.MF 配置的Main-Class, JarLauncher。
JarLauncher启动时，注册URL关联协议。
获取所有内嵌的存档(内嵌jar和class)
根据存档的URL[]构建类加载器。
然后用这个类加载器加载Start-Class。保证这些类都在同一个ClassLoader中。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!

Java spring spring boot bootstrap maven 子类 xml misc 栈堆 .net class Thread apache

Déclaration：

Cet article est reproduit dans:. en cas de violation, veuillez contacter admin@php.cn Supprimer

Article précédent：Comment intégrer https avec SpringbootArticle suivant：Comment intégrer https avec Springboot

Articles Liés

Voir plus