SpringBoot重构Jar包源码分析

原创
2019/12/26 08:06
阅读数 72

我们知道,SpringBoot仅凭一个Jar包就能将我们构建的整个工程跑起来,如果你也想知道这个能跑起来的jar内部结构是如何构建出来的,请耐心读完本篇,本篇内容可能有点多,但包你有收获。如果读完没有收获,请拉到文章最后,我再告诉你一个绝招。


分析Springboot重构Jar包源码前我们先按平常方式创建一个springboot项目,通过IDEAspringboot提供的网站(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手工运行的主类被配置为keyStart-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源码中找到一个注解@MojorepackageRepackageMojo类文件:

 

 

这个类顶层继承自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对象,这里初始化的是JarLayoutJarLayout主要布局信息为:BOOT-INF/liblib目录,BOOT-INF/classesclass类文件目录,需要写入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软件编程之家》微信公众号



本文分享自微信公众号 - Java软件编程之家(gh_b3a87885f8f5)。
如有侵权,请联系 support@oschina.cn 删除。
本文参与“OSC源创计划”,欢迎正在阅读的你也加入,一起分享。

展开阅读全文
打赏
0
0 收藏
分享
加载中
更多评论
打赏
0 评论
0 收藏
0
分享
返回顶部
顶部