.jar中没有主清单属性_SpringBoot构建Jar包源码分析

我们知道，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"?>4.0.0org.springframework.boot        spring-boot-starter-parent        2.2.2.RELEASEcom.sourcecode.analysis    sourcecode-analysis-springboot    0.0.1-SNAPSHOTsourcecode-analysis-springbootDemo project for Spring Boot1.8org.springframework.boot            spring-boot-starter        org.springframework.boot            spring-boot-starter-web        org.springframework.boot            spring-boot-starter-test            testorg.junit.vintage                    junit-vintage-engine                org.springframework.boot                spring-boot-maven-plugin            

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的插件配置，可以看到如下核心配置：

                    org.springframework.boot            spring-boot-maven-plugin            

从名字感官上可以看出这应该是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 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集合​

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);      }   }}

这个方法核心逻辑如下：

对传入的参数做必要性判断

根据jar包后缀判断初始化layout对象，这里初始化的是JarLayout，JarLayout主要布局信息为：BOOT-INF/lib为lib目录，BOOT-INF/classes为class类文件目录，需要写入springboot自定义的classloader使jar可正常执行

将maven-jar-plugin插件构建的原始jar包备份后缀为original文件中，并将原始jar包删除，这么做目的是准备好从备份original文件到原始jar包的重构环境

进入Repackager对象的repackage重载方法，将准备好的参数带入

我们继续跟入Repackager对象的repackage重载方法，源码如下：

private void repackage(JarFile sourceJar, File destination, Libraries libraries, LaunchScript launchScript)      throws IOException {    // 遍历前面传入的artifacts //并封装到内部Map 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 libraryEntryNames      // 将所有lib写入到原始jar中      writeableLibraries.write(writer);   }}

这个方法从顶层直观告诉我们springboot对原始jar包动手脚的整个先后顺序。核心逻辑如下：

实例化lib信息预写对象，主要是遍历libratis对象的artifacts属性，封装到map中

将原始jar File对象包装成JarWrite对象，准备往干净的(因为前面被删过)原始jar文件写入新的东西

往原始jar写入META-INF/MANIFEST.MF文件内容

往原始jar写入classloader

从备份的original文件复制class类文件以及其他资源文件写入到原始jar BOOT-INF/classes目录下

将从pom.xml解析到的artifacts lib依赖包文件流写入到原始jar BOOT-INF/lib目录下

为了更加深度解析，我们分别进入每个写入方法大致过一下处理逻辑源码，下面逻辑都写在每一行代码注释中，请用心看注释描述。另外配套前面顶层源码的截图信息。

实例化lib信息预写对象源码如下：

// Repackager类的一个内部类private final class WritableLibraries implements UnpackHandler {    private final Map 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 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 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对象源码如下：

写入META-INF/MANIFE文件内容源码如下：

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");}

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();   }}

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));         }      }   }}

从备份original文件复制class文件源码如下：

连带调用源码如下：

void writeEntries(JarFile jarFile, EntryTransformer entryTransformer, UnpackHandler unpackHandler)      throws IOException {   Enumeration 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);         }      }   }}

写入lib资源源码如下：

这个方法前面实例化lib预写对象时已经看过了，这里再放出来一遍：

//可以看到写入是通过外部传入的JarWriter来执行的

//这个外部JarWriter实际就是原始jar的JarWriter对象

private void write(JarWriter writer) throws IOException {   for (Entry entry : this.libraryEntryNames.entrySet()) {      writer.writeNestedLibrary(entry.getKey().substring(0, entry.getKey().lastIndexOf('/') + 1),            entry.getValue());   }}

整个springboot重构jar包源码分析到此就算结束了，你get到了吗？

如果你读完还一头雾水没啥收获，这里给出的绝招是：请集中精力，再读一遍！