Thinking In Spring Boot 之 Spring Boot 如何启动—JarLauncher 实现原理（二）

ゝ一纸荒年。 2022-02-16 01:57 275阅读 0赞

通过上篇博客，已经了解了Spring Boot 启动时依靠于 **META-INF/MANIFEST.MF** 中的 **Main-Class** 启动的。

为了方便学习源码添加jar包如下

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

下面我们深入了解下** JarLauncher** 是如何实现启动 **main(String\[\] args)** 的。

首先看下 Launcher 的类图

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NDIzMTA1_size_16_color_FFFFFF_t_70][]

我们可以发现 **Launcher** 有一个抽象类 **ExecutableArchiveLauncher** ，**JarLauncher** 和 **WarLauncher** 都继承了 **ExecutableArchiveLauncher**

进入 **JarLauncher** 类中，执行main方法

public class JarLauncher extends ExecutableArchiveLauncher {
      ...
      public static void main(String[] args) throws Exception {
       new JarLauncher().launch(args);
      }
    }

**launch()** 方法是 抽象类 **Launcher** 实现的方法

public abstract class Launcher {	
    	...
    	protected void launch(String[] args) throws Exception {
    		JarFile.registerUrlProtocolHandler();
    		ClassLoader classLoader = createClassLoader(getClassPathArchives());
    		launch(args, getMainClass(), classLoader);
    	}
    }

launch方法分为三步骤

1.  注册URL协议并清除应用缓存
2.  设置类加载路径
3.  执行main方法

## 1 JarFile.registerUrlProtocolHandler() ##

该方法利用了 **java.net.URLStreamHandler **扩展机制，其实现由 **URL\#getURLStreamHandler(String)** 提供。

public class JarFile extends java.util.jar.JarFile {
        ...
        // 注册URL协议
      public static void registerUrlProtocolHandler() {
          String handlers = System.getProperty(PROTOCOL_HANDLER, "");
          System.setProperty(PROTOCOL_HANDLER, ("".equals(handlers) ? HANDLERS_PACKAGE
              : handlers + "|" + HANDLERS_PACKAGE));
          resetCachedUrlHandlers();
        }
    	// 重置并清除应用缓存
        private static void resetCachedUrlHandlers() {
          try {
            URL.setURLStreamHandlerFactory(null);
          }
          catch (Error ex) {
            // Ignore
          }
        }
    }

## 2 createClassLoader(getClassPathArchives()) ##

创建 **ClassLoader ,getClassPathArchives()** 由子类 **ExecutableArchiveLauncher** 实现

public abstract class ExecutableArchiveLauncher extends Launcher {
      ...
      protected List<Archive> getClassPathArchives() throws Exception {
       List<Archive> archives = new ArrayList<>(
         this.archive.getNestedArchives(this::isNestedArchive));
       postProcessClassPathArchives(archives);
       return archives;
      }
    }

**isNestedArchive(Archive.Entry entry)** 需要子类 **JarLauncher** 或 **WarLauncher** 实现，以 **JarLauncher** 为例

public class JarLauncher extends ExecutableArchiveLauncher {
    	...
    	@Override
    	protected boolean isNestedArchive(Archive.Entry entry) {
    		if (entry.isDirectory()) {
    			return entry.getName().equals(BOOT_INF_CLASSES);
    		}
    		return entry.getName().startsWith(BOOT_INF_LIB);
    	}
    }

该方法主要是为了过滤掉 **Archive.Entry** 实例是否匹配 **BOOT-INF/lib** 或 **BOOT-INF/classes** ,只要符合以上路径即可，故 **getClassPathArchives()** 的返回值还是取决于**archives** 属性对象的内容。

public abstract class ExecutableArchiveLauncher extends Launcher {
      private final Archive archive;
      public ExecutableArchiveLauncher() {
        try {
          this.archive = createArchive();
        }
        catch (Exception ex) {
         throw new IllegalStateException(ex);
        }
      }
      ...
    }

**createArchive()** 该方法来自于父类 **Launcher** ,该方法主要判断文件路径和归档文件是否正确

public abstract class Launcher {
        ...
    	protected final Archive createArchive() throws Exception {
    		ProtectionDomain protectionDomain = getClass().getProtectionDomain();
    		CodeSource codeSource = protectionDomain.getCodeSource();
    		URI location = (codeSource != null ? codeSource.getLocation().toURI() : null);
    		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);
    		}
    		return (root.isDirectory() ? new ExplodedArchive(root)
    				: new JarFileArchive(root));
    	}
    }

## 3 launch(args, getMainClass(), classLoader) ##

该方法的实际执行者是 **createMainMethodRunner()**

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, String[] args,
    			ClassLoader classLoader) {
    		return new MainMethodRunner(mainClass, args);
    	}
    }

**MainMethodRunner** 对象关联 **mainClass** 及 **main** 方法参数 **args**

public class MainMethodRunner {
    	...
      public MainMethodRunner(String mainClass, String[] args) {
       this.mainClassName = mainClass;
       this.args = (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[] { this.args });
    	}
    }

而 **mainClass** 来自 **getMainClass()**

public abstract class ExecutableArchiveLauncher extends Launcher {
    	...
    	@Override
    	protected String getMainClass() throws Exception {
    		Manifest manifest = this.archive.getManifest();
    		String mainClass = null;
    		if (manifest != null) {
    			mainClass = manifest.getMainAttributes().getValue("Start-Class");
    		}
    		if (mainClass == null) {
    			throw new IllegalStateException(
    					"No 'Start-Class' manifest entry specified in " + this);
    		}
    		return mainClass;
    	}
    }

类名称来自于 **/META-INF/MANIFEST.MF** 资源中的 **Start-Class** 属性，其子类没有覆盖此方法实现，故无论是JAR还是WAR，读取 Spring Boot 启动类均来自于此属性。获取mainClass 之后会执行**MainMethodRunner\#run()**方法去读取**mainClass** 类中的**main(String\[\] args)**方法

// 方法一开始就展示了，为了更加清楚哪里调用，再写一遍
    public abstract class Launcher {
      protected void launch(String[] args, String mainClass, ClassLoader classLoader)
        throws Exception {
       Thread.currentThread().setContextClassLoader(classLoader);
       createMainMethodRunner(mainClass, args, classLoader).run();
      }
    }

因此 **JarLuncher** 实际上是同进程内调用 **Start-Class** 类的 **main(String\[\] args)** 方法，并在启动前准备好了 **Class Path**. WarLuncher 就不展开了,大部分实现逻辑如上，详情参考 **Spring Boot 编程思想\#第二章**。

原著：**书名: Spring Boot 编程思想 作者：小马哥**

--------------------

***Please enjoy the pain which is unable to avoid.***

***请享受无法回避的痛苦。***

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NDIzMTA1_size_16_color_FFFFFF_t_70]: /images/20220216/caa1500ce22040b5bd4ad6c31ae77ffa.png