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

/**   * 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 {      //...  }

/**  * 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;

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

/**   * 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 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();  }

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