我们知道，SpringBoot仅凭一个Jar包就能将我们构建的整个工程跑起来，如果你也想知道这个能跑起来的jar内部结构是如何构建出来的，请耐心读完本篇，本篇内容可能有点多，但包你有收获。如果读完没有收获，请拉到文章最后，我再告诉你一个绝招。
分析Springboot重构Jar包源码前我们先按平常方式创建一个springboot项目，通过IDEA或springboot提供的网站（https://start.spring.io/）很容易就可以创建出一个springboot web工程。注意：创建时要把Web Starter选择上，不然后面不会启动Tomcat容器。创建好的项目目录一般大致如下：
pom.xml文件如下：
<?xml version="1.0" encoding="UTF-8"?><project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.2.2.RELEASE</version> <relativePath/> <!-- lookup parent from repository --> </parent> <groupId>com.sourcecode.analysis</groupId> <artifactId>sourcecode-analysis-springboot</artifactId> <version>0.0.1-SNAPSHOT</version> <name>sourcecode-analysis-springboot</name> <description>Demo project for Spring Boot</description>
<properties> <java.version>1.8</java.version> </properties>
<dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter</artifactId> </dependency>
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency>
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> <exclusions> <exclusion> <groupId>org.junit.vintage</groupId> <artifactId>junit-vintage-engine</artifactId> </exclusion> </exclusions> </dependency> </dependencies>
<build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build>
</project>
SourcecodeAnalysisSpringbootApplication.java类如下：
package com.sourcecode.analysis.springboot;
import org.springframework.boot.SpringApplication;import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplicationpublic class SourcecodeAnalysisSpringbootApplication {
public static void main(String[] args) { SpringApplication.run(SourcecodeAnalysisSpringbootApplication.class, args); }
}
application.properties文件默认是空的。
当springboot项目创建好之后，我们可以直接运行SourcecodeAnalysisSpringbootApplication.java类的main方法即可启动web工程，启动成功控制台如下：（默认端口8080）
除此之外我们也可以通过执行maven package方式将项目打成jar包，通过java -jar 命令来运行，运行效果如下：
springboot项目创建过程就是这么多，接下来就可以在这个脚手架基础上去填我们的业务代码了。在springboot之前要实现这个过程可是要配置一大堆xml的，但是现在这些事情springboot通过starter的方式帮我们做了。由于我们本章主要内容是讲解springboot重构jar包的源码，关于springboot starter如何帮我们简化配置的等到后面有时间再写一篇来介绍。
当通过java -jar命令启动jar包时，首先会先从jar包中META-INF/MANIFEST.MF文件中找到Main-Class的值作为主类来运行jar包，这是java基础知识。所以说要了解springboot是如何启动的，我们首先需要将springboot打出来的jar包解压出来，找到META-INF/MANIFEST.MF文件并打开，我们可以看到大概如下内容：
Manifest-Version: 1.0Implementation-Title: sourcecode-analysis-springbootImplementation-Version: 0.0.1-SNAPSHOTStart-Class: com.sourcecode.analysis.springboot.SourcecodeAnalysisSpri ngbootApplicationSpring-Boot-Classes: BOOT-INF/classes/Spring-Boot-Lib: BOOT-INF/lib/Build-Jdk-Spec: 1.8Spring-Boot-Version: 2.2.2.RELEASECreated-By: Maven Archiver 3.4.0Main-Class: org.springframework.boot.loader.JarLauncher
可以看到Main-Class的值为: org.springframework.boot.loader.JarLauncher。通过java -jar运行时执行的主方法便是 org.springframework.boot.loader.JarLauncher类的main方法。而我们通过IDEA手工运行的主类被配置为key为Start-Class的值中，这个类是怎么写到META-INF/MANIFEST.MF文件中的呢？因为我们前面是通过maven package命令打包出来的，所以要解开这个问题我们要回到maven打包阶段去思考，想到这里此时我们应该看下pom.xml的插件配置，可以看到如下核心配置：
<build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> <configuration> <executable>true</executable> </configuration> </plugin> </plugins> </build>
从名字感官上可以看出这应该是springboot打包插件，我们可以大胆猜测springboot通过自己实现的maven package阶段插件对maven-jar-plugin插件创建的jar动了手脚。为了找到具体线索，查看maven package命令日志，可以看到打包阶段执行完maven-jar-plugin插件后接下来果然是执行了spring-boot-maven-plugin插件中的repackage进行jar重构。
为了深入了解springboot是如何对maven-jar-plugin插件原始jar包动手脚的，我们把springboot源码下载下来准备进行源码分析，springboot github 源码clone地址：https://github.com/spring-projects/spring-boot.git。克隆下来源码目录结构如下：
紧接着我们顺藤摸瓜，通过全局搜索repackag关键字的方式从springboot源码中找到一个注解@Mojo为repackage的RepackageMojo类文件：
这个类顶层继承自maven插件抽象父类AbstractMojo，且被定义为打包阶段执行，这个类正是spring-boot-maven-plugin插件中执行的repackage，我们找到插件默认执行的execute方法源码如下：
@Overridepublic 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();}
我们继续跟入repackage()方法，源码如下：
private void repackage() throws MojoExecutionException { // 获取maven-jar-plugin插件构建的jar包 Artifact对象 Artifact source = getSourceArtifact(); // 获取maven-jar-plugin插件构建的jar包 File对象 File target = getTargetFile(); // 实例化重新打包对象，整个打包工作基本由这个对象完成//将maven-jar-plugin插件构建的jar包 File对象传入给source属性 Repackager repackager = getRepackager(source.getFile()); // 过滤掉spring-boot-devtools依赖以及系统本地的依赖 // this.project.getArtifacts()返回//pom.xml当前阶段范围的所有依赖信息对象集合，包含传递过来的 Set<Artifact> artifacts = filterDependencies(this.project.getArtifacts(), getFilters(getAdditionalFilters())); // 创建lib信息对象，这里纯粹传参实例化没有逻辑 Libraries libraries = new ArtifactsLibraries(artifacts, this.requiresUnpack, getLog()); try { // 获取sh应用管理脚本（start/stop/restart），可配置 // 这里默认返回null,唯有配置插件时配置了executable //或embeddedLaunchScript时才会实例化 LaunchScript launchScript = getLaunchScript(); // 进入核心重构jar方法 repackager.repackage(target, libraries, launchScript); } catch (IOException ex) { throw new MojoExecutionException(ex.getMessage(), ex); } //将重构好的File对象set到Artifact对象中，更新jar包文件 updateArtifact(source, target, repackager.getBackupFile());}
这个方法核心逻辑如下：
1、实例化maven-jar-plugin插件构建的原始jar包（后面统称这个jar为原始jar）文件对象
2、实例化启动脚本LaunchScript对象，由于没有配置参数，所以这里返回null
3、实例化Libraries依赖信息对象，这里原理是读取pom.xml依赖后转为Set<Artifact>集合
4、实例化重构jar包核心工作对象Repackager
5、调用Repackager对象的repackager重构jar方法，将实例化好的参数带入
6、最后重构完成后更新原来Artifact File对象
我们继续跟入Repackager对象的repackage方法，源码如下：
public void repackage(File destination, Libraries libraries, LaunchScript launchScript) throws IOException {
//参数校验 if (destination == null || destination.isDirectory()) { throw new IllegalArgumentException("Invalid destination"); } if (libraries == null) { throw new IllegalArgumentException("Libraries must not be null"); }
//实例化layout属性//layout作用是定义重构jar包内部目录名称//以及定义是否需要写入classloader使jar文件可执行，默认true if (this.layout == null) { //这里默认根据文件后缀判断实例化哪个布局对象,//分别有Jar War Expanded(zip)等，默认实例化JarLayout对象 this.layout = getLayoutFactory().getLayout(this.source); }
// maven-jar-plugin构建的原始jar包File对象 destination = destination.getAbsoluteFile(); File workingSource = this.source; if (alreadyRepackaged() && this.source.equals(destination)) { return; } if (this.source.equals(destination)) {workingSource = getBackupFile(); workingSource.delete();// 将原始jar包备份（重命名）为原始jar名称.original文件 renameFile(this.source, workingSource); }//删除原始jar文件 destination.delete(); try { //JarFile是jdk自带的类，可从中获取jar对象信息 try (JarFile jarFileSource = new JarFile(workingSource)) { //将备份jar作为源，将删除后的原始jar作新的目的地，//传入lib对象、启动脚本等参数进入repackage对象的重载方法 repackage(jarFileSource, destination, libraries, launchScript); } } finally {
if (!this.backupSource && !this.source.equals(workingSource)) { //目前版本源码中，这里永远不会执行 因为backupSource写死为true deleteFile(workingSource); } }}
这个方法核心逻辑如下：
1、对传入的参数做必要性判断
2、根据原始jar包后缀判断初始化layout对象，这里初始化的是JarLayout，JarLayout主要布局信息为：BOOT-INF/lib为lib目录，BOOT-INF/classes为class类文件目录，需要写入springboot自定义的classloader使jar可正常执行
3、将maven-jar-plugin插件构建的原始jar包备份后缀为original文件中，并将原始jar包删除，这么做目的是准备好从备份original文件到原始jar包的重构环境
4、进入Repackager对象的repackage重载方法，将准备好的参数带入
我们继续跟入Repackager对象的repackage重载方法，源码如下：
private void repackage(JarFile sourceJar, File destination, Libraries libraries, LaunchScript launchScript) throws IOException {
// 遍历前面传入的artifacts//并封装到内部Map<String, Library> libraryEntryNames中 // 过程中将BOOT-INF/lib/目录拼接上去，//例如put(“BOOT-INF/lib/aaa.jar”, Library) // 同时会对判断是否存在重复依赖，存在会报错Duplicate library aaa.jar WritableLibraries writeableLibraries = new WritableLibraries(libraries);
// JarWriter是springboot封装了apache的JarArchiveOutputStream类 // 底层就是ziparchive版本的OutputStream输出流，支持往jar写东西的对象 // 这里简单理解成new FileOutputStream(new 前面被删除的原始jar文件对象), // 意思是准备往前面被删除的原始jar文件写入东西(删除后文件是干净的) try (JarWriter writer = new JarWriter(destination, launchScript)) {
// 写入META-INF/MANIFEST.MF文件内容 // 我们看到的META-INF/MANIFEST.MF文件内容全部都是这个方法写入的 writer.writeManifest(buildManifest(sourceJar));
// 根据layout配置写入SpringBoot实现的ClassLoader // 写入classloader原因是重构后的jar包的lib目录为BOOT-INF/lib， // 外部的classloader并不知道重构后的lib应该到哪里加载，// 所以springboot插件需要实现一个classloader并设置到线程上下文// 给后续加载类时使用，这里写入的classloader是springboot// 项目的其中一个module,打成jar包后解压写入进去的 writeLoaderClasses(writer); if (this.layout instanceof RepackagingLayout) { //将备份的original中class文件和其他资源文件全部写入到原始jar的//BOOT-INF/classes/目录下，写入过程进行了SHA-1签名 writer.writeEntries(sourceJar, new RenamingEntryTransformer(((RepackagingLayout) this.layout).getRepackagedClassesLocation()), writeableLibraries); } else { writer.writeEntries(sourceJar, writeableLibraries); } // 最后遍历前面WritableLibraries对象内部// Map<String, Library> libraryEntryNames // 将所有lib写入到原始jar中 writeableLibraries.write(writer); }}
这个方法从顶层直观告诉我们springboot对原始jar包动手脚的整个先后顺序。核心逻辑如下：
1、实例化lib信息预写对象，主要是遍历libratis对象的artifacts属性，封装到map中
2、将原始jar File对象包装成JarWrite对象，准备往干净的（因为前面被删过）原始jar文件写入新的东西
3、往原始jar写入META-INF/MANIFEST.MF文件内容
4、往原始jar写入classloader
5、从备份的original文件复制class类文件以及其他资源文件写入到原始jar BOOT-INF/classes目录下
6、将从pom.xml解析到的artifacts lib依赖包文件流写入到原始jar BOOT-INF/lib目录下
为了更加深度解析，我们分别进入每个写入方法大致过一下处理逻辑源码，下面逻辑都写在每一行代码注释中，请用心看注释描述。另外配套前面顶层源码的截图信息。
1、实例化lib信息预写对象源码如下：
顶层源码截图：
// Repackager类的一个内部类private final class WritableLibraries implements UnpackHandler {
private final Map<String, Library> libraryEntryNames = new LinkedHashMap<>();
//外部new调用的参数构造器 private WritableLibraries(Libraries libraries) throws IOException { // libraries实现类为ArtifactsLibraries，前面分析代码过程new出来的 // doWithLibraries方法代码下面有截图，逻辑很简单就是遍历artifact，然后 // 判断去重后调用这里的箭头函数，最后工作就是保存到map中 libraries.doWithLibraries((library) -> { if (isZip(library.getFile())) { // 这里layout代码如下，写死ruturn BOOT-INF/lib/ // public String getLibraryDestination(String libraryName, LibraryScope scope) { // return "BOOT-INF/lib/"; // } String libraryDestination = Repackager.this.layout.getLibraryDestination(library.getName(), library.getScope()); if (libraryDestination != null) {
// 放到map中,key=BOOT-INF/lib/ + jar名称, value=library信息对象 // 这里提一下，library里面有个File file属性，这个属性才是jar文件对象 Library existing = this.libraryEntryNames.putIfAbsent(libraryDestination + library.getName(), library); if (existing != null) { throw new IllegalStateException("Duplicate library " + library.getName()); } } } }); }
// 判断是否允许打开文件，主要后面sha1Hash签名时判断用 @Override public boolean requiresUnpack(String name) { Library library = this.libraryEntryNames.get(name); return library != null && library.isUnpackRequired(); }
// 文件加密方法 @Override public String sha1Hash(String name) throws IOException { Library library = this.libraryEntryNames.get(name); if (library == null) { throw new IllegalArgumentException("No library found for entry name '" + name + "'"); } return FileUtils.sha1Hash(library.getFile()); }
//可以看到写入是通过外部传入的JarWriter来执行的 //这个外部JarWriter实际就是原始jar的JarWriter对象 private void write(JarWriter writer) throws IOException { for (Entry<String, Library> entry : this.libraryEntryNames.entrySet()) { writer.writeNestedLibrary(entry.getKey().substring(0, entry.getKey().lastIndexOf('/') + 1), entry.getValue()); } }
}
ArtifactsLibraries对象的doWithLibraries方法源码如下：
public void doWithLibraries(LibraryCallback callback) throws IOException { Set<String> duplicates = getDuplicates(this.artifacts); for (Artifact artifact : this.artifacts) { LibraryScope scope = SCOPES.get(artifact.getScope()); if (scope != null && artifact.getFile() != null) { String name = getFileName(artifact); // 处理重复jar名称 if (duplicates.contains(name)) { this.log.debug("Duplicate found: " + name); name = artifact.getGroupId() + "-" + name; this.log.debug("Renamed to: " + name); } // 回调传入的函数，artifact.getFile()是重点， // 它是真正jar的File 对象，可以读出来写入到其它地方 callback.library(new Library(name, artifact.getFile(), scope, isUnpackRequired(artifact))); } }}
2、将原始jar File对象包装成JarWrite对象源码如下：
顶层源码截图：
public JarWriter(File file, LaunchScript launchScript) throws FileNotFoundException, IOException { FileOutputStream fileOutputStream = new FileOutputStream(file); if (launchScript != null) { // 如果存在脚本，直接写入原始jar文件 fileOutputStream.write(launchScript.toByteArray()); // 修改下文件执行权限 setExecutableFilePermission(file); } this.jarOutput = new JarArchiveOutputStream(fileOutputStream); this.jarOutput.setEncoding("UTF-8");}
3、写入META-INF/MANIFE文件内容源码如下：
顶层源码截图：
buildManifest源码如下：
private Manifest buildManifest(JarFile source) throws IOException { // 备份original文件的Manifest文件 Manifest manifest = source.getManifest(); if (manifest == null) { manifest = new Manifest(); manifest.getMainAttributes().putValue("Manifest-Version", "1.0"); } // 重新实例化一个新的Manifest文件 manifest = new Manifest(manifest); String startClass = this.mainClass; if (startClass == null) { startClass = manifest.getMainAttributes().getValue(MAIN_CLASS_ATTRIBUTE); } if (startClass == null) { //这里根据规则去找Application启动类，也就是Start-Class的值 //IDEA我们手工run的那个主类 //如果查找超过一定时间会发出警告，建议让你手工配置，查找比较耗时 startClass = findMainMethodWithTimeoutWarning(source); } //layout。getLauncherClassName方法如下： // public String getLauncherClassName() { // return "org.springframework.boot.loader.JarLauncher"; // } String launcherClassName = this.layout.getLauncherClassName(); if (launcherClassName != null) { // 写入 Main-Class manifest.getMainAttributes().putValue(MAIN_CLASS_ATTRIBUTE, launcherClassName); if (startClass == null) { throw new IllegalStateException("Unable to find main class"); } // 写入 Start-Class manifest.getMainAttributes().putValue(START_CLASS_ATTRIBUTE, startClass); } else if (startClass != null) { manifest.getMainAttributes().putValue(MAIN_CLASS_ATTRIBUTE, startClass); } String bootVersion = getClass().getPackage().getImplementationVersion(); manifest.getMainAttributes().putValue(BOOT_VERSION_ATTRIBUTE, bootVersion); // 写入Spring-Boot-Classes = BOOT-INF/classes/ manifest.getMainAttributes().putValue(BOOT_CLASSES_ATTRIBUTE, (this.layout instanceof RepackagingLayout) ? ((RepackagingLayout) this.layout).getRepackagedClassesLocation() : this.layout.getClassesLocation()); String lib = this.layout.getLibraryDestination("", LibraryScope.COMPILE); if (StringUtils.hasLength(lib)) { // 写入Spring-Boot-Lib = BOOT-INF/lib/ manifest.getMainAttributes().putValue(BOOT_LIB_ATTRIBUTE, lib); } return manifest;}
writeManifest关键源码如下：
public void writeManifest(Manifest manifest) throws IOException { JarArchiveEntry entry = new JarArchiveEntry("META-INF/MANIFEST.MF"); writeEntry(entry, manifest::write);}
writeEntry有多个重载方法，最终都走的是下面的重载方法：
private void writeEntry(JarArchiveEntry entry, EntryWriter entryWriter, UnpackHandler unpackHandler) throws IOException {
String parent = entry.getName(); if (parent.endsWith("/")) { parent = parent.substring(0, parent.length() - 1); entry.setUnixMode(UnixStat.DIR_FLAG | UnixStat.DEFAULT_DIR_PERM); } else { entry.setUnixMode(UnixStat.FILE_FLAG | UnixStat.DEFAULT_FILE_PERM); } if (parent.lastIndexOf('/') != -1) { parent = parent.substring(0, parent.lastIndexOf('/') + 1); if (!parent.isEmpty()) { writeEntry(new JarArchiveEntry(parent), null, unpackHandler); } }
if (this.writtenEntries.add(entry.getName())) { // 这里判断是否允许打开文件，如果允许则往里面写入sha1Hash签名 entryWriter = addUnpackCommentIfNecessary(entry, entryWriter, unpackHandler); //前面实例化的原始jar的JarArchiveOutputStream对象 //这里代表写入entry到输出流内存中 this.jarOutput.putArchiveEntry(entry); if (entryWriter != null) { //将输出流写到entryWriter对象 entryWriter.write(this.jarOutput); } //关闭资源 this.jarOutput.closeArchiveEntry(); }}
4、写入classloader源码如下：
顶层源码截图：
writeLoaderClasses源码如下：
private void writeLoaderClasses(JarWriter writer) throws IOException { // 自定义布局时才走这里，一般很少人这么闲自己实现calssloader的 if (this.layout instanceof CustomLoaderLayout) { ((CustomLoaderLayout) this.layout).writeLoadedClasses(writer); } // layout.isExecutable固定返回true,所有进入这里 else if (this.layout.isExecutable()) { writer.writeLoaderClasses(); }}
连环调用源码如下：
private static final String NESTED_LOADER_JAR = "META-INF/loader/spring-boot-loader.jar";
public void writeLoaderClasses() throws IOException { writeLoaderClasses(NESTED_LOADER_JAR);}
public void writeLoaderClasses(String loaderJarResourceName) throws IOException { // getClass().getClassLoader()返回的是JDK的sun.misc.Launcher$AppClassLoader类加载器 // 获取META-INF/loader/spring-boot-loader.jar文件 URL loaderJar = getClass().getClassLoader().getResource(loaderJarResourceName); try (JarInputStream inputStream = new JarInputStream(new BufferedInputStream(loaderJar.openStream()))) { JarEntry entry; while ((entry = inputStream.getNextJarEntry()) != null) { if (entry.getName().endsWith(".class")) { // 遍历spring-boot-loader.jar文件 //把所有的.class文件写入到原始jar包中 writeEntry(new JarArchiveEntry(entry), new InputStreamEntryWriter(inputStream)); } } }}
5、从备份original文件复制class文件源码如下：
顶层源码截图：
void writeEntries(JarFile jarFile, EntryTransformer entryTransformer, UnpackHandler unpackHandler) throws IOException { Enumeration<JarEntry> entries = jarFile.entries(); //遍历整个备份的original文件 while (entries.hasMoreElements()) { JarArchiveEntry entry = new JarArchiveEntry(entries.nextElement()); setUpEntry(jarFile, entry); try (ZipHeaderPeekInputStream inputStream = new ZipHeaderPeekInputStream(jarFile.getInputStream(entry))) { EntryWriter entryWriter = new InputStreamEntryWriter(inputStream); JarArchiveEntry transformedEntry = entryTransformer.transform(entry); if (transformedEntry != null) { //将所有class类文件以及其他资源文件写入到原始jar中 //这里走的是前面分析的带签名的writeEntry重装方法 writeEntry(transformedEntry, entryWriter, unpackHandler); } } }}
void writeEntries(JarFile jarFile, EntryTransformer entryTransformer, UnpackHandler unpackHandler) throws IOException { Enumeration<JarEntry> entries = jarFile.entries(); //遍历整个备份的original文件 while (entries.hasMoreElements()) { JarArchiveEntry entry = new JarArchiveEntry(entries.nextElement()); setUpEntry(jarFile, entry); try (ZipHeaderPeekInputStream inputStream = new ZipHeaderPeekInputStream(jarFile.getInputStream(entry))) { EntryWriter entryWriter = new InputStreamEntryWriter(inputStream); JarArchiveEntry transformedEntry = entryTransformer.transform(entry); if (transformedEntry != null) { //将所有class类文件以及其他资源文件写入到原始jar中 //这里走的是前面分析的带签名的writeEntry重装方法 writeEntry(transformedEntry, entryWriter, unpackHandler); } } }}
6、写入lib资源源码如下：
顶层源码截图：
//可以看到写入是通过外部传入的JarWriter来执行的//这个外部JarWriter实际就是原始jar的JarWriter对象private void write(JarWriter writer) throws IOException { for (Entry<String, Library> entry : this.libraryEntryNames.entrySet()) { writer.writeNestedLibrary(entry.getKey().substring(0, entry.getKey().lastIndexOf('/') + 1), entry.getValue()); }}
整个springboot重构jar包源码分析到此就算结束了，你get到了吗？
如果你读完还一头雾水没啥收获，这里给出的绝招是：请集中精力，再读一遍！
长按扫码关注《Java软件编程之家》微信公众号
