众所周知，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
目录结构有不少的变化，可以认为在执行spring-boot-maven-plugin后，abc-0.0.1-SNAPSHOT.jar.original被重新打包成了abc-0.0.1-SNAPSHOT.jar这个FAT JAR。
在BOOT-INF/lib下有一个dependency需要花功夫研究: spring-boot-loader，这个JAR保证了为什么通过java -jar命令能够执行FAT JAR从而启动Springboot应用。
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
