前言
在學習SparkJava、Vert.x等輕量級Web架構的時候，都遇到過打包問題，這兩個架構打包的時候都需要添加額外的Maven配置，并指定啟動類才能得到可執行的JAR包；
而springboot項目，似乎都不需要額外的配置，直接package就可以得到可執行的JAR包，這是怎麼回事呢？
Vert.x要怎麼配？
我們先來看看，Vert.x打包做哪些配置
1)引入maven-shade-plugin插件
2)在插件中指定在package完成時觸發shade操作
3)指定啟動類
maven-shade-plugin
3.1.0
package
shade
implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
com.test.Starter
效果：
執行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完成後觸發
@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作為啟動類，但是如果沒有指定的時候，它是如何處理的呢？
@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 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
public class Repackager {
//...
public void setMainClass(String mainClass) {
this.mainClass = mainClass;
}
//...
}
我們就從上面調用repackage方法開始看
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";
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 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 getAnnotationNames() {
return this.annotationNames;
}
}
//...
到此這篇關于SpringBoot為啥不用配置啟動類的實作的文章就介紹到這了,更多相關SpringBoot 啟動類内容請搜尋腳本之家以前的文章或繼續浏覽下面的相關文章希望大家以後多多支援腳本之家！