SpringBoot為啥不用配置啟動類

前言

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

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

Vert.x要怎麼配？

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

1）引入maven-shade-plugin插件

2）在插件中指定在package完成時觸發shade操作

3）指定啟動類

<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>

效果：

執行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 layout=NONE 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.

@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 Andy Wilkinson

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

原文位址

https://www.cnblogs.com/longfurcat/p/12643878.html

SpringBoot為啥不用配置啟動類

繼續閱讀

27 Best Free Eclipse Plug-ins for Java Developer to be ProductiveCode Quality PluginsText Editor PluginsDependency ManagementVersion Control Integration PluginsFramework Development Continuous Integration Related PluginsOther Utility Plugins

Java String.format方法的簡單使用

android 主線程的相關問題

neo4j之cypher使用文檔

GitHub連夜封殺！這份阿裡 10W 字内部 Java 字面試手冊到底有多強？

spark/scala關于【資源檔案】加載方法概述外部檔案加載方案測試資源檔案打包入jar包中小結

mybatis_入門程式Mybatis入門

maven No compiler is provided in this environment. Perhaps you are running on a JRE rather than a J

AOP程式設計_Android優雅權限架構(1)概念基礎，2021金三銀四前言正文大綱正文

Effective Java 8:通用程式設計

OOM三種類型

工廠模式-三種類型

【遞歸】高效率求2的n次幂

win10本地scala和spark安裝安裝scala安裝spark

scala (3) Function 和 Method

Opendaylight課堂之深度剖析toaster（一）