【源码分析】springboot具体启动过程

2019-10-28 本文已影响0人我不是刺猬_

1.将项目打包成jar包并运行

将应用打包成jar文件

在终端中运行./gradlew bootRun将应用打包成一个jar文件：demo-0.0.1-SNAPSHOT.jar

image.png

命令行运行一个jar项目
进入 jar文件所在目录，运行一下命令启动项目

java -jar demo-0.0.1-SNAPSHOT.jar

unzip demo-0.0.1-SNAPSHOT.jar

可以看到生成的jar包文件目录如下：

BOOT-INF
- classes
  - com
  - application.properties
- lib
META-INF
- MANIFEST.MF
org
注意：
BOOT-INF：该目录是项目代码，源代码，配置文件和依赖包，这个可以理解
META-INF：内容如下
image.png
meta一般都是项目元信息，表示项目版本，名称等 description信息。为什么会有这6个记录呢？先保留疑问。
org：顺着目录打开，可以看到该org目录是org.springframework.boot.loader下的包，解压缩后被放置到了jar包中。

疑问：回到上边疑问，Start-Class在项目我们知道是main方法所在类，但是Main-Class呢？JarLancher的作用又是干什么？字面意思感觉也是项目开始类的意思。以及另外两个属性path也有疑问。

2. spring boot项目启动源码分析

在idea中扩展包中找到spring-boot-loader包，打开JarLancher类，

/**
 * {@link Launcher} for JAR based archives. This launcher assumes that dependency jars are
 * included inside a {@code /BOOT-INF/lib} directory and that application classes are
 * included inside a {@code /BOOT-INF/classes} directory.
 *
 * @author Phillip Webb
 * @author Andy Wilkinson
 */
public class JarLauncher extends ExecutableArchiveLauncher {

    static final String BOOT_INF_CLASSES = "BOOT-INF/classes/";

    static final String BOOT_INF_LIB = "BOOT-INF/lib/";

    public JarLauncher() {
    }

    protected JarLauncher(Archive archive) {
        super(archive);
    }

    @Override
    protected boolean isNestedArchive(Archive.Entry entry) {
        if (entry.isDirectory()) {
            return entry.getName().equals(BOOT_INF_CLASSES);
        }
        return entry.getName().startsWith(BOOT_INF_LIB);
    }

    public static void main(String[] args) throws Exception {
        new JarLauncher().launch(args);
    }

}

分析： 该类继承了ExecutableArchiveLauncher抽象类，两个静态成员变量属性，原来jar包部分目录是JarLancher指定的，最后main方法，实际上是JarLancher对象将main方法的参数通过lanch方法加载。我们再往上看ExecutableArchiveLauncher抽象类，及跳转launch方法。

**
 * Base class for executable archive {@link Launcher}s.
 *
 * @author Phillip Webb
 * @author Andy Wilkinson
 */
public abstract class ExecutableArchiveLauncher extends Launcher {

    private final Archive archive;

    public ExecutableArchiveLauncher() {
        try {
            this.archive = createArchive();
        }
        catch (Exception ex) {
            throw new IllegalStateException(ex);
        }
    }

    protected ExecutableArchiveLauncher(Archive archive) {
        this.archive = archive;
    }

    protected final Archive getArchive() {
        return this.archive;
    }

    @Override
    protected String getMainClass() throws Exception {
        Manifest manifest = this.archive.getManifest();
        String mainClass = null;
        if (manifest != null) {
            mainClass = manifest.getMainAttributes().getValue("Start-Class");
        }
        if (mainClass == null) {
            throw new IllegalStateException(
                    "No 'Start-Class' manifest entry specified in " + this);
        }
        return mainClass;
    }

    @Override
    protected List<Archive> getClassPathArchives() throws Exception {
        List<Archive> archives = new ArrayList<>(
                this.archive.getNestedArchives(this::isNestedArchive));
        postProcessClassPathArchives(archives);
        return archives;
    }

    /**
     * Determine if the specified {@link JarEntry} is a nested item that should be added
     * to the classpath. The method is called once for each entry.
     * @param entry the jar entry
     * @return {@code true} if the entry is a nested item (jar or folder)
     */
    protected abstract boolean isNestedArchive(Archive.Entry entry);

    /**
     * Called to post-process archive entries before they are used. Implementations can
     * add and remove entries.
     * @param archives the archives
     * @throws Exception if the post processing fails
     */
    protected void postProcessClassPathArchives(List<Archive> archives) throws Exception {
    }

}

分析：该类也是继承一个Lancher的抽象类，launch（）方法就是在最顶层抽象类实现，查看该类的实现类，如下，这时候忽然明白，原来gradle 打包工具，jar包和war包是在这里定义的。

image.png

**
 * Base class for launchers that can start an application with a fully configured
 * classpath backed by one or more {@link Archive}s.
 *
 * @author Phillip Webb
 * @author Dave Syer
 */
public abstract class Launcher {

    /**
     * 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 {
        JarFile.registerUrlProtocolHandler();
        ClassLoader classLoader = createClassLoader(getClassPathArchives());
        launch(args, getMainClass(), classLoader);
    }

    /**
     * Create a classloader for the specified archives.
     * @param archives the archives
     * @return the classloader
     * @throws Exception if the classloader cannot be created
     */
    protected ClassLoader createClassLoader(List<Archive> archives) throws Exception {
        List<URL> urls = new ArrayList<>(archives.size());
        for (Archive archive : archives) {
            urls.add(archive.getUrl());
        }
        return createClassLoader(urls.toArray(new URL[0]));
    }

    /**
     * Create a classloader for the specified URLs.
     * @param urls the URLs
     * @return the classloader
     * @throws Exception if the classloader cannot be created
     */
    protected ClassLoader createClassLoader(URL[] urls) throws Exception {
        return new LaunchedURLClassLoader(urls, getClass().getClassLoader());
    }

    /**
     * Launch the application given the archive file and a fully configured classloader.
     * @param args the incoming arguments
     * @param mainClass the main class to run
     * @param classLoader the classloader
     * @throws Exception if the launch fails
     */
    protected void launch(String[] args, String mainClass, ClassLoader classLoader)
            throws Exception {
        Thread.currentThread().setContextClassLoader(classLoader);
        createMainMethodRunner(mainClass, args, classLoader).run();
    }

    /**
     * Create the {@code MainMethodRunner} used to launch the application.
     * @param mainClass the main class
     * @param args the incoming arguments
     * @param classLoader the classloader
     * @return the main method runner
     */
    protected MainMethodRunner createMainMethodRunner(String mainClass, String[] args,
            ClassLoader classLoader) {
        return new MainMethodRunner(mainClass, args);
    }

    /**
     * Returns the main class that should be launched.
     * @return the name of the main class
     * @throws Exception if the main class cannot be obtained
     */
    protected abstract String getMainClass() throws Exception;

    /**
     * Returns the archives that will be used to construct the class path.
     * @return the class path archives
     * @throws Exception if the class path archives cannot be obtained
     */
    protected abstract List<Archive> getClassPathArchives() throws Exception;

    protected final Archive createArchive() throws Exception {
        ProtectionDomain protectionDomain = getClass().getProtectionDomain();
        CodeSource codeSource = protectionDomain.getCodeSource();
        URI location = (codeSource != null) ? codeSource.getLocation().toURI() : null;
        String path = (location != null) ? location.getSchemeSpecificPart() : null;
        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));
    }

}

解析：launch（）中，ClassLoader classLoader = createClassLoader(getClassPathArchives()); 该行代码主要做的就是将类归档文件作为参数，并加载到类加载器中。

    @Override
    protected List<Archive> getClassPathArchives() throws Exception {
        List<Archive> archives = new ArrayList<>(
                this.archive.getNestedArchives(this::isNestedArchive));
        postProcessClassPathArchives(archives);
        return archives;
    }

解析:Archiev代表jar文件归档对象，此时就是获取嵌套的归档对象即我们的项目文件，然后作为classloader的参数。
我们看到spring-boot-loader并没有直接将jar包复制到目录中，因为jar打包规范是将所有的jar包都解压缩后，不允许嵌套，如果将class文件打包成一个jar文件，该方式的缺点是文件目录混乱，重名时就会进行覆盖。但是我们看到在项目源文件中，有lib目录，这些是spring boot通过classloader达到了目的。

protected void launch(String[] args) throws Exception {
        JarFile.registerUrlProtocolHandler();
        ClassLoader classLoader = createClassLoader(getClassPathArchives());
        launch(args, getMainClass(), classLoader);
    }

自定义类加载器加载BOOT-INF文件夹过程
1）getClassPathArchieves() 将子文件夹中的嵌套的jar文件获取到硬盘位置url
2）ClassLoader classLoader = createClassLoader(getClassPathArchives());装载到自定义类加载器中，返回jar文件的类加载器对象，具体过程如下：

将class文件url放置到一个array中。

protected ClassLoader createClassLoader(List<Archive> archives) throws Exception {
        List<URL> urls = new ArrayList<>(archives.size());
        for (Archive archive : archives) {
            urls.add(archive.getUrl());
        }
        return createClassLoader(urls.toArray(new URL[0]));
    }

createClassLoader负责通过url加载，进入到这个方法中，一个参数是我们的jar url，另一个是系统类加载器的class对象。真正加载的类加载器就是new LaunchedURLClassLoader()，再进入到这个方法

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

可以看到都是在调用系统类加载器,

public LaunchedURLClassLoader(URL[] urls, ClassLoader parent) {
        super(urls, parent);
    }
super进入：
   public URLClassLoader(URL[] urls, ClassLoader parent) {
        super(parent);
        // this is to make the stack depth consistent with 1.1
        SecurityManager security = System.getSecurityManager();
        if (security != null) {
            security.checkCreateClassLoader();
        }
        this.acc = AccessController.getContext();
        ucp = new URLClassPath(urls, acc);
    }
再进入super：
   protected SecureClassLoader(ClassLoader parent) {
        super(parent);
        // this is to make the stack depth consistent with 1.1
        SecurityManager security = System.getSecurityManager();
        if (security != null) {
            security.checkCreateClassLoader();
        }
        initialized = true;
    }
再进入super，最终是系统类加载器
 protected ClassLoader(ClassLoader parent) {
        this(checkCreateClassLoader(), parent);
    }

3）拿到加载class的classLoader对象后，下一步如何将这个加载器对象执行呢？就是第三行代码，launch（）方法
参数：args，MANIFEST.MF属性的·Start-Class·属性，即我们main方法入口类；自定义类加载器

    protected void launch(String[] args, String mainClass, ClassLoader classLoader):
            throws Exception {
        Thread.currentThread().setContextClassLoader(classLoader); ##这句话就是将类加载器替换为自定义类加载器
        createMainMethodRunner(mainClass, args, classLoader).run();
    }

获取到MANIFEST.MFStart-Class属性，作为main class参数，

    @Override
    protected String getMainClass() throws Exception {
        Manifest manifest = this.archive.getManifest();
        String mainClass = null;
        if (manifest != null) {
            mainClass = manifest.getMainAttributes().getValue("Start-Class");
        }
        if (mainClass == null) {
            throw new IllegalStateException(
                    "No 'Start-Class' manifest entry specified in " + this);
        }
        return mainClass;
    }

4）Thread.currentThread().setContextClassLoader(classLoader); 这句就是将类加载器替换为自定义类加载器

createMainMethodRunner(mainClass, args, classLoader).run();做了什么呢？主要在run方法。

MainMethodRunner只做了变量替换而已。

protected MainMethodRunner createMainMethodRunner(String mainClass, String[] args,
            ClassLoader classLoader) {
        return new MainMethodRunner(mainClass, args);
    }
public MainMethodRunner(String mainClass, String[] args) {
        this.mainClassName = mainClass;
        this.args = (args != null) ? args.clone() : null;
    }

run()：[重点] :可以看到spring boot通过自定义classloader后，在Thread中获取到，通过反射的方式来运行对应的“main”方法，这种巧妙的办法加载应用入口其实不叫“main”也可以，只要入口名对应就行，之所以取“main”，因此可以在IDE中通过run的方式运行，否则取其他名字则不能。

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

以上就是spring boot加载类的启动过程，这也就是为什么org下是将spring-boot-loader复制到了org文件夹下，不能嵌套jar文件，而BOOT-INF却可以，就是自定义了类加载器。

【源码分析】springboot具体启动过程

1.将项目打包成jar包并运行

2. spring boot项目启动源码分析

猜你喜欢

热点阅读