So kapseln Sie den Starteintrag der SpringBoot-Anwendung

Springboot kann als eine wesentliche Fähigkeit für Java-Programmierer bezeichnet werden. Jeder weiß, dass Springboot schließlich über Maven in ein JAR-Paket gepackt und dann direkt mit dem Befehl java -jar ausgeführt werden kann ein Webprojekt (oder anderes). Dadurch werden die komplizierten Vorgänge des ursprünglichen Tomcat-basierten Webprojekts vermieden. Springboot kann die Bereitstellung von Webdiensten so einfach machen, da es über einen integrierten Jetty- (oder Tomcat-)Server verfügt und den Server während des Container-Startvorgangs startet, um den Webdienst erfolgreich auszuführen. java -jar命令运行一个Web工程（或其它）。这样就避免了原先基于tomcat的web工程的复杂操作。Springboot能够使Web服务的部署简单到如此程度是因为其内置了Jetty（或Tomcat）服务器，并且在容器启动过程中start该服务器，成功运行Web服务。

相信各位Springbooter一定不会陌生下面的代码，无论是初学Springboot的新同学，或是开始研究Springboot源码的新司机，这段代码几乎是我们的落脚点。我们如此熟悉它，以至于认为它就是Springboot这个魔法乐园的起点。但真的是这样吗？

 @SpringBootApplication
 public class Springboot01helloworldApplication {
     public static void main(String[] args) {
         SpringApplication.run(Springboot01helloworldApplication.class, args);
     }
 }

我们都知道，一个Java工程打包过后，这个jar包的入口描述被写在了/META-INF/MANIFEST.MF文件下，下面让我们来看看这个文件内容：

 Manifest-Version: 1.0
 Archiver-Version: Plexus Archiver
 Built-By: MrXu
 Start-Class: com.vivo.internet.nex.repeater.console.RepeaterConsoleApplication
 Spring-Boot-Classes: BOOT-INF/classes/
 Spring-Boot-Lib: BOOT-INF/lib/
 Spring-Boot-Version: 1.5.19.RELEASE
 Created-By: Apache Maven 3.8.1
 Build-Jdk: 1.8.0_281
 Main-Class: org.springframework.boot.loader.JarLauncher

文件入口的描述为Main-Class对应的value，即org.springframework.boot.loader.JarLauncher。那么，接下来我们需要看下这个类究竟做了什么？

 // JarLauncher.java
 public class JarLauncher extends ExecutableArchiveLauncher {
     static final String BOOT_INF_CLASSES = "BOOT-INF/classes/";
     static final String BOOT_INF_LIB = "BOOT-INF/lib/";
     public JarLauncher() {
     }
     // ...省略无关代码
     public static void main(String[] args) throws Exception {
         (new JarLauncher()).launch(args);
     }
 }

明显的main函数吸引了我们的注意，没错了，这就是入口，看看JarLauncher的空构造并没有任何代码，我们先往它的父类找找：

 // ExecutableArchiveLauncher.java
 public abstract class ExecutableArchiveLauncher extends Launcher {
     public ExecutableArchiveLauncher() {
         try {
             this.archive = this.createArchive();
         } catch (Exception var2) {
             throw new IllegalStateException(var2);
         }
     }
     // ...省略
 }
 
 // Launcher.java
 public abstract class Launcher {
     public Launcher() {}
     // ...省略无关代码
 }

从代码中可以看出，真正干了事情的父类是ExecutableArchiveLauncher，它在初始化时构造了archive实例，该实例封装了/META-INF/MANIFEST.MF文件的信息。后面我们也会用到它。

随后便是launch方法，我们只关系核心执行流程：

 // Launcher.java
 protected void launch(String[] args) throws Exception {
     JarFile.registerUrlProtocolHandler();
     ClassLoader classLoader = this.createClassLoader(this.getClassPathArchives());
     this.launch(args, this.getMainClass(), classLoader);
 }
 // ExecutableArchiveLauncher.java
 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);
     } else {
         return mainClass;
     }
 }

这里首先调用子类ExecutableArchiveLauncher的getMainClass方法，主要逻辑就是从/META-INF/MANIFEST.MF文件中获取Start-Class信息，对应上文就是com.vivo.internet.nex.repeater.console.RepeaterConsoleApplication

Ich glaube, dass alle Springbooter mit dem folgenden Code vertraut sein werden, egal ob Sie ein neuer Student sind, der Springboot lernt, oder ein neuer Treiber, der mit dem Studium des Springboot-Quellcodes beginnt, dieser Code ist fast unser Ausgangspunkt. Wir sind damit so vertraut, dass wir glauben, es sei der Ausgangspunkt des magischen Paradieses Springboot. Aber ist das wirklich so?

 // Launcher.java
 protected void launch(String[] args, String mainClass, ClassLoader classLoader) throws Exception {
     Thread.currentThread().setContextClassLoader(classLoader);
     // 这里首先调用createMainMethodRunner创建一个MainMethodRunner实例，将mainClass和args参数传入。随后调用
     this.createMainMethodRunner(mainClass, args, classLoader).run();
 }
 protected MainMethodRunner createMainMethodRunner(String mainClass, String[] args, ClassLoader classLoader) {
     return new MainMethodRunner(mainClass, args);
 }
 
 // MainMethodRunner.java
 public MainMethodRunner(String mainClass, String[] args) {
     this.mainClassName = mainClass;
     this.args = args != null ? (String[])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((Object)null, this.args);
 }

Wir alle wissen, dass nach dem Packen eines Java-Projekts die Eintragsbeschreibung des JAR-Pakets in die Datei /META-INF/MANIFEST.MF geschrieben wird dieser Datei. :🎜rrreee🎜Die Beschreibung des Dateieintrags ist der Wert, der der Hauptklasse entspricht, nämlich org.springframework.boot.loader.JarLauncher. Als nächstes müssen wir uns also ansehen, was genau diese Klasse macht? 🎜rrreee🎜Die offensichtliche Hauptfunktion erregt unsere Aufmerksamkeit. Schauen wir uns die leere Struktur von JarLauncher an und es gibt keinen Code: 🎜rrreee🎜Sie können es anhand des Codes erkennen Stellen Sie fest, dass die übergeordnete Klasse, die die Arbeit tatsächlich erledigt, ExecutableArchiveLauncher ist. Sie erstellt während der Initialisierung eine Archivinstanz, die die Informationen der Datei /META-INF/MANIFEST.MF kapselt . . Wir werden es später auch verwenden. 🎜🎜Dann kommt die Startmethode. Wir kümmern uns nur um den Kernausführungsprozess: 🎜rrreee🎜Hier rufen wir zuerst die getMainClass-Methode der Unterklasse ExecutableArchiveLauncher auf. Die Hauptlogik besteht darin, sie aus dem /META-INF/MANIFEST abzurufen .MF-Datei Die Informationen zur Startklasse entsprechen der obigen Zeichenfolge com.vivo.internet.nex.repeater.console.RepeaterConsoleApplication, die der von uns geschriebenen Startklasse zugeordnet ist. 🎜🎜Dann erfolgt die spezifische Ausführung der Startmethode launch(), die zunächst einen MainMethodRunner erstellt, die oben erhaltene Startklasse und die transparenten Parameter übergibt und dann die Ausführungsmethode von MainMethodRunner aufruft. Die Ausführung der Ausführungsmethode ist ebenfalls sehr einfach, dh das Laden der Startklasse, die der Startklasse entspricht, und das anschließende reflexive Aufrufen der Hauptmethode der Startklasse. Danach folgt der Initialisierungsprozess des Containers. 🎜rrreee

Das obige ist der detaillierte Inhalt vonSo kapseln Sie den Starteintrag der SpringBoot-Anwendung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!