众所周知，Springboot的FAT JAR机制大大的简化了应用的打包和启动，并且统一了不同stack(command, web, batch)的打包和启动方法，使得一个应该的开发和部署都变得简单了，本文想在这里解析一下FAT JAR的方式下，Springboot的类加载机制。

Springboot FAT JAR的结构

我们知道Springboot提供了spring-boot-maven-plugin这个maven plugin在build时生成FAT jar，如果我们build了一个springboot的应用，去target folder下可以看见两个名字非常类似的文件: abc-0.0.1-SNAPSHOT.jar 和abc-0.0.1-SNAPSHOT.jar.original,这两个文件的大小相差非常明显，我们解压开.original文件可以发现如下结构，这个就是我们应用中所有本地文件（代码和资源文件），而不包含第三方的依赖等等。

如果我们解压打开abc-0.0.1-SNAPSHOT.jar (FAT JAR)，目录结构如下, 本地的文件都在BOOT-INF/classes下，但是还多了：
BOOT-INF/lib - 存放所有dependences的JAR
org/Springframework - 存放springboot相关的class

image.png

spring-boot-loader 做了什么

既然把所有的依赖，class和资源文件都包含在一个JAR内，那就必须要解决启动时如何去load这些claas和资源文件，为了一探究竟，我们需要把spring-boot-loader的source code拉下来，一个简单的方法就是把spring-boot-loader作为依赖加到应用的pom.xml中，当然scope可以设置成provided，因为FAT JAR中一定会包含这个依赖。

<dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-loader</artifactId>
      <scope>Provided</scope>
    </dependency>

这样我们就能很方便的拿到spring-boot-loader的source code。通过FAT JAR中的MANIFEST.MF，我们能快速找到真正的Springboot bootstrap方法应该是org.springframework.boot.loader.JarLauncher#main，真正的code在基类Launcher#launch中。

public abstract class Launcher {

    private static final String JAR_MODE_LAUNCHER = "org.springframework.boot.loader.jarmode.JarModeLauncher";

    /**
     * Launch the application. This method is the initial entry point that should be
     * called by a subclass {@code public static void main(String[] args)} method.
     * @param args the incoming arguments
     * @throws Exception if the application fails to launch
     */
    protected void launch(String[] args) throws Exception {
        if (!isExploded()) {
            JarFile.registerUrlProtocolHandler();
        }
        ClassLoader classLoader = createClassLoader(getClassPathArchivesIterator());
        String jarMode = System.getProperty("jarmode");
        String launchClass = (jarMode != null && !jarMode.isEmpty()) ? JAR_MODE_LAUNCHER : getMainClass();
        launch(args, launchClass, classLoader);
    }

可以发现这里创建了一个新的classloader - LaunchedURLClassLoader，具体是，

    protected ClassLoader createClassLoader(URL[] urls) throws Exception {
        return new LaunchedURLClassLoader(isExploded(), getArchive(), urls, getClass().getClassLoader());
    }

并把classload 加入thread 的context中。

protected void launch(String[] args, String launchClass, ClassLoader classLoader) throws Exception {
        Thread.currentThread().setContextClassLoader(classLoader);
        createMainMethodRunner(launchClass, args, classLoader).run();
    }

为什么需要LaunchedURLClassLoader呢？设想一下，现在FAT JAR中依赖的各个jar文件其实并不在运行时应用的classpath下，也就是根据类加载的双亲委派机制，这些依赖没办法被默认的任何一个classloader加载，Springboot为了解决这个问题，自定义了类加载机制。

P.S 不同的内置classloader的scope 如下：
Bootstrap ClassLoader（加载JDK的/lib目录下的类）
Extension ClassLoader（加载JDK的/lib/ext目录下的类）
Application ClassLoader（程序自己classpath下的类)

LaunchedURLClassLoader做了什么

LaunchedURLClassLoader继承了java.net.URLClassLoader，自己实现了loadClass方法。

@Override
    protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
        if (name.startsWith("org.springframework.boot.loader.jarmode.")) {
            try {
                Class<?> result = loadClassInLaunchedClassLoader(name);
                if (resolve) {
                    resolveClass(result);
                }
                return result;
            }
            catch (ClassNotFoundException ex) {
            }
        }
        if (this.exploded) {
            return super.loadClass(name, resolve);
        }
        Handler.setUseFastConnectionExceptions(true);
        try {
            try {
                definePackageIfNecessary(name);
            }
            catch (IllegalArgumentException ex) {
                // Tolerate race condition due to being parallel capable
                if (getPackage(name) == null) {
                    // This should never happen as the IllegalArgumentException indicates
                    // that the package has already been defined and, therefore,
                    // getPackage(name) should not return null.
                    throw new AssertionError("Package " + name + " has already been defined but it could not be found");
                }
            }
            return super.loadClass(name, resolve);
        }
        finally {
            Handler.setUseFastConnectionExceptions(false);
        }
    }

definePackageIfNecessary 确保了Jar in Jar里的class manifest能够和package关联起来。

private void definePackage(String className, String packageName) {
        try {
            AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {
                String packageEntryName = packageName.replace('.', '/') + "/";
                String classEntryName = className.replace('.', '/') + ".class";
                for (URL url : getURLs()) {
                    try {
                        URLConnection connection = url.openConnection();
                        if (connection instanceof JarURLConnection) {
                            JarFile jarFile = ((JarURLConnection) connection).getJarFile();
                            if (jarFile.getEntry(classEntryName) != null && jarFile.getEntry(packageEntryName) != null
                                    && jarFile.getManifest() != null) {
                                definePackage(packageName, jarFile.getManifest(), url);
                                return null;
                            }
                        }
                    }
                    catch (IOException ex) {
                        // Ignore
                    }
                }
                return null;
            }, AccessController.getContext());
        }
        catch (java.security.PrivilegedActionException ex) {
            // Ignore
        }
    }

可以看到最终load class还是调了super.loadClass，也就是java.lang.ClassLoader#loadClass，这其实又回到了双亲委派机制，最后让Application Classloader来load。

LaunchedURLClassLoader的作用是在FAT JAR(Jar in Jar)这样的目录结构中，能够找到要load的class(依赖中的类或者应用自己的类)，并且load他们。

我们看看这个class load是怎么load 我们在springboot应用中定义的main class，也就是应用的入口程序的。
在org.springframework.boot.loader.MainMethodRunner中，通过LaunchedURLClassLoader load并且通过反射调用了main 方法。

public void run() throws Exception {
        Class<?> mainClass = Class.forName(this.mainClassName, false, Thread.currentThread().getContextClassLoader());
        Method mainMethod = mainClass.getDeclaredMethod("main", String[].class);
        mainMethod.setAccessible(true);
        mainMethod.invoke(null, new Object[] { this.args });
    }

Java -Jar 和IDE里启动Sprintboot 有什么区别

Java -Jar是以FAT JAR的方式用LaunchedURLClassLoader来load class。而在IDE中则是直接以ApplicationClassLoader来load的。这种差别会导致调用classloader.getResourceAsStream()得到不一样的结果，这是因为FAT JAR启动时，LaunchedURLClassLoader的load的urls并没有FAT JAR本身，如abc-0.0.1-SNAPSHOT.jar, 但是应用中的src/main/resources/META-INF/resources目录被打包到了FAT JAR里，也就是abc-0.0.1-SNAPSHOT.jar!/META-INF/resources，这样这些resource也就不会被访问到了

这也就是为什么有时候在IDE里能读到的resource在Run FAT JAR的情况下读不到了，Springboot也给了多种方式来正确的load resource: https://www.baeldung.com/spring-load-resource-as-string