【Spring boot】启动过程源码分析_bootstrapregistryinitializer applicationcontextini

启动过程结论

• 推测web应用类型。
• spi的方式获取BootstrapRegistryInitializer、ApplicationContextInitializer、ApplicationContextInitializer对象。
• 通过调用栈推测出main()方法所在的类。
• 调用启动方法：run(String… args)。后面的步骤在这个方法内部！
• 触发SpringApplicationRunListener的starting()。
• 创建Environment对象。
• 触发SpringApplicationRunListener的environmentPrepared()。
• 打印Banner。
• 创建Spring容器对象（ApplicationContext）。
• 利用ApplicationContextInitializer初始化Spring容器对象。
• 触发SpringApplicationRunListener的contextPrepared()。
• 调用DefaultBootstrapContext对象的close()。
• 将启动类作为配置类注册到Spring容器中（load()方法）。
• 触发SpringApplicationRunListener的contextLoaded()。
• 刷新Spring容器。
• 触发SpringApplicationRunListener的started()。
• 调用ApplicationRunner和CommandLineRunner。
• 触发SpringApplicationRunListener的ready()。
• 上述过程抛异常了就触发SpringApplicationRunListener的failed()。

入口位置

• 第一步构造对象：new SpringApplication(primarySources)
• 第二步调用SpringApplication.run(String… args)

// 我们自己写的main方法
@SpringBootApplication
public class ZfcqApp {
    public static void main(String[] args) {
        SpringApplication.run(ZfcqApp.class, args);
    }
}

/**
 * 他会调用SpringApplication的run方法
 * primarySource：我们传入的类的class
 * args：我们传入的参数，一般是启动的时候-D制定的参数
 */
public static ConfigurableApplicationContext run(Class<?> primarySource, String... args) {
    return run(new Class<?>[] { primarySource }, args);
}

/**
 * 继续看内部调用的run方法
 */
public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {
    // 俩步，第一步构造对象：new SpringApplication(primarySources)
    // 第二步调用SpringApplication.run(String... args)
    // 这里我们可以在main方法中分开俩步去写，从而可以在中间设置SpringApplication对象的信息
    return new SpringApplication(primarySources).run(args);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

构造SpringApplication源码分析

/**
 * 调用俩个参数的构造方法
 * primarySources：我们主类的class
 */
public SpringApplication(Class<?>... primarySources) {
    this(null, primarySources);
}

/**
 * 俩个产生的构造方法
 */
public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
    // 赋值到全局，这里第一次传入的是null
    this.resourceLoader = resourceLoader;
    // 主类存在的判断
    Assert.notNull(primarySources, "PrimarySources must not be null");
    // 赋值到全局，这里一般传入的是我们的main方法的类
    this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));

    // 推测WEB应用的类型（NONE、SERVLET、REACTIVE）
    this.webApplicationType = WebApplicationType.deduceFromClasspath();

    // 从spring.factories中获取BootstrapRegistryInitializer对象的值
    this.bootstrapRegistryInitializers = new ArrayList<>(getSpringFactoriesInstances(BootstrapRegistryInitializer.class));

    // 从spring.factories中获取ApplicationContextInitializer对象的值
    setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));

    // 从spring.factories中获取ApplicationListener对象的值。非常重要的有一个是EnvironmentPostProcessorApplicationListener
    setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));

    // 推测出main方法所在的类！SpringApplication.run(ZfcqApp.class, args);可以传任意的类！
    this.mainApplicationClass = deduceMainApplicationClass();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

推测web应用类型

• REACTIVE：web应用。
• NONE：无Servlet，不是web应用。
• SERVLET：除去上面俩种的其他应用。

static WebApplicationType deduceFromClasspath() {
    // 如果项目依赖中存在org.springframework.web.reactive.DispatcherHandler，并且不存在org.springframework.web.servlet.DispatcherServlet，那么应用类型为WebApplicationType.REACTIVE
    if (ClassUtils.isPresent(WEBFLUX_INDICATOR_CLASS, null) && !ClassUtils.isPresent(WEBMVC_INDICATOR_CLASS, null) && !ClassUtils.isPresent(JERSEY_INDICATOR_CLASS, null)) {
        return WebApplicationType.REACTIVE;
    }
    // 如果项目依赖中不存在org.springframework.web.reactive.Dispatche#rHandler，也不存在org.springframework.web.servlet.DispatcherServlet，那么应用类型为WebApplicationType.NONE
    for (String className : SERVLET_INDICATOR_CLASSES) {
        if (!ClassUtils.isPresent(className, null)) {
            return WebApplicationType.NONE;
        }
    }
    // 否则，应用类型为WebApplicationType.SERVLET
    return WebApplicationType.SERVLET;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

推测出Main类（main()方法所在的类）

• 从调用栈中去获取main类！

private Class<?> deduceMainApplicationClass() {
    try {
        // 获取调用栈数组
        StackTraceElement[] stackTrace = new RuntimeException().getStackTrace();
        // 找到调用栈中的main方法！
        for (StackTraceElement stackTraceElement : stackTrace) {
            if ("main".equals(stackTraceElement.getMethodName())) {
                return Class.forName(stackTraceElement.getClassName());
            }
        }
    }
    catch (ClassNotFoundException ex) {
        // Swallow and continue
    }
    return null;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

核心的启动方法：run(String… args)

public ConfigurableApplicationContext run(String... args) {
    // 开始时间
    long startTime = System.nanoTime();

    // 创建引导启动器，类似一个ApplicationContext，可以往里面添加一些对象。
    DefaultBootstrapContext bootstrapContext = createBootstrapContext();

    // spring容器对象，开始的时候为空
    ConfigurableApplicationContext context = null;
    // 与awt有关，一般用不上
    configureHeadlessProperty();

    // spring boot的启动监听器
    // 从spring.factories中获取SpringApplicationRunListener对象的值
    // 默认会拿到EventPublishingRunListener，他会启动各个地方的ApplicationEvent事件。
    SpringApplicationRunListeners listeners = getRunListeners(args);

    // 发布开始启动的事件：ApplicationstartingEvent
    listeners.starting(bootstrapContext, this.mainApplicationClass);
    try {
        // 把run方法的参数进行封装
        ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);

        // 准备environment对象：包括操作系统、jvm、ymal、properties....配置
        // 发布一个ApplicationEnvironmentPreparedEvent事件。
        ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, applicationArguments);

        // 默认spring.beaninfo.ignore为true，表示不需要jdk去缓存BeanInfo信息，spring自己缓存。
        // 这里是spring在创建bean的时候会利用jdk的一些工具来解析一个类的相关信息，jdk在解析一个类的信息的时候会进行缓存，这里就是禁止了jdk的缓存。
        configureIgnoreBeanInfo(environment);

        // 打印Banner
        Banner printedBanner = printBanner(environment);

        // 根据应用类型，创建spring容器
        context = createApplicationContext();
        // jdk9的一个机制，默认没做任何操作
        context.setApplicationStartup(this.applicationStartup);

        // 准备容器的操作
        // 利用ApplicationContextInitializer初始化spring容器
        // 发布ApplicationContextInitializedEvent（容器初始化完成）事件
        // 发布BootstrapContextClosedEvent（关闭引导容器）事件
        // 注册primarySources类（run方法存进来的配置类）
        // 发布ApplicationPreparedEvent事件
        prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);

        // refresh容器：解析配置类、扫描、启动webServer。spring相关的逻辑！
        refreshContext(context);

        // 空方法，类似spring的onRefresh方法，可以由子类实现。
        afterRefresh(context, applicationArguments);

        // 启动的事件
        Duration timeTakenToStartup = Duration.ofNanos(System.nanoTime() - startTime);
        if (this.logStartupInfo) {
            new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), timeTakenToStartup);
        }

        // 发布一个ApplicationStartedEvent事件，表示spring已经启动完成
        listeners.started(context, timeTakenToStartup);

        // 从spring容器中获取ApplicationRunner和CommandLineRunner，并执行他的run方法。
        // 这俩个可以自己定义Bean
        callRunners(context, applicationArguments);
    }
    catch (Throwable ex) {
        // 失败之后，发布一个失败的事件：ApplicationFailedEvent
        handleRunFailure(context, ex, listeners);
        throw new IllegalStateException(ex);
    }
    try {
        // 计算下事件
        Duration timeTakenToReady = Duration.ofNanos(System.nanoTime() - startTime);

        // 一切都成功，发布ApplicationStartedEvent事件
        listeners.ready(context, timeTakenToReady);
    }
    catch (Throwable ex) {
        // 失败之后，发布一个失败的事件：ApplicationFailedEvent
        handleRunFailure(context, ex, null);
        throw new IllegalStateException(ex);
    }
    return context;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

创建引导启动器

private DefaultBootstrapContext createBootstrapContext() {
    // 构建一个DefaultBootstrapContext对象，这个对象是2.4.0之后才会有！
    DefaultBootstrapContext bootstrapContext = new DefaultBootstrapContext();
    // 利用bootstrapRegistryInitializers初始化bootstrapContext。可以在spring.factories中设置bootstrapRegistryInitializers
    this.bootstrapRegistryInitializers.forEach((initializer) -> initializer.initialize(bootstrapContext));
    return bootstrapContext;
}
1
2
3
4
5
6
7

准备environment

private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners, DefaultBootstrapContext bootstrapContext, ApplicationArguments applicationArguments) {
    // Create and configure the environment   这句话是源码中本身的注释！
    // 创建ApplicationServletEnvironment。
    ConfigurableEnvironment environment = getOrCreateEnvironment();

    // 添加SimpleCommandLinePropertySource放在首位
    configureEnvironment(environment, applicationArguments.getSourceArgs());

    // 把所有的PropertySource封装为ConfigurationPropertySourcesPropertySource，然后添加到environment中，放在首位！
    ConfigurationPropertySources.attach(environment);

    // 发布ApplicationEnvironmentPreparedEvent（应用Environment准备完成）事件，表示环境已经准备好了。默认EnvironmentPostProcessorApplicationListener去处理这个事件！
    listeners.environmentPrepared(bootstrapContext, environment);

    // 把DefaultProperties放到最后
    DefaultPropertiesPropertySource.moveToEnd(environment);

    // 环境中spring.main.environment-prefix参数校验
    Assert.state(!environment.containsProperty("spring.main.environment-prefix"), "Environment prefix cannot be set via properties.");

    // 环境中spring.main参数校验
    bindToSpringApplication(environment);
    if (!this.isCustomEnvironment) {
        environment = convertEnvironment(environment);
    }
    ConfigurationPropertySources.attach(environment);
    return environment;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

准备spring容器的操作

private void prepareContext(DefaultBootstrapContext bootstrapContext, ConfigurableApplicationContext context, ConfigurableEnvironment environment, SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments, Banner printedBanner) {
    // 设置环境变量到spring容器
    context.setEnvironment(environment);

    // 设置在SpringApplication上的BeanNameGenerator、resourceLoader设置到spring容器中
    postProcessApplicationContext(context);

    // 使用ApplicationContextInitializer初始化spring容器
    applyInitializers(context);

    // 容器初始化完成，发布ApplicationContextInitializedEvent事件
    listeners.contextPrepared(context);

    // 关闭引导的容器
    bootstrapContext.close(context);

    if (this.logStartupInfo) {
        logStartupInfo(context.getParent() == null);
        logStartupProfileInfo(context);
    }

    // 注册一些单例Bean
    // Add boot specific singleton beans
    ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
    beanFactory.registerSingleton("springApplicationArguments", applicationArguments);
    if (printedBanner != null) {
        beanFactory.registerSingleton("springBootBanner", printedBanner);
    }

    // spring容器设置AllowCircularReferences和allowBeanDefinitionOverriding
    if (beanFactory instanceof AbstractAutowireCapableBeanFactory) {
        ((AbstractAutowireCapableBeanFactory) beanFactory).setAllowCircularReferences(this.allowCircularReferences);
        if (beanFactory instanceof DefaultListableBeanFactory) {
            ((DefaultListableBeanFactory) beanFactory)					.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
        }
    }
    if (this.lazyInitialization) {
        context.addBeanFactoryPostProcessor(new LazyInitializationBeanFactoryPostProcessor());
    }
    // Load the sources
    // 拿到启动配置（run方法传递进来的）
    Set<Object> sources = getAllSources();
    Assert.notEmpty(sources, "Sources must not be empty");
    // 将启动配置类解析为BeanDefinition注册到spring容器
    load(context, sources.toArray(new Object[0]));
    // 发布ApplicationPreparedEvent事件，表示已经启动好spring容器
    listeners.contextLoaded(context);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49