前言

在學習SparkJava、Vert.x等輕量級Web框架的時候，都遇到過打包問題，這兩個框架打包的時候都需要新增額外的Maven配置，並指定啟動類才能得到可執行的JAR包；

而springboot專案，似乎都不需要額外的配置，直接package就可以得到可執行的JAR包，這是怎麼回事呢？

Vert.x要怎麼配？

我們先來看看，Vert.x打包做哪些配置

1）引入maven-shade-plugin外掛

2）在外掛中指定在package完成時觸發shade操作

3）指定啟動類

<plugin>
    <artifactId>maven-shade-plugin</artifactId>
    <version>3.1.0</version>
    <executions>
        <execution>
            <!--在mvn package完成時觸發-->
            <phase>package</phase>
            <!--執行shade操作-->
            <goals>
                <goal>shade</goal>
            </goals>
            <configuration>
                <transformers>
                    <transformer
                         implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                        <manifestEntries>
                            <!--指定啟動類-->
                            <main-class>com.test.Starter</main-class>
                        </manifestEntries>
                    </transformer>
                </transformers>
                <artifactSet/>
            </configuration>
        </execution>
    </executions>
</plugin>

效果：

執行package操作後，將得到兩個jar包

①origin-[your project].jar（Maven預設打包操作得到的jar包，該包僅包含此專案的類）

②[your project].jar（帶有依賴包，且配置有啟動類的可執行JAR包）

Spring Boot又是怎麼做的

不用新增外掛？=> 初始化時預設就有

Spring Boot 初始化得到的專案中，預設帶有spring-boot-maven-plugin的Maven配置

SpringBoot打包的基本原理與前面的Vertx配置相同，都是使用maven-shade-plugin（spring-boot-maven-plugin底層使用maven-shade-plugin），在package完成之後，加入依賴的包，並指定啟動類。

SpringBoot是在package時，觸發repackage，將原打包結果重新命名為[your project].jar.original，並得到帶有依賴包和配置好啟動類的[your project].jar

不用指定啟動類？=> 預設掃描得到啟動類

spring-boot-maven-plugin會掃描專案，並以帶有@SpringBootApplication註解和main方法的類作為啟動類。

預設情況下，SpringBoot專案預設啟動類寫死JarLauncher，該類的main方法再呼叫掃描得到的實際啟動類（XXXApplication）的main方法

原始碼檢視

我們從maven repository下載一個spring-boot-maven-plugin的原始碼進行檢視，檢視RepackageMojo.java。

從@Mojo註解中，我們可以知道，該Mojo繫結在PACKAGE（註解中的defaultPhase=LifecyclePhase.PACKAGE），即在package完成後觸發

/**
 * Repackages existing JAR and WAR archives so that they can be executed from the command
 * line using {@literal java -jar}. With <code>layout=NONE</code> can also be used simply
 * to package a JAR with nested dependencies (and no main class, so not executable).
 *
 * @author Phillip Webb
 * @author Dave Syer
 * @author Stephane Nicoll
 * @author Björn Lindström
 * @since 1.0.0
 */
@Mojo(name = "repackage", defaultPhase = LifecyclePhase.PACKAGE, requiresProject = true, threadSafe = true,
        requiresDependencyResolution = ResolutionScope.COMPILE_PLUS_RUNTIME,
        requiresDependencyCollection = ResolutionScope.COMPILE_PLUS_RUNTIME)
public class RepackageMojo extends AbstractDependencyFilterMojo {
    //...
}

我們可以看到，該Mojo中可以指定一個mainclass作為啟動類，但是如果沒有指定的時候，它是如何處理的呢？

/**
* The name of the main class. If not specified the first compiled class found that
* contains a 'main' method will be used.
* @since 1.0.0
*/
@Parameter
private String mainClass;

我們跟蹤這個mainClass，發現在此類中，沒有對這個mainClass進行賦值的操作，只用來構造一個Repackager（也就是說在該Maven外掛沒有配置mainClass的時候，傳給Repackager的就是一個null），我們觀察到這個Repackager就是該Mojo執行

@Override
public void execute() throws MojoExecutionException, MojoFailureException {
    if (this.project.getPackaging().equals("pom")) {
        getLog().debug("repackage goal could not be applied to pom project.");
        return;
    }
    if (this.skip) {
        getLog().debug("skipping repackaging as per configuration.");
        return;
    }
    repackage();
}

private void repackage() throws MojoExecutionException {
    Artifact source = getSourceArtifact();
    File target = getTargetFile();
    Repackager repackager = getRepackager(source.getFile());
    Set<Artifact> artifacts = filterDependencies(this.project.getArtifacts(), getFilters(getAdditionalFilters()));
    Libraries libraries = new ArtifactsLibraries(artifacts, this.requiresUnpack, getLog());
    try {
        LaunchScript launchScript = getLaunchScript();
        repackager.repackage(target, libraries, launchScript); //執行repackage操作
    }
    catch (IOException ex) {
        throw new MojoExecutionException(ex.getMessage(), ex);
    }
    updateArtifact(source, target, repackager.getBackupFile());
}

private Repackager getRepackager(File source) {
    Repackager repackager = new Repackager(source, this.layoutFactory);
    repackager.addMainClassTimeoutWarningListener(new LoggingMainClassTimeoutWarningListener());
    repackager.setMainClass(this.mainClass); //將外掛配置的mainClass注入，預設就是null
    if (this.layout != null) {
        getLog().info("Layout: " + this.layout);
        repackager.setLayout(this.layout.layout());
    }
    return repackager;
}

由上可知，mainClass的最終確定，應該在Repackager的中完成，我繼續跟蹤該程式碼（Repackager來自spring-boot-maven-plugin下引入的spring-boot-loader-tools），開啟Repackager的程式碼。我們觀察到Repackager的setMainClass並沒有做額外的操作，只是將傳入的引數set進來，但是從註釋中可以得知，其在使用時如果為空，則會搜尋合適的類作為MainClass

/**
 * Utility class that can be used to repackage an archive so that it can be executed using
 * '{@literal java -jar}'.
 *
 * @author Phillip Webb
 * @author Andy Wilkinson
 * @author Stephane Nicoll
 * @since 1.0.0
 */
public class Repackager {
    //...

    /**
     * Sets the main class that should be run. If not specified the value from the
     * MANIFEST will be used, or if no manifest entry is found the archive will be
     * searched for a suitable class.
     * @param mainClass the main class name
     */
    public void setMainClass(String mainClass) {
        this.mainClass = mainClass;
    }

    //...

}

我們就從上面呼叫repackage方法開始看

/**
 * Repackage to the given destination so that it can be launched using '
 * {@literal java -jar}'.
 * @param destination the destination file (may be the same as the source)
 * @param libraries the libraries required to run the archive
 * @param launchScript an optional launch script prepended to the front of the jar
 * @throws IOException if the file cannot be repackaged
 * @since 1.3.0
 */
public void repackage(File destination, Libraries libraries, LaunchScript launchScript) throws IOException {
    if (destination == null || destination.isDirectory()) {
        throw new IllegalArgumentException("Invalid destination");
    }
    if (libraries == null) {
        throw new IllegalArgumentException("Libraries must not be null");
    }
    if (this.layout == null) {
        this.layout = getLayoutFactory().getLayout(this.source);
    }
    destination = destination.getAbsoluteFile();
    File workingSource = this.source;
    if (alreadyRepackaged() && this.source.equals(destination)) {
        return;
    }
    if (this.source.equals(destination)) {
        workingSource = getBackupFile();
        workingSource.delete();
        renameFile(this.source, workingSource);
    }
    destination.delete();
    try {
        try (JarFile jarFileSource = new JarFile(workingSource)) {
            repackage(jarFileSource, destination, libraries, launchScript); //這裡往下檢視
        }
    }
    finally {
        if (!this.backupSource && !this.source.equals(workingSource)) {
            deleteFile(workingSource);
        }
    }
}

private void repackage(JarFile sourceJar, File destination, Libraries libraries, LaunchScript launchScript)
        throws IOException {
    WritableLibraries writeableLibraries = new WritableLibraries(libraries);
    try (JarWriter writer = new JarWriter(destination, launchScript)) {
        writer.writeManifest(buildManifest(sourceJar)); //注意這裡有一個buildManifest
        writeLoaderClasses(writer);
        if (this.layout instanceof RepackagingLayout) {
            writer.writeEntries(sourceJar,
                    new RenamingEntryTransformer(((RepackagingLayout) this.layout).getRepackagedClassesLocation()),
                    writeableLibraries);
        }
        else {
            writer.writeEntries(sourceJar, writeableLibraries);
        }
        writeableLibraries.write(writer);
    }
}

private Manifest buildManifest(JarFile source) throws IOException {
    Manifest manifest = source.getManifest();
    if (manifest == null) {
        manifest = new Manifest();
        manifest.getMainAttributes().putValue("Manifest-Version", "1.0"); 
    }
    manifest = new Manifest(manifest);
    String startClass = this.mainClass; //mainClass
    if (startClass == null) {
        startClass = manifest.getMainAttributes().getValue(MAIN_CLASS_ATTRIBUTE); //先嚐試從mainfest中拿，這個暫時不清楚資料來源
    }
    if (startClass == null) {
        startClass = findMainMethodWithTimeoutWarning(source); //這裡觸發搜尋mainClass
    }
    String launcherClassName = this.layout.getLauncherClassName();
    if (launcherClassName != null) {
        manifest.getMainAttributes().putValue(MAIN_CLASS_ATTRIBUTE, launcherClassName);
        if (startClass == null) {
            throw new IllegalStateException("Unable to find main class");
        }
        manifest.getMainAttributes().putValue(START_CLASS_ATTRIBUTE, startClass);
    }
    else if (startClass != null) {
        manifest.getMainAttributes().putValue(MAIN_CLASS_ATTRIBUTE, startClass);
    }
    String bootVersion = getClass().getPackage().getImplementationVersion();
    manifest.getMainAttributes().putValue(BOOT_VERSION_ATTRIBUTE, bootVersion);
    manifest.getMainAttributes().putValue(BOOT_CLASSES_ATTRIBUTE, (this.layout instanceof RepackagingLayout)
            ? ((RepackagingLayout) this.layout).getRepackagedClassesLocation() : this.layout.getClassesLocation());
    String lib = this.layout.getLibraryDestination("", LibraryScope.COMPILE);
    if (StringUtils.hasLength(lib)) {
        manifest.getMainAttributes().putValue(BOOT_LIB_ATTRIBUTE, lib);
    }
    return manifest;
}

private String findMainMethodWithTimeoutWarning(JarFile source) throws IOException {
    long startTime = System.currentTimeMillis();
    String mainMethod = findMainMethod(source); //這裡往下看
    long duration = System.currentTimeMillis() - startTime;
    if (duration > FIND_WARNING_TIMEOUT) {
        for (MainClassTimeoutWarningListener listener : this.mainClassTimeoutListeners) {
            listener.handleTimeoutWarning(duration, mainMethod);
        }
    }
    return mainMethod;
}

protected String findMainMethod(JarFile source) throws IOException {
    return MainClassFinder.findSingleMainClass(source, this.layout.getClassesLocation(),
            SPRING_BOOT_APPLICATION_CLASS_NAME); //在指定Jar檔案中查詢MainClass
}

private static final String SPRING_BOOT_APPLICATION_CLASS_NAME = "org.springframework.boot.autoconfigure.SpringBootApplication";

/**
 * Find a single main class in a given jar file. A main class annotated with an
 * annotation with the given {@code annotationName} will be preferred over a main
 * class with no such annotation.
 * @param jarFile the jar file to search
 * @param classesLocation the location within the jar containing classes
 * @param annotationName the name of the annotation that may be present on the main
 * class
 * @return the main class or {@code null}
 * @throws IOException if the jar file cannot be read
 */
public static String findSingleMainClass(JarFile jarFile, String classesLocation, String annotationName)
        throws IOException {
    SingleMainClassCallback callback = new SingleMainClassCallback(annotationName);
    MainClassFinder.doWithMainClasses(jarFile, classesLocation, callback);
    return callback.getMainClassName();
}

從最後幾步中，我們可以知道，查詢的mainClass是一個帶有@SpringBootApplication註解的類。不用說明，該類肯定是帶有main方法，如果你想進一步確認，則可以繼續檢視MainClassFinder的程式碼（來自spring-boot-loader-tools）。

//...
private static final Type MAIN_METHOD_TYPE = Type.getMethodType(Type.VOID_TYPE, STRING_ARRAY_TYPE);

private static final String MAIN_METHOD_NAME = "main";

private static class ClassDescriptor extends ClassVisitor {

    private final Set<String> annotationNames = new LinkedHashSet<>();

    private boolean mainMethodFound;

    ClassDescriptor() {
        super(SpringAsmInfo.ASM_VERSION);
    }

    @Override
    public AnnotationVisitor visitAnnotation(String desc, boolean visible) {
        this.annotationNames.add(Type.getType(desc).getClassName());
        return null;
    }

    @Override
    public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) {
        //如果訪問方式是public static 且 方法名為 main 且 返回值為 void，則認定該類含有main方法
        if (isAccess(access, Opcodes.ACC_PUBLIC, Opcodes.ACC_STATIC) && MAIN_METHOD_NAME.equals(name) 
                && MAIN_METHOD_TYPE.getDescriptor().equals(desc)) {
            this.mainMethodFound = true;
        }
        return null;
    }

    private boolean isAccess(int access, int... requiredOpsCodes) {
        for (int requiredOpsCode : requiredOpsCodes) {
            if ((access & requiredOpsCode) == 0) {
                return false;
            }
        }
        return true;
    }

    boolean isMainMethodFound() {
        return this.mainMethodFound;
    }

    Set<String> getAnnotationNames() {
        return this.annotationNames;
    }

}
//...

&n