前言

在學(xué)習(xí)SparkJava、Vert.x等輕量級(jí)Web框架的時(shí)候，都遇到過打包問題，這兩個(gè)框架打包的時(shí)候都需要添加額外的Maven配置，并指定啟動(dòng)類才能得到可執(zhí)行的JAR包；

而springboot項(xiàng)目，似乎都不需要額外的配置，直接package就可以得到可執(zhí)行的JAR包，這是怎么回事呢？

Vert.x要怎么配？

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

1）引入maven-shade-plugin插件

2）在插件中指定在package完成時(shí)觸發(fā)shade操作

3）指定啟動(dòng)類

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

效果：

執(zhí)行package操作后，將得到兩個(gè)jar包

①origin-[your project].jar（Maven默認(rèn)打包操作得到的jar包，該包僅包含此項(xiàng)目的類）

②[your project].jar（帶有依賴包，且配置有啟動(dòng)類的可執(zhí)行JAR包）

Spring Boot又是怎么做的

不用添加插件？=> 初始化時(shí)默認(rèn)就有

Spring Boot 初始化得到的項(xiàng)目中，默認(rèn)帶有spring-boot-maven-plugin的Maven配置

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

SpringBoot是在package時(shí)，觸發(fā)repackage，將原打包結(jié)果重命名為[your project].jar.original，并得到帶有依賴包和配置好啟動(dòng)類的[your project].jar

不用指定啟動(dòng)類？=> 默認(rèn)掃描得到啟動(dòng)類spring-boot-maven-plugin會(huì)掃描項(xiàng)目，并以帶有@SpringBootApplication注解和main方法的類作為啟動(dòng)類。

默認(rèn)情況下，SpringBoot項(xiàng)目默認(rèn)啟動(dòng)類寫死JarLauncher，該類的main方法再調(diào)用掃描得到的實(shí)際啟動(dòng)類（XXXApplication）的main方法

源碼查看我們從maven repository下載一個(gè)spring-boot-maven-plugin的源碼進(jìn)行查看，查看RepackageMojo.java。

從@Mojo注解中，我們可以知道，該Mojo綁定在PACKAGE（注解中的defaultPhase=LifecyclePhase.PACKAGE），即在package完成后觸發(fā)

/** * 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中可以指定一個(gè)mainclass作為啟動(dòng)類，但是如果沒有指定的時(shí)候，它是如何處理的呢？

/*** 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*/@Parameterprivate String mainClass;

我們跟蹤這個(gè)mainClass，發(fā)現(xiàn)在此類中，沒有對(duì)這個(gè)mainClass進(jìn)行賦值的操作，只用來構(gòu)造一個(gè)Repackager（也就是說在該Maven插件沒有配置mainClass的時(shí)候，傳給Repackager的就是一個(gè)null），我們觀察到這個(gè)Repackager就是該Mojo執(zhí)行

@Overridepublic 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); //執(zhí)行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注入，默認(rèn)就是null if (this.layout != null) { getLog().info('Layout: ' + this.layout); repackager.setLayout(this.layout.layout()); } return repackager;}

由上可知，mainClass的最終確定，應(yīng)該在Repackager的中完成，我繼續(xù)跟蹤該代碼（Repackager來自spring-boot-maven-plugin下引入的spring-boot-loader-tools），打開Repackager的代碼。我們觀察到Repackager的setMainClass并沒有做額外的操作，只是將傳入的參數(shù)set進(jìn)來，但是從注釋中可以得知，其在使用時(shí)如果為空，則會(huì)搜索合適的類作為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; } //...}

我們就從上面調(diào)用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)); //注意這里有一個(gè)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中拿，這個(gè)暫時(shí)不清楚數(shù)據(jù)來源 } if (startClass == null) { startClass = findMainMethodWithTimeoutWarning(source); //這里觸發(fā)搜索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是一個(gè)帶有@SpringBootApplication注解的類。不用說明，該類肯定是帶有main方法，如果你想進(jìn)一步確認(rèn)，則可以繼續(xù)查看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，則認(rèn)定該類含有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; }}//...

到此這篇關(guān)于SpringBoot為啥不用配置啟動(dòng)類的實(shí)現(xiàn)的文章就介紹到這了,更多相關(guān)SpringBoot 啟動(dòng)類內(nèi)容請(qǐng)搜索好吧啦網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持好吧啦網(wǎng)！