简单分析SpringBoot java-jar命令行启动原理

// SpringBootDemo.java
@SpringBootApplication
public class SpringBootDemo {
 public static void main(String[] args) {
  SpringApplication.run(SpringBootDemo.class);
 }

}

<dependencies>
 <dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-web</artifactId>
 </dependency>
</dependencies>

<build>
 <finalName>springboot-demo</finalName>
 <plugins>
  <plugin>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-maven-plugin</artifactId>
  </plugin>
 </plugins>
</build>

<build>
 <plugins>
  <plugin>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-maven-plugin</artifactId>
  </plugin>
 </plugins>
</build>

// RepackageMojo.java
private void repackage() throws MojoExecutionException {
 // 获取使用maven-jar-plugin生成的jar，最终的命名将加上.orignal后缀
 Artifact source = getSourceArtifact();
 // 最终文件，即Fat jar
 File target = getTargetFile();
 // 获取重新打包器，将重新打包成可执行jar文件
 Repackager repackager = getRepackager(source.getFile()); 
 // 查找并过滤项目运行时依赖的jar
 Set<Artifact> artifacts = filterDependencies(this.project.getArtifacts(), getFilters(getAdditionalFilters()));
 // 将artifacts转换成libraries
 Libraries libraries = new ArtifactsLibraries(artifacts, this.requiresUnpack, getLog());
 try {
  // 提供Spring Boot启动脚本
  LaunchScript launchScript = getLaunchScript();
  // 执行重新打包逻辑，生成最后fat jar
  repackager.repackage(target, libraries, launchScript);
 }
 catch (IOException ex) {
  throw new MojoExecutionException(ex.getMessage(), ex);
 }
 // 将source更新成 xxx.jar.orignal文件
 updateArtifact(source, target, repackager.getBackupFile());
}

// 继续跟踪getRepackager这个方法，知道Repackager是如何生成的，也就大致能够推测出内在的打包逻辑。
private Repackager getRepackager(File source) {
 Repackager repackager = new Repackager(source, this.layoutFactory);
 repackager.addMainClassTimeoutWarningListener(new LoggingMainClassTimeoutWarningListener());
 // 设置main class的名称，如果不指定的话则会查找第一个包含main方法的类，
 // repacke最后将会设置org.springframework.boot.loader.JarLauncher
 repackager.setMainClass(this.mainClass);
 if (this.layout != null) {
  getLog().info("Layout: " + this.layout);
  repackager.setLayout(this.layout.layout());
 }
 return repackager;
}

/**
 * Executable JAR layout.
 */
public static class Jar implements RepackagingLayout {

 @Override
 public String getLauncherClassName() {
  return "org.springframework.boot.loader.JarLauncher";
 }

 @Override
 public String getLibraryDestination(String libraryName, LibraryScope scope) {
  return "BOOT-INF/lib/";
 }

 @Override
 public String getClassesLocation() {
  return "";
 }

 @Override
 public String getRepackagedClassesLocation() {
  return "BOOT-INF/classes/";
 }

 @Override
 public boolean isExecutable() {
  return true;
 }

}

<dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-loader</artifactId>
 <scope>provided</scope>
</dependency>

// JarLauncher.java
public class JarLauncher extends ExecutableArchiveLauncher {

 // BOOT-INF/classes/
 static final String BOOT_INF_CLASSES = "BOOT-INF/classes/";
 // BOOT-INF/lib/
 static final String BOOT_INF_LIB = "BOOT-INF/lib/";

 public JarLauncher() {
 }

 protected JarLauncher(Archive archive) {
 super(archive);
 }

 @Override
 protected boolean isNestedArchive(Archive.Entry entry) {
 if (entry.isDirectory()) {
 return entry.getName().equals(BOOT_INF_CLASSES);
 }
 return entry.getName().startsWith(BOOT_INF_LIB);
 }
 // main方法
 public static void main(String[] args) throws Exception {
 new JarLauncher().launch(args);
 }

}

// ExecutableArchiveLauncher.java
public ExecutableArchiveLauncher() {
 try {
  // 构造 archive 对象
  this.archive = createArchive();
 }
 catch (Exception ex) {
  throw new IllegalStateException(ex);
 }
}
// 构造 archive 对象
protected final Archive createArchive() throws Exception {
 ProtectionDomain protectionDomain = getClass().getProtectionDomain();
 CodeSource codeSource = protectionDomain.getCodeSource();
 URI location = (codeSource != null) ? codeSource.getLocation().toURI() : null;
 // 这里就是拿到当前的 classpath 的绝对路径
 String path = (location != null) ? location.getSchemeSpecificPart() : null;
 if (path == null) {
  throw new IllegalStateException("Unable to determine code source archive");
 }
 File root = new File(path);
 if (!root.exists()) {
  throw new IllegalStateException("Unable to determine code source archive from " + root);
 }
 // 将构造的archive 对象返回
 return (root.isDirectory() ? new ExplodedArchive(root) : new JarFileArchive(root));
}

public abstract class Archive {
 public abstract URL getUrl();
 public String getMainClass();
 public abstract Collection<Entry> getEntries();
 public abstract List<Archive> getNestedArchives(EntryFilter filter);
}

jar:file:/D:/java/workspace/spring-boot-bootstarp-demo/spring-boot-demo/target/springboot-demo.jar!

// Launcher.java
protected void launch(String[] args) throws Exception {
 /*
  * 利用 java.net.URLStreamHandler 的扩展机制注册了SpringBoot的自定义的可以解析嵌套jar的协议。
  * 因为SpringBoot FatJar除包含传统Java Jar中的资源外还包含依赖的第三方Jar文件
  * 当SpringBoot FatJar被java -jar命令引导时，其内部的Jar文件是无法被JDK的默认实现
  * sun.net.www.protocol.jar.Handler当做classpath的，这就是SpringBoot的自定义协议的原因。
 */
 JarFile.registerUrlProtocolHandler();
 // 通过 classpath 来构建一个 ClassLoader
 ClassLoader classLoader = createClassLoader(getClassPathArchives()); // 1
 launch(args, getMainClass(), classLoader); // 2
}

// ExecutableArchiveLauncher.java
@Override
protected List<Archive> getClassPathArchives() throws Exception {
 List<Archive> archives = new ArrayList<>(this.archive.getNestedArchives(this::isNestedArchive));
 postProcessClassPathArchives(archives);
 return archives;
}

// JarLauncher.java
@Override
protected boolean isNestedArchive(Archive.Entry entry) {
 // entry是文件目录时，必须是我们自己的业务类所在的目录 BOOT-INF/classes/
 if (entry.isDirectory()) {
  return entry.getName().equals(BOOT_INF_CLASSES);
 }
 // entry是Jar文件时，需要在依赖的文件目录 BOOT-INF/lib/下面
 return entry.getName().startsWith(BOOT_INF_LIB);
}

// Launcher.java
protected ClassLoader createClassLoader(List<Archive> archives) throws Exception {
 List<URL> urls = new ArrayList<>(archives.size());
 for (Archive archive : archives) {
  // 前面说到，archive有一个自己的URL的，获得archive的URL放到list中
  urls.add(archive.getUrl());
 }
 // 调用下面的重载方法
 return createClassLoader(urls.toArray(new URL[0]));
}

// Launcher.java
protected ClassLoader createClassLoader(URL[] urls) throws Exception {
 return new LaunchedURLClassLoader(urls, getClass().getClassLoader());
}

// LaunchedURLClassLoader.java
public LaunchedURLClassLoader(URL[] urls, ClassLoader parent) {
 super(urls, parent);
}

// Launcher.java
launch(args, getMainClass(), classLoader);

// ExecutableArchiveLauncher.java
@Override
protected String getMainClass() throws Exception {
 // 从 archive 中拿到 Manifest文件
 Manifest manifest = this.archive.getManifest();
 String mainClass = null;
 if (manifest != null) {
  // 就是MANIFEST.MF 文件中定义的Start-Class属性，也就是我们自己写的com.example.spring.boot.demo.SpringBootDemo这个类
  mainClass = manifest.getMainAttributes().getValue("Start-Class");
 }
 if (mainClass == null) {
  throw new IllegalStateException("No 'Start-Class' manifest entry specified in " + this);
 }
 // 返回mainClass
 return mainClass;
}

// Launcher.java
protected void launch(String[] args, String mainClass, ClassLoader classLoader) throws Exception {
 // 将自定义的LaunchedURLClassLoader设置为当前线程上下文类加载器
 Thread.currentThread().setContextClassLoader(classLoader);
 // 构建一个 MainMethodRunner 实例对象来启动应用
 createMainMethodRunner(mainClass, args, classLoader).run();
}

// Launcher.java
protected MainMethodRunner createMainMethodRunner(String mainClass, String[] args, ClassLoader classLoader) {
 return new MainMethodRunner(mainClass, args);
}

// MainMethodRunner.java
public void run() throws Exception {
 // 使用当前线程上下文类加载器也就是自定义的LaunchedURLClassLoader来加载我们自己写的com.example.spring.boot.demo.SpringBootDemo这个类
 Class<&#63;> mainClass = Thread.currentThread().getContextClassLoader().loadClass(this.mainClassName);
 // 找到SpringBootDemo的main方法
 Method mainMethod = mainClass.getDeclaredMethod("main", String[].class);
 // 最后，通过反射的方式调用main方法
 mainMethod.invoke(null, new Object[] { this.args });
}