Spring Boot applications can be quickly packaged using spring-boot-maven-plugin to build an executable jar. Spring Boot has an embedded container, and the application can be started directly through the java -jar command.
Although it is a simple startup command, there is a lot of knowledge hidden behind it. Today I will take you to explore the principles behind FAT JAR startup. This article mainly contains the following parts:
What is JAR. First, you need to understand what jar is before you know what java -jar does.
What's the difference with FatJar. What is the difference between the executable jar provided by Spring Boot and the ordinary jar?
Class loading principle at startup. What does the classloader do during startup? How does Spring Boot solve the loading problem of embedded packages through a custom class loader.
The entire process started. Finally, integrate the contents of the previous three parts and analyze the source code to see how to complete the startup.
JAR file (Java Archive, English: Java ARchive) is a software package file format that is usually used to aggregate a large number of Java class files, related metadata and resource (text, images, etc.) files into one file to distribute Java platform application software or libraries. To understand it simply, it is actually a compressed package. Since it is a compressed package, in order to extract the contents of the JAR file, you can use any standard unzip decompression software to extract the contents. Or use the command jar -xf foo.jar that comes with the Java virtual machine to decompress the corresponding jar file.
JARs can be simply divided into two categories:
Non-executable JAR. When packaging, you do not need to specify main-class, and it cannot be run. Ordinary jar packages can be used by other projects to depend on.
Executable JAR. When building a jar package, the main-class class is specified. You can execute the main# of main-class through the java -jar xxx.jar command. ##Method, run the jar package. The runnable jar package cannot be depended on by other projects.
META-INF directory (metadata) and package directory (compiled class). This ordinary jar does not contain third-party dependency packages, but only the application's own configuration files, classes, etc.
.
├── META-INF
│ ├── MANIFEST.MF #定义
└── org # 包路径(存放编译后的class)
└── springframeworkMANIFEST.MF file in the META-INF folder. The main configuration information is as follows:
normal jar package, the .MF file of runnable jar package, there will also be mian- Attributes such as class or start-class. If you rely on an external jar package, the lib path and other information will also be configured in the MF file. More informationSee: How to add content to the MANIFEST.MF file with maven
runnable jar packages and normal jar packages There is no particularly fixed pattern for the structure. In short, no matter what the structure is, after configuring the jar package information in the .MF file, you can use the jar package normally.
What is the difference between FatJarWhat is FatJar? Ordinary jar only contains information about the current jar and does not contain third-party jars. When internally relying on a third-party jar, an error will be reported if run directly. In this case, the third-party jar needs to be embedded into the executable jar.Put a jar and its dependent third-party jars into one package. This package is FatJar.
SpringBoot FatJar solutionSpring BootIn order to solve the problem of embedded jars, a set of FatJar solutions are provided, which define jar directories respectively. Structure and MANIFEST.MF. On the basis of compiling and generating the executable jar, use spring-boot-maven-plugin according to the Spring Boot executable package standard repackage to obtain the executable Spring Boot jar. According to the type of executable jar, it is divided into two types: executable Jar and executable war.
<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.classMETA-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中。
The above is the detailed content of What are FatJar and Jar in Springboot?. For more information, please follow other related articles on the PHP Chinese website!
![[Web front-end] Node.js quick start](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
