Comment encapsuler l'entrée de démarrage de l'application SpringBoot

Springboot peut être considéré comme une compétence essentielle pour les programmeurs Java. Tout le monde sait que Springboot peut éventuellement être regroupé dans un package jar via maven, puis utiliser directement la commande java -jar pour l'exécuter. un projet web (ou autre). Cela évite les opérations compliquées du projet Web original basé sur Tomcat. Springboot peut rendre le déploiement de services Web si simple car il dispose d'un serveur Jetty (ou Tomcat) intégré et démarre le serveur pendant le processus de démarrage du conteneur pour exécuter avec succès le service Web. 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

Je pense que tous les Springbooters connaîtront le code suivant. Que vous soyez un nouvel étudiant apprenant Springboot ou un nouveau pilote commençant à étudier le code source de Springboot, ce code est presque notre point de départ. Nous le connaissons tellement que nous pensons que c'est le point de départ du paradis magique de Springboot. Mais est-ce vraiment le cas ?

 // 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);
 }

Nous savons tous qu'après le packaging d'un projet Java, la description de l'entrée du package jar est écrite sous le fichier /META-INF/MANIFEST.MF. de ce fichier. :🎜rrreee🎜La description de l'entrée du fichier est la valeur correspondant à Main-Class, qui est org.springframework.boot.loader.JarLauncher. Alors, nous devons ensuite examiner ce que fait exactement cette classe ? 🎜rrreee🎜La fonction principale évidente attire notre attention. Oui, c'est l'entrée. Regardez la structure vide de JarLauncher et il n'y a pas de code. Cherchons d'abord sa classe parent : 🎜rrreee🎜Vous pouvez voir dans le code Ça tourne. que la classe parent qui fait réellement le travail est ExecutableArchiveLauncher. Elle construit une instance d'archive lors de l'initialisation, qui encapsule les informations du fichier /META-INF/MANIFEST.MF. . Nous l'utiliserons également plus tard. 🎜🎜Vient ensuite la méthode de lancement. Nous ne nous soucions que du processus d'exécution de base : 🎜rrreee🎜Ici, nous appelons d'abord la méthode getMainClass de la sous-classe ExecutableArchiveLauncher. La logique principale est de l'obtenir à partir du /META-INF/MANIFEST. Fichier .MF Les informations Start-Class correspondent à la chaîne com.vivo.internet.nex.repeater.console.RepeaterConsoleApplication ci-dessus, qui est associée à la classe de démarrage que nous avons écrite. 🎜🎜Vient ensuite l'exécution spécifique de la méthode de lancement. launch() crée d'abord un MainMethodRunner, transmet les paramètres Start-Class et transparent obtenus ci-dessus, puis appelle la méthode run de MainMethodRunner. L'exécution de la méthode run est également très simple, c'est-à-dire charger la classe de démarrage correspondant à Start-Class, puis appeler de manière réfléchie la méthode principale de la classe de démarrage. Vient ensuite le processus d’initialisation du conteneur. 🎜rrreee

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!