SpringBoot 类加载过程

1. Jar包目录分析

1.1 spring boot 2.0.0 项目打包成 jar后目录结构

├── META-INF
│   ├── MANIFEST.MF (Jar.Properties?)
├── BOOT-INF
│   ├── classes 项目源代码 
│   ├── lib  项目jar包
└── org
    └── springframework
        └── boot
            └── loader
                ├── ExecutableArchiveLauncher.class
                ├── JarLauncher.class
                ├── JavaAgentDetector.class
                ├── LaunchedURLClassLoader.class
                ├── Launcher.class
                ├── MainMethodRunner.class
                ├── ... 

1.2 MANIFEST.MF 文件

Manifest-Version: 1.0
Implementation-Title: TeamManager
Implementation-Version: 0.0.1-SNAPSHOT
Built-By: MRZhao
Implementation-Vendor-Id: com.zhao
Spring-Boot-Version: 2.0.0.RELEASE
//以jar包形式启动的主函数 主启动器
Main-Class: org.springframework.boot.loader.JarLauncher
//自己项目 Main函数入口
Start-Class: com.zhao.Application
Spring-Boot-Classes: BOOT-INF/classes/
Spring-Boot-Lib: BOOT-INF/lib/
Created-By: Apache Maven 3.3.3
Build-Jdk: 1.8.0_31
Implementation-URL: https://projects.spring.io/spring-boot/#/spring-bo
 ot-starter-parent/TeamManager

2.Archive的概念

1.Archive即归档文件，这个概念在linux下比较常见

2.Archive 略等价于 jar包或者文档目录的抽象

package org.springframework.boot.loader.archive;

public abstract interface Archive  extends Iterable{
  //返回此jar包的url(定位符)
  public abstract URL getUrl()
  //获取lib下/jar包列表
  public abstract Manifest getManifest()
   
  public abstract List getNestedArchives(EntryFilter paramEntryFilter)
  public static abstract interface EntryFilter {
    public abstract boolean matches(Archive.Entry paramEntry);
  }
    public static abstract interface Entry  {
    public abstract boolean isDirectory();
    public abstract String getName();
  }
}

3.JarLauncher

从MANIFEST.MF可以看到Main函数是JarLauncher，下面来分析它的工作流程。JarLauncher类的继承结构是：

class JarLauncher 
    extends ExecutableArchiveLauncher
class ExecutableArchiveLauncher 
    extends Launcher

以demo-0.0.1-SNAPSHOT.jar创建一个Archive：
JarLauncher先找到自己所在的jar，即demo-0.0.1-SNAPSHOT.jar的路径，然后创建了一个Archive。

下面的代码展示了如何从一个类找到它的加载的位置的技巧：

 protected final Archive createArchive() throws Exception {
        ProtectionDomain protectionDomain = getClass().getProtectionDomain();
        CodeSource codeSource = protectionDomain.getCodeSource();
        URI location = (codeSource == null ? null : codeSource.getLocation().toURI());
        String path = (location == null ? null : location.getSchemeSpecificPart());
        if (path == null) {
            throw new IllegalStateException("Unable to determine code source archive");
        }
        File root = new File(path);
        if (!root.exists()) {
            throw new IllegalStateException(
                    "Unable to determine code source archive from " + root);
        }
        return (root.isDirectory() ? new ExplodedArchive(root)
                : new JarFileArchive(root));
    }

获取lib/下面的jar，并创建一个LaunchedURLClassLoader
JarLauncher创建好Archive之后，通过getNestedArchives函数来获取到demo-0.0.1-SNAPSHOT.jar/lib下面的所有jar文件，并创建为List。

注意上面提到，Archive都是有自己的URL的。

获取到这些Archive的URL之后，也就获得了一个URL[]数组，用这个来构造一个自定义的ClassLoader：LaunchedURLClassLoader。

创建好ClassLoader之后，再从MANIFEST.MF里读取到Start-Class，即com.example.SpringBootDemoApplication，然后创建一个新的线程来启动应用的Main函数。

  /**
     * Launch the application given the archive file and a fully configured classloader.
     */
    protected void launch(String[] args, String mainClass, ClassLoader classLoader)
            throws Exception {
        Runnable runner = createMainMethodRunner(mainClass, args, classLoader);
        Thread runnerThread = new Thread(runner);
        runnerThread.setContextClassLoader(classLoader);
        runnerThread.setName(Thread.currentThread().getName());
        runnerThread.start();
    }

    /**
     * Create the {@code MainMethodRunner} used to launch the application.
     */
    protected Runnable createMainMethodRunner(String mainClass, String[] args,
            ClassLoader classLoader) throws Exception {
        Class runnerClass = classLoader.loadClass(RUNNER_CLASS);
        Constructor constructor = runnerClass.getConstructor(String.class,
                String[].class);
        return (Runnable) constructor.newInstance(mainClass, args);
    }

LaunchedURLClassLoader

LaunchedURLClassLoader和普通的URLClassLoader的不同之处是，它提供了从Archive里加载.class的能力。

结合Archive提供的getEntries函数，就可以获取到Archive里的Resource。当然里面的细节还是很多的，下面再描述。

spring boot应用启动流程总结

看到这里，可以总结下Spring Boot应用的启动流程：

1. spring boot应用打包之后，生成一个fat jar，里面包含了应用依赖的jar包，还有Spring boot loader相关的类
2. Fat jar的启动Main函数是JarLauncher，它负责创建一个LaunchedURLClassLoader来加载/lib下面的jar，并以一个新线程启动应用的Main函数。