鲁达 launcher实现原理
在上节内容中，我们得知 jar 包 Main-Class 指定入口程序为 Spring Boot 提供的 L auncher(JarL auncher)，并不是我们在 Spring Boot 项目中所写的入口类。那么，Launcher 类又是如何实现项目的启动呢?本节带大家了解其相关原理。
Launcher 类的具体实现类有 3 个: JarL auncher、Warl _auncher 和 PropertiesLauncher,我们这里主要讲解 JarLauncher 和 WarLauncher。首先，以 JarL auncher 为例来解析说明Spring Boot 基于 Launcher 来实现的启动过呈。
JarLauncher
在了解 JarL .auncher 的实现原理之前，先来看看 JarL auncher 的源码。
public class JarLauncher extends ExecutableArchiveLauncher static final String BOOT_ INF_ CLASSES = "BOOT- INF/classes/"; static final String BOOT_ INF_ LIB = "B0OOT-INF/lib/"; //省略构造方法 @Override protected boolean isNestedArchive(Archive. Entry entry) { if (entry. isDirectory()) return entry. getName() . equals(B0OT_ _INF_ CLASSES); return entry . getName() . startsWith(BOOT_ INF_ LIB); public static void main(String[] args) throws Exception { new JarLauncher(). launch(args); } }JarLauncher 类结构非常简单，它继承了抽象类 ExecutableArchiveLauncher，而抽象类又继承了抽象类 Launcher。
JarLauncher 中定义了两个常量: BOOT_ INF_ _CLASSES 和 BOOT_ _INF_ LIB,它们分别定义了业务代码存放在 jar 包中的位置( BOOT-INF/classes/)和依赖 jar 包所在的位置(BOOT-INF/ib/) 。
JarLauncher 中提供了一-个 main 方法，即入口程序的功能，在该方法中首先创建了 JarLauncher 对象，然后调用其 launch 方法。大家都知道，当创建子类对象时，会先调用父类的构造方法。因此，父类 ExecutableArchiveL auncher 的构造方法被调用。
public abstract class ExecutableArchiveL auncher extends L auncher { private final Archive archive; public ExecutableArchiveLauncher() { try { = createArchive(); } catch (Exception ex) { throw new IllegalStateException(ex);} } }在 ExecutableArchiveLauncher 的构造方法中仅实现了父类 Launcher 的 createArchive 方法的调用和异常的抛出。Launcher 类中 createArchive 方法源代码如下。
protected final Archive createArchive() throws Exception { //通过获得当前 Class 类的信息，查找到当前归档文件的路径 ProtectionDomain protectionDomain = getClass() . getProtectionDomain(); CodeSource codeSource = protectionDomain. getCodeSource(); URI location = (codeSource != nu1l) ? codeSource . getLocation() . toURI() null; String path = (location != null) ? location. getSchemeSpecificPart() : n ul1; if (path == null) { throw new IllegalStateException("Unable to determine code source ar chive"); //获得路径之后，创建对应的文件，并检查是否存在 File root = new File(path); if (!root . exists()) { throw new IllegalStateException("Unable to determine code source ar chive from”+ root); //如果是目录，则创建 ExplodedArchive, 否则创建 JarF ileArchive return (root. isDirectory() ? new ExplodedArchive(root) : new JarFileArc hive(root)); }在 createArchive 方法中，根据当前类信息获得当前归档文件的路径(即打包后生成的可执行的 ) ，并检查文件路径是否存在。如果存在且是文件夹，则创建 ExplodedArchive 的对象， 否则创建 JarFileArchive 的对象。
关于 Archive，它在 Spring Boot 中是一个抽象的概念， Archive 可以是一 个jar (JarFileArchive) ，也可以是一个文件目录(ExplodedArchive) ，上面的代码已经进行了很好地证明。你可以理解为它是一个抽象出来的统一 -访问资源的层。Archive 接口的具体定义如下。
public interface Archive extends Iterable<Archive . Entry> { //获取该归档的 url URL getUrl() throws MalformedURL Exception; // 获取 jar!/META- INF 或[ArchiveDir]/META- INF Manifest getManifest() throws IOException; //获取 jar!/B0OT- INF/lib/*. jar 或[ArchiveDir]/BOOT- INF/Lib/*. jar List<Archive> getNestedArchives(EntryFilter filter) throws IOException; }通过 Archive 接口中定义的方法可以看出，Archive 不仅提供了获得归档自身 URL 的方法，也提供了获得该归档内部 jar 文件列表的方法，而 jar 内部的 jar 文件依旧会被 Spring Boot认为是一个 Archive。
通常，jar 里的资源分隔符是!/，在 JDK 提供的 JarFile URL 只支持一层“!"”，而 Spring Boot扩展了该协议，可支持多层"!/”。 因此，在 Spring Boot 中也就可以表示 jar in jar、jar indirectory、fat jar 类型的资源了。
我们再回到 JarL auncher 的入口程序，当创建 JarLauncher 对象，获得了当前归档文件的Archive，下一步便是调用 launch 方法，该方法由 Launcher 类实现。Launcher 中的这个launch 方法就是启动应用程序的入口，而该方法的定义是为了让子类的静态 main 方法调用的。
protected void launch(String[] args) throws Exception { //注册一个“java. protocol . handler. pkgs”属性，以便定位 URLStreamHandler 来处理 jar URL JarFile. registerUrlProtocolHandler(); //获取 Archive, 并通过 Archive 的 URL 获得 CLassL oader(这里为 aunchedURLClassLo ader) ClassLoader classLoader = createClassLoader(getClassPathArchives()); //启动应用程序(创建 MainMethodRunner 类并调用其 run 方法) launch(args，getMainClass(), classLoader); }下 面 看 在 launch 方 法 中 都 具 体 做 了 什 么 操 作 ， 首 先 调 用 了 JarFile 的registerUrIlProtocol-Handler 方法。
public class JarFile extends java.util. jar.JarFile { private static final String PROTOCOL HANDLER = "java. protocol . handler . pkg s"; private static final String HANDLERS_ PACKAGE = "org. springframework . boot . loader"; public static void registerUrlProtocolHandler() { String handlers = System. getProperty(PROTOCOL_ HANDLER, ""); System. setProperty(PROTOCOL HANDLER, ("". equals(handlers) ? HANDLERS_ PA CKAGE : handlers + "|" + HANDLERS_ PACKA GE)); resetCachedUrlHandlers(); private static void resetCachedUrlHandlers() { try {URL. setURLStreamHandlerF actory(null); } catch (Error ex) { //忽咯异常处理 } }}JarFile 的 registerUrlProtocolHandler 方法利用了 ava.net.URLStreamHandler 扩展机制
其实现由 URL #getURL StreamHandler(String) 提供，该方法返回一个 URLStreamHandler类的实现类。针对不同的协议，通过实现 URL StreamHandler 来进行扩展。JDK 默认支持了文件(ile) 、HTTP、JAR 等协议。
关于实现 URL StreamHandler 类来扩展协议，JVM 有固定的要求。
第一:子类的类名必须是 Handler,最后一级包名必须是协议的名称。 比口，自定义了 Http的 协 议 实 现 ， 则 类 名 必 然 为 xx., 而 JDK 对 http 实 现 为 :
sun.net.protocol..第 二 :JVM 启 动 时 ， 通 常 需 要 配 置 Java 系 统 属 性 ava. ， 追 加URLStreamHandler 实现类的 package。 如果有多个实现类(package) ，则用"l 隔开。
JarFile#registerUrlProtocolHandler(String) 方 法 就 是 将 org. 追加到 Java 系统属性 ava. 中。
执行完 JarFile.registerUrlProtocolHandler() 之后，执行 createClassL oader 方法创建ClassLoader。
该方法的参数是通过ExecutableArchiveL auncher实现getClassPathArchives方法获得的。相关实现源代码如下。
public abstract class ExecutableArchiveLauncher extends Launcher { private final Archive archive; @Override protected List<Archive> getClassPathArchives() throws Exception { List<Archive> archives = new ArrayList<>( this . archive. getNestedArchives(this: : isNestedArchive)); postProcessClassPathArchives (archives); return archives; } }在 getClassPathArchives 方法中通过调用当前 archive 的 getNestedArchives 方法， 找到/BOOT-INF/lib 下 jar 及/BOOT-INF/classes 目录所对应的 archive,通过这些 archive 的 URL生成 L _aunchedURL .ClassLoader.创建 L aunchedURLClassL oader 是由 Launcher 中重载的 createClassL oader 方法实现的，代码如下。
public abstract class Launcher {protected ClassLoader createClassLoader(List<Archive> archives) throws Ex ception { List<URL> urls = new ArrayList<> (archives . size()); for (Archive archive : archives) { urls . add(archive . getUr1()); return createClassLoader(urls . toArray(new URL[0])); protected ClassLoader createClassLoader(URL[] urls) throws Exception { return new LaunchedURLClassLoader(urls, getClass().getClassLoader()); } }Launcher#launch 方法的最后一步，是将 ClassLoader( LaunchedURLClassLoader)设置为线程上下文类加载器，并创建 MainMethodRunner 对象， 调用其 run 方法。
public abstract class Launcher { protected void launch(String[] args, String mainClass, ClassLoader classLoader ) throws Exception { Thread. currentThread() . setContextClassLoader(classLoader); createMainMethodRunner(mainClass, args, classLoader). run(); protected MainMethodRunner createMainMethodRunner(String mainClass, Strin3[] args, ClassLoader classLoade r) { return new MainMethodRunner(mainClass, args); } }当 MainMethodRunner 的 run 方法被调用，便真正开始启动应用程序了。
MainMethodRunner 类的源码如下。
public class MainMethodRunner { private final String mainClassName; private final String[] args; public MainMethodRunner(String mainClass, String[] args) { this . mainClassName = mainClass; = (args != null) ? args.clone() : null; } public void run() throws Exception { Class<?> mainClass = Thread. currentThread() . getContextClassLoader() . loadClass (this . mainClassName); Method mainMethod = mainClass . getDeclaredMethod("main", String[].class); mainMethod . invoke(null, new object[] { }); } }上述代码中属性 mainClass 参数便是在 Mani 文件中我们自定义的 Spring Boot 的入口类，即 Start-class 属 性值。在 MainMethodRunner 的 run 方法中，通过反射获得入口类的 main 方法并调用。
至此，Spring Boot 入口类的 main 方法正式执行，所有应用程序类文件均可通过/BOOT-INF/classe 加载，所有依赖的第三方 jar 均可通过/BOOT-INF/lib 加载。
WarL auncher
WarLauncher 与 Jarl auncher 都继承自抽象类 ExecutableArchiveL auncher,它们的实现方式和流程基本相同，差异很小。主要的区别是 war 包中的目录文件和 jar 包路径不同。WarLauncher 部分源代码如下。
public class WarLauncher extends ExecutableArchiveLauncher { private static final String WEB_ INF = "WEB- INF/"; private static final String WEB_ INF_ CLASSES = WEB_ INF + "classes/"; private static final String WEB_ _INF_ LIB = WEB_ INF + "lib/"; private static final String WEB_ INF_ LIB_ PROVIDED = WEB_ INF + "lib- provide d/"; @Override public boolean isNestedArchive (Archive. Entry entry) { if (entry. isDirectory()) { return entry . getName(). equals(WEB_ INF_ CLASSES); }else { return entry . getName(). startsWith(WEB_ INF_ LIB) | | entry . getName() . startsWith(WEB_ INF_ LIB_ PROVIDED); public static void main(String[] args) throws Exception { nev WarLauncher(). launch(args); } }JarL auncher 在 构 建 L auncherURLClassLoader 时 搜 索 BOOT-INF/classes 目 录 及BOOT-INF/lib 目 录 下 的 jar 。 而 通 过 上 述 代 码 可 以 看 出 ， WarL auncher 在 构 建LauncherURLClass-Loader 时 搜 索 的 是 WEB-INFO/classes 目 录 及 WEB-INFO/ib 和WEB-INFO/ib-provided 目录下的 jar。
下面，我们通过对 jar 打包形式的 Spring Boot 项目进行修改，变成可打包成 war 的项目。
然后，再看一下打包成的 war 的目 录结构。第一步，修改 中的 packaging 为 war。
<packaging>war</ packaging>第二步，在 spring-boot-starter-web 依赖中排除 tomcat,并新增 servlet-api 依赖，这里采用的是 Servlet 2.5 版本。
<dependencies> <dependency> <groupId>org . springframework. boot</groupId> <artifactId>spring- boot-starter-web</artifactId> <exclusions> <exclusion> <groupId>org . springframework. boot</groupId> <artifactId>spring-boot- starter- tomcat</artifactId> </exclusion> </ exclusions> </dependency> <dependency> <groupId>javax. servlet</groupId> <artifactId>servlet-api</ artifactId> <version>2. 5</version> </ dependency> </ dependencies>第三步，在 build 配置中将插件替换为 maven-war-plugin.
<build> <plugins> <plugin> <groupId>org . apache . maven. plugins</groupId> <artifactId>maven-war-plugin</ artifactId> <version>2.6</version> <configuration> <fai. lOnMiss ingWebXml>false</ failOnMissingWebXml> </configuration> </plugin> </plugins> </build>第四步，让 Spring Boot 入口类继承 SpringBootServletlnitializer 并实现其方法。
@SpringBootApplicationpublic class SpringBootApp extends SpringBootServletInitializer { public static void main(String[] args) { SpringApplication. run, args); @Override protected SpringApplicationBuilder configure(SpringApplicat ionBuilder bui lder) { return builder. sources );} }执行，maven clean package 即可得到对应的 war 包。同样，这里会生成两个 war 包文件:一个后缀为.war 的可独立部署的文件，一个 war.original 文件，具体命名形式参考 jar 包。
对 war 包解压之后，目录结构如下。
META-INF MANIFEST.MF maven WEB-INF classes lib org springframework最后，war 包文件既能被 WarL auncher 启动，又能兼容 Servlet 容器。其实，jar 包和 war并无本质区别，因此，如果无特殊情况，尽量采用 jar 包的形式来进行打包部署。
小结
本章主要介绍了 Spring Boot 生成的 jar 包文件结构、生成方式、启动原理等内容，同时也引入了不少新概念，比如 Active、Fat jar 等。由于篇幅所限，关于 Spring Boot 中对实现 Jarin Jar 的 JAR 协议扩展不再展开，感兴趣的读者可查看代码进行学习。
本文给大家讲解的内容是SpringBoot打包部署解析：Launcher实现原理
- 下篇文章给大家讲解的是Spring Boot 应用监控解析；
- 觉得文章不错的朋友可以转发此文关注小编；
- 感谢大家的支持！