Was sind FatJar und Jar in Springboot?

Einführung

Die Spring Boot-Anwendung kann mit spring-boot-maven-plugin schnell gepackt werden, um ein 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 的可执行包标准repackageausführbares JAR zu erstellen. Spring Boot verfügt über einen eingebetteten Container und die Anwendung kann direkt über den Befehl java -jar gestartet werden.

Obwohl es sich um einen einfachen Startbefehl handelt, verbirgt sich dahinter eine Menge Wissen. Heute werde ich Sie mitnehmen, um die Prinzipien hinter dem Startup von

FAT JAR

zu erkunden. Dieser Artikel enthält hauptsächlich die folgenden Teile:

• 🎜Was ist JAR🎜. Zuerst müssen Sie verstehen, was jar ist, bevor Sie wissen, was java -jar tut. 🎜
• 🎜🎜Was ist der Unterschied zu FatJar🎜. Was ist der Unterschied zwischen dem von Spring Boot bereitgestellten ausführbaren JAR und dem gewöhnlichen JAR? 🎜
• 🎜🎜Klassenladeprinzip beim Start🎜. Was macht der Klassenlader beim Start? Wie löst Spring Boot das Ladeproblem eingebetteter Pakete durch einen benutzerdefinierten Klassenlader? 🎜
• 🎜🎜Der gesamte Prozess🎜 wurde eingeleitet. Integrieren Sie abschließend den Inhalt der vorherigen drei Teile und analysieren Sie den Quellcode, um zu sehen, wie der Startvorgang abgeschlossen werden kann. Was ist JAR? Java-Klassendateien, zugehörige Metadaten und Ressourcendateien (Text, Bilder usw.) werden in einer Datei zusammengefasst, um Anwendungssoftware oder Bibliotheken für die Java-Plattform zu verteilen. Um es einfach zu verstehen: Da es sich um ein komprimiertes Paket handelt, können Sie zum Extrahieren des Inhalts der JAR-Datei eine beliebige Standard-Dekomprimierungssoftware zum Extrahieren verwenden. Oder verwenden Sie den Befehl jar -xf foo.jar, der mit der Java Virtual Machine geliefert wird, um die entsprechende JAR-Datei zu dekomprimieren. 🎜🎜🎜JARs können einfach in zwei Kategorien unterteilt werden: 🎜🎜
  • 🎜🎜Nicht ausführbare JARs🎜. Beim Packen müssen Sie main-class nicht angeben und es kann nicht ausgeführt werden. Gewöhnliche JAR-Pakete können von anderen Projekten als Abhängigkeit verwendet werden. 🎜
  • 🎜🎜Ausführbares JAR🎜. Beim Erstellen eines JAR-Pakets wird die Klasse main-class angegeben. Sie können den Befehl java -jar xxx.jar verwenden, um die Klasse main-class</ auszuführen. code> >main-Methode, führt das JAR-Paket aus. Auf das ausführbare JAR-Paket 🎜 können sich andere Projekte nicht verlassen. 🎜
  🎜

  JAR-Struktur

  🎜Paketstruktur🎜🎜Ob es sich um eine nicht lebensfähige JAR oder eine ausführbare JAR handelt, sie enthält nach der Dekomprimierung zwei Teile: META-INF Verzeichnis (Metadaten) und package Verzeichnis (kompilierte Klasse). Dieses gewöhnliche JAR enthält keine Abhängigkeitspakete von Drittanbietern, sondern nur die eigenen Konfigurationsdateien, Klassen usw. der Anwendung. 🎜

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

  🎜Beschreibungsdatei MANIFEST.MF🎜🎜Die Konfigurationsdatei des JAR-Pakets ist die Datei MANIFEST.MF im Ordner META-INF. 🎜Die Hauptkonfigurationsinformationen🎜 lauten wie folgt: 🎜
  • 🎜Manifest-Version: wird verwendet, um die Version der Manifestdatei zu definieren, zum Beispiel: Manifest-Version: 1.0🎜
  • 🎜Erstellt von: Deklarieren Sie den Generator der Datei. Im Allgemeinen wird dieses Attribut vom JAR-Befehlszeilentool generiert, zum Beispiel: Erstellt von: Apache Ant 1.5.1🎜
  < li>🎜Signature-Version: Definition Signierte Version der JAR-Datei🎜
  • 🎜Class-Path: Die Anwendung oder der Klassenlader verwendet diesen Wert, um den internen Klassensuchpfad zu erstellen. Dies muss im festgelegt werden ausführbares JAR-Paket. 🎜
  🎜🎜Das Obige sind die Attribute des 🎜gewöhnlichen JAR-Pakets🎜. In der .MF-Datei des 🎜ausführbaren JAR-Pakets🎜 gibt es auch mian-class oder start -class< /code> und andere Attribute. Wenn Sie auf ein externes JAR-Paket angewiesen sind, werden der lib-Pfad und andere Informationen auch in der MF-Datei konfiguriert. 🎜Weitere Informationen🎜Siehe: Wie Maven Inhalte zur MANIFEST.MF-Datei hinzufügt🎜🎜Was die Verzeichnisstruktur des 🎜ausführbaren JAR-Pakets🎜 und des 🎜gewöhnlichen JAR-Pakets🎜 betrifft, gibt es kein besonders festes Muster, nein Unabhängig von der Struktur konfigurieren Sie in der .MF-Datei die JAR-Paketinformationen, und Sie können das JAR-Paket normal verwenden. 🎜🎜Was ist der Unterschied zwischen FatJar🎜<h4>Was ist FatJar? </h4>🎜Gewöhnliches Glas enthält nur Informationen über das aktuelle Glas und keine Gläser von Drittanbietern. Wenn Sie sich intern auf eine JAR-Datei eines Drittanbieters verlassen, wird bei direkter Ausführung ein Fehler gemeldet. In diesem Fall muss die JAR-Datei eines Drittanbieters in die ausführbare JAR-Datei eingebettet werden. 🎜Fügen Sie ein Glas und die davon abhängigen Gläser von Drittanbietern in ein Paket ein. Dieses Paket ist FatJar. 🎜🎜<h4>SpringBoot FatJar-Lösung</h4>🎜<code>Spring Boot bietet eine Reihe von FatJar-Lösungen zur Lösung des Problems eingebetteter Jars, die jeweils die 🎜jar-Verzeichnisstruktur🎜 und MANIFEST definieren .MF. Basierend auf dem Kompilieren und Generieren einer ausführbaren JAR-Datei verwenden Sie spring-boot-maven-plugin gemäß dem Standard für ausführbare Pakete von Spring Boot repackage, um eine ausführbare Spring Boot-JAR-Datei zu erhalten. 🎜Je nach Art des ausführbaren Jars wird es in zwei Typen unterteilt: ausführbares Jar und ausführbarer Krieg. 🎜🎜🎜Spring-Boot-Maven-Plugin-Paketierungsprozess🎜🎜Weil es im neu erstellten leeren SpringBoot-Projekt nirgendwo eine explizite Einführung oder das Schreiben verwandter Klassen gibt. Tatsächlich können Sie für jedes neu erstellte SpringBoot-Projekt das folgende Plug-in in seiner pom.xml-Datei sehen: 🎜

  <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中。

  Das obige ist der detaillierte Inhalt vonWas sind FatJar und Jar in Springboot?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!