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

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

/**
 * 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)); //注意這里有一個(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();
}

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

}
//...