在SpringBoot项目中，很多开发者会被一个问题困扰——SpringBoot可执行Jar包的启动入口究竟在哪里？通过本文，我们将深入解析SpringBoot的启动奥秘，从MANIFEST文件到JarLauncher的具体实现，让你清楚了解SpringBoot是如何启动的。

项目背景

本文作者小知在知乎上分享了关于SpringBoot启动机制的深刻见解，我们将基于这些见解进行详细解析。

MANIFEST.MF文件内容：

Manifest-Version: 1.0  
Implementation-Title: oneday-auth-server  
Implementation-Version: 1.0.0-SNAPSHOT  
Archiver-Version: Plexus Archiver  
Built-By: oneday  
Implementation-Vendor-Id: com.oneday  
Spring-Boot-Version: 2.1.3.RELEASE  
Main-Class: org.springframework.boot.loader.JarLauncher  
Start-Class: com.oneday.auth.Application  
Spring-Boot-Classes: BOOT-INF/classes/  
Spring-Boot-Lib: BOOT-INF/lib/  
Created-By: Apache Maven 3.3.9  
Build-Jdk: 1.8.0_171

从上述文件中，可以看到两个关键信息：Main-Class和Start-Class。它们分别指向
org.springframework.boot.loader.JarLauncher和
com.oneday.auth.Application。

解析启动流程

1. MANIFEST.MF文件解析

MANIFEST.MF文件是Java中jar包的重要配置文件，SpringBoot通过定制该文件，指定了自定义的启动类JarLauncher。

2. JarLauncher的工作原理

SpringBoot可执行jar包的启动并不是直接调用用户定义的main方法，而是通过JarLauncher进行二次调度。JarLauncher的 main 方法启动后，会通过反射机制调用Start-Class指定的main方法。

JarLauncher 核心代码：

package org.springframework.boot.loader;

public class JarLauncher extends Launcher {

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

    @Override
    protected String[] getArguments() {
        return super.getArguments();
    }

    @Override
    protected void launch(String[] args) throws Exception {
        String mainClass = getMainClass();
        ClassLoader classLoader = createClassLoader(getClassPathArchives());
        launch(mainClass, args, classLoader);
    }

    protected void launch(String mainClass, String[] args, ClassLoader classLoader) throws Exception {
        Thread.currentThread().setContextClassLoader(classLoader);
        Class appClass = classLoader.loadClass(mainClass);
        Method mainMethod = appClass.getDeclaredMethod("main", String[].class);
        mainMethod.invoke(null, (Object) args);
    }

    private String getMainClass() throws Exception {
        return "com.oneday.auth.Application";
    }
}

3. 自定义类加载器

JarLauncher通过自定义ClassLoader来加载SpringBoot应用的类和资源：

ClassLoader实现关键代码：

protected ClassLoader createClassLoader(List archives) throws Exception {
    URL[] urls = archives.stream().map(this::toUrl).toArray(URL[]::new);
    return new LaunchedURLClassLoader(urls, getClass().getClassLoader());
}

LaunchedURLClassLoader继承自URLClassLoader，负责加载jar包内的类和资源。

示例代码展示

1. 项目目录结构

src/main/
├── java/
│   └── com/oneday/auth/
│       └── Application.java
├── resources/
│   └── application.properties

2. Maven配置文件

    4.0.0
    com.oneday
    auth-server
    1.0.0-SNAPSHOT
    jar

    
        org.springframework.boot
        spring-boot-starter-parent
        2.1.3.RELEASE
        
    

    
        
            org.springframework.boot
            spring-boot-starter-web
        
    

    
        
            
                org.springframework.boot
                spring-boot-maven-plugin
            
        
    

3. 主应用程序代码

package com.oneday.auth;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Application {

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

总结

通过本文的深入解析，我们了解了SpringBoot可执行Jar包的启动流程，从MANIFEST.MF文件的配置到JarLauncher类的实现，再到自定义类加载器的工作机制。SpringBoot通过这些巧妙设计，实现了可执行Jar包的高效独立运行。

启示：理解这些内部机制，能够帮助开发者在构建SpringBoot应用时优化启动性能，排查启动问题，并实现更灵活的应用部署。如果你有更多关于SpringBoot的问题或见解，欢迎在评论区分享与讨论！