文章内容
SpringBoot项目支持两种常见的打包形式: jar 包和 war 包。默认情况下创建的 Spring Boot项目是采用 jar 包形式，如果项目需要 war 包，可通过修改配置打成 war 包。
Spring Boot 的 jar 包项目发布形式简单、快捷且内置 web 容器，因此 Spring Boot 将其作为默认选项。在享受便利的同时，需要多少了解一下 Spring Boot 的 jar 包是如何生成的，以及如何通过 jar 包启动运行。
一、jar包的生成
Spring Boot 的可执行 jar 包又称作“fat jar”，是包含所有三方依赖的 jar。它与传统 jar 包最大的不同是包含了一个 lib 目录和内嵌了 web 容器(均以 tomcat 为例)。
1、配置
jar 包通常是由集成在 pom.xml 文件中的 maven 插件来生成的。配置在 pom 文件 build 元素中的 plugins 内。
<build>
<plugins>
<plugin>
<groupId>org . springframework. boot</groupId>
<artifactId>spring- boot-maven- plugin</ artifactId>
</plugin>
</plugins>
</build>
2、源码解析
spring-boot-maven-plugin 项目存在于 spring-boot-tools 目录中。spring-boot-maven-plugin默认有 5 个 goals：repackage、 run、 start、 stop、 build-info。在打包的时候默认使用的是 repackage。
spring-boot-maven-plugin 的 repackage 能够将 mvn package 生成的软件包，再次打包为可执行的软件包，并将 mvn package 生成的软件包重命名为*.original。
这就为什么当执行 maven clean package 时，spring-boot-maven-plugin 会在 target 目录下生成两个 jar 文件。
spring-learn-0.0.1-SNAPSHOT.jar
spring-learn-0.0.1-SNAPSHOT. jar.original
其中可以将 spring-learn-0.0.1-SNAPSHOT.jar.original 文件的后缀 original 去掉，生成的新jar包便是包含业务代码的包（普通的jar包）。另外的spring-learn-0.0.1-SNAPSHOT.jar包则是在 Spring Boot 中通过 jar启动的包，它包含了应用的依赖，以及 spring boot 相关 class。
spring-boot-maven-plugin 的 repackage 在代码层面调用了 RepackageMojo 的 execute 方法。RepackageMojo 类就是提供重新打包现有的 jar 或 war 包文件，使得它们可以使用java jar 来进行启动。
1）RepackageMojo 的 execute 方法
@Override
public void execute() throws MojoExecutionException, MojoFailureException {
if (this.project.getPackaging().equals("pom")) {
getLog().debug("repackage goal could not be applied to pom project.");
return;
}
if (this.skip) {
getLog().debug("skipping repackaging as per configuration.");
return;
}
repackage();
}
在 execute 方法中判断了是否为 pom 项目和是否跳过，如果是，则打印 debug 日志并返回；否则继续执行 repackage 方法。
2）RepackageMojo 中的 repackage 方法相关源代码及操作解析
private void repackage() throws MojoExecutionException {
// maven生成的jar，最终的命名将加上.original后缀
Artifact source = getSourceArtifact();
//最终为可执行jar，即fat jar
File target = getTargetFile();
//获取重新打包器，将maven生成的jar重新打包成可执行jar
Repackager repackager = getRepackager(source.getFile());
//查找并过滤项目运行时依赖的jar
Set<Artifact> artifacts = filterDependencies(this.project.getArtifacts(), getFilters(getAdditionalFilters()));
//将 artifacts 转换成 Libraries
Libraries libraries = new ArtifactsLibraries(artifacts, this.requiresUnpak, getLog());
try {
/获得Spring Boot启动脚本
LaunchScript launchScript = getLaunchScript();
//执行重新打包，生成fat jar
repackager.repackage(target, libraries, launchScript);
} catch (IOException ex) {
throw new MojoExecutionException(ex.getMessage(), ex);
}
将maven生成的jar更新成original文件
updateArtifact(source, target, repackager.getBackupFile());
}
关于整个 repackage 方法的操作流程在代码中已经进行相应注释说明，其基本过程为：获得 maven 生成的普通 jar 包、获得目标 File 对象、获得重新打包器、获得依赖 jar 包、获得启动脚本，最后通过重新打包器进行重新打包为可通过 java -jar 执行的 jar 包。
3）获取 Repackager 的方法 getRepackager 的源代码
private Repackager getRepackager(File source) {
Repackager repackager = new Repackager(source, this.layoutFactory);
repackager.addMainClassTimeoutWarningListener(new LoggingMainClassTimeoutWarningl istener());
//设置 main class 的名称，如果不指定，则会查找第一个包含 main方法的类
// repackage 最后将会设置 org.springframework.boot.Loader.JarLauncher
repackager.setMainClass(this.mainClass);
if (this.layout != null) {
getLog().info("Layout: " + this.layout);
//比如，layout返回@org.springframework.boot.loader.tools.Layouts.Jar
repackager.setLayout(this.layout.layout());
}
return repackager;
}
getRepackager 方法主要是根据将要被转换的文件(jar或war) 创建了 Repackager 对象，并设置启动用的 MainClass 为 org.springframework.boot.loader.JarLauncher，该配置对应于 jar 包中 Manifest.MF 文件内的 MainClass 值。
同时，如果 layout 不为 null，通过内部枚举类 LayoutType 提供的 layout 方法获取对应的重新打包的实现类，比如针对 jar 包的 org.springframework.boot.loader.tools.Layouts.Jar类。
4）枚举类 LayoutType 的定义
public enum LayoutType {
JAR(new Jar()),
WAR(new War()),
ZIP(new Expanded()),
DIR(new Expanded()),
NONE(new None());
}
从 LayoutType 的定义可以看出，Spring Boot其实是支持多种类型的 archive (即归档文件) : jar 类型、war 类型、zip 类型、 文件目录类型和 NONE。很显然，使用了相同的实现类来处理 ZIP 文件和 DIR 文件。
5）jar 类型
jar 类型为 Layouts 类的内部类，可以简单看一下 jar 类型的处理类都包含 了哪些内容：
public static class Jar implements RepackagingLayout {
//获取具体的 Lancher 类全路径
@Override
public String getLauncherClassName() {
return "org.springframework.boot.loader.Jarlauncher";
}
//获得具体的依赖 jar 包路径
@Override
public String getLibraryDestination(String libraryName, LibraryScope scop) {
return "BOOT - INF/lib/";
}
//获取重新打包的 class 文件路径
@Override
public String getRepackagedClassesLocation() {
return "BOOT -INF/classes/";
}
}
通过源代码可以看出，jar 类型的归档文件(jar 包)中包含了 jar 包启动的 Main-class (JarLauncher) ： BOOT-INF/lib/目录和 BOOT-INF/classes/目录。如果看 Expanded 和 None 类，会发现它们又继承自 jar。
6 ） Repackager 中 repackage 方法
RepackageMojo 中的 repackage 调用所获取的 Repackager 的repackage 方法：
public void repackage(File destination, Libraries libraries, LaunchScript 1aunchScript) throws IOException {
//校验目标文件
if (destination == null| | destination.isDirectory()) {
throw new illegalArgumentException("Invalid destination");
}
//校验依赖库
if (libraries = null) {
throw new IllegalArgumentException("Libraries must not be nu1l");
}
//校验是否存在对应的 Layout, 如果不存在则创建
if (this.layout == null) {
this.layout = getLayoutFactory().getLayout(this.source);
}
destination = destination.getAbsoluteFile();
File workingSource = this.source;
//检查是否已经重新打包
if (alreadyRepackaged() && this.source.equals(destination)) {
return;
}
//如果目标文件和 source 相同，则删除原有备份文件(.original 结尾的)，重新备份 source 文件
if (this.source.equals(destination)) {
workingSource = getBackupFile();
workingSource.delete();
renameFile(this.source, workingSource);
}
destination.delete();
try {
try (JarFile jarFileSource = new JarFile(workingSource)) {
//核心功能就是创建 JarWriter 向文件指定文件中写入内容
repackage(jarFileSource, destination, libraries, launchScript);
} finally {
if (!this.backupSource && !this.source.equals(workingSource)) {
deleteFile(workingSource);
}
}
}
}
上述代码的核心业务逻辑如下：
- 校验各类参数(文件和路径是否存在)。
- 备份待重新打包的文件以.original 结尾， 如果已经存在备份文件则先执行删除操作。
- 生成目标文件之前，先清除一下目标文件。
- 调用重载的 repackage 方法，进行具体(jar 包)文件的生成和 MANIFESTMF 的信息写入。
- 最后，判断并执行 workingSource 的清除操作
- 用一句话总结上述过程：当符合条件时，对原有 jar 包文件进行备份，并生成新的可以通过 jar-jar 启动的文件。
二、jar包的结构
spring-learn-0.0.1-SNAPSHOT.jar的目录结构：
在上述结构中，BOOT-INF/classes 目录中存放业务代码，BOOT-INF/lib 目录中存放了除java虚拟机之外的所有依赖；org 目录中存放了 Spring Boot 用来启动 jar 包的相关 class文件；META-INF 目录中存放了 MANIFEST.MF、maven 信息和 spring factories 文件。
其中，Manifest.MF 文件通常被用来定义扩展或档案打包相关数据，它是一个元数据文件，数据格式为名/值对。一个可执行的 jar 文件需要通过该文件来指出该程序的主类。
Manifest-Version: 1.0
Implementation-Title: spring-learn
Implementation-Version: 0.0.1-SNAPSHOT
Start-Class: com.secbro2.learn.SpringLearnApplication
Spring-Boot-Classes: B0OT-INF/classes/
Spring-Boot-Lib: B0OT-INF/lib/
Build-Jdk-Spec: 1.8
Spring-Boot-Version: 2.2.1.RELEASE
Created-By: Maven Archiver 3.4.0
Main-Class: org.springframework.boot.loader.Jarlauncher
Manifest.MF 文件中定义 Main-Class 设置为org.springframework.boot.loader.JarLauncher, 也就是说，jar 包程序启动入口为JarLauncher类的 main 方法。JarLauncher 类位 于 spring-boot-loader 项目中，在 jar 包的 org 目录中便存储着 Launcher 相关类的 class 文件。
项目的弓导类定义在 Start-Class 属性中，需要注意的是，Start-Class 属性并非 Java 标准的 Manifest.MF 属性。