SpringBoot execution process example analysis

Each Spring Boot project has a main program startup class. In the main program startup class, there is a main() method to start the project. In this method, the entire Spring Boot program can be started by executing SpringApplication.run() .

Question: So how does the SpringApplication.run() method start the Spring Boot project?

Let’s look at the source code inside the run() method. The core code is as follows:

@SpringBootApplication
public class SpringbootDemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringbootDemoApplication.class, args);
    }
}

public static ConfigurableApplicationContext run(Class<?> primarySource, String... args) {
    return run(new Class[]{primarySource}, args);
}
    public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {
        return (new SpringApplication(primarySources)).run(args);
}

As can be seen from the above source code, the SpringApplication.run() method performs two operations, respectively. It is the initial creation of the SpringApplication instance and calling run() to start the project. The implementation of these two stages is detailed as follows

1. Initial creation of SpringApplication instance

View the source code information of initialization and creation of SpringApplication instance object. The core code is as follows

    public SpringApplication(ResourceLoader resourceLoader, Class... primarySources) {
        this.sources = new LinkedHashSet();
        this.bannerMode = Mode.CONSOLE;
        this.logStartupInfo = true;
        this.addCommandLineProperties = true;
        this.addConversionService = true;
        this.headless = true;
        this.registerShutdownHook = true;
        this.additionalProfiles = new HashSet();
        this.isCustomEnvironment = false;
        this.resourceLoader = resourceLoader;
        Assert.notNull(primarySources, "PrimarySources must not be null");
    // 把项目启动类.class设置为属性存储起来
        this.primarySources = new LinkedHashSet(Arrays.asList(primarySources));
    // 判断当前webApplicationType应用的类型
        this.webApplicationType = WebApplicationType.deduceFromClasspath();
    // 设置初始化器(Initializer),最后会调用这些初始化器
        this.setInitializers(this.getSpringFactoriesInstances(ApplicationContextInitializer.class));
    // 设置监听器(Listener)
        this.setListeners(this.getSpringFactoriesInstances(ApplicationListener.class));
    // 用于推断并设置项目main()方法启动的主程序启动类
        this.mainApplicationClass = this.deduceMainApplicationClass();

As can be seen from the above source code, the initialization process of SpringApplication mainly includes 4 parts, detailed description as follows.

(1) this.webApplicationType = WebApplicationType.deduceFromClasspath()

is used to determine the type of the current webApplicationType application. The deduceFromClasspath() method is used to check whether a certain feature class exists under the Classpath class path, so as to determine whether the current webApplicationType type is a SERVLET application (traditional MVC application before Spring 5) or a REACTIVE application (WebFlux interactive application that began to appear in Spring 5)

(2) this.setInitializers(this.getSpringFactoriesInstances(ApplicationContextInitializer.class))

Initializer settings for SpringApplication applications. During the initializer setting process, the Spring class loader SpringFactoriesLoader will be used to obtain all available application initializer classes ApplicationContextInitializer from the spring.factores file under META-INF under the META-INF/spring.factories class path.

(3) this.setListeners(this.getSpringFactoriesInstances(ApplicationListener.class))

Used for listener settings of SpringApplication application. The listener setting process is basically the same as the initializer setting process in the previous step. SpringFactoriesLoader is also used to obtain all available listener classes ApplicationListener from the spring.factores file under META-INF under the META-INF/spring.factories class path.

(4) this.mainApplicationClass = this.deduceMainApplicationClass()

Used to infer and set the main program startup class started by the project main() method

2． Initialization startup of the project

After analyzing the initialization and creation of the SpringApplication instance object in the previous part of the (new SpringApplication(primarySources)).run(args) source code, check the project initialization startup process and core code executed by the run(args) method The details are as follows:

  public ConfigurableApplicationContext run(String... args) {
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        ConfigurableApplicationContext context = null;
        Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList();
        this.configureHeadlessProperty();
    // 第一步：获取并启动监听器
        SpringApplicationRunListeners listeners = this.getRunListeners(args);
        listeners.starting();
        Collection exceptionReporters;
        try {
            ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
    // 第二步：根据SpringApplicationRunListeners以及参数来准备环境
            ConfigurableEnvironment environment = this.prepareEnvironment(listeners, applicationArguments);
            this.configureIgnoreBeanInfo(environment);
    // 准备Banner打印器 - 就是启动Spring Boot的时候打印在console上的ASCII艺术字体
            Banner printedBanner = this.printBanner(environment);
    // 第三步：创建Spring容器
            context = this.createApplicationContext();
            exceptionReporters = this.getSpringFactoriesInstances(SpringBootExceptionReporter.class, new Class[]{ConfigurableApplicationContext.class}, new Object[]{context});
    // 第四步：Spring容器前置处理
            this.prepareContext(context, environment, listeners, applicationArguments, printedBanner);
    // 第五步：刷新容器
            this.refreshContext(context);
    // 第六步：Spring容器后置处理
            this.afterRefresh(context, applicationArguments);
            stopWatch.stop();
            if (this.logStartupInfo) {
                (new StartupInfoLogger(this.mainApplicationClass)).logStarted(this.getApplicationLog(), stopWatch);
            }
    // 第七步：发出结束执行的事件
            listeners.started(context);
    // 返回容器
            this.callRunners(context, applicationArguments);
        } catch (Throwable var10) {
            this.handleRunFailure(context, var10, exceptionReporters, listeners);
            throw new IllegalStateException(var10);
        }
        try {
            listeners.running(context);
            return context;
        } catch (Throwable var9) {
            this.handleRunFailure(context, var9, exceptionReporters, (SpringApplicationRunListeners) null);
            throw new IllegalStateException(var9);
        }
    }

As can be seen from the above source code, the project initialization startup process generally includes the following parts:

Step 1: Obtain and start the listener

this.getRunListeners (args) and listeners.starting() methods are mainly used to obtain and run the SpringApplicationRunListener listener initialized during the SpringApplication instance initialization process.

Second step: Prepare the environment based on SpringApplicationRunListeners and parameters

This.prepareEnvironment(listeners, applicationArguments) method is mainly used to preset the project running environment, and at the same time, through this.configureIgnoreBeanInfo(environment ) method to exclude some unnecessary running environments

Step 3: Create a Spring container

Judge based on webApplicationType to determine the container type. If the type is a SERVLET type, the corresponding container will be loaded through reflection Bytecode, that is, AnnotationConfigServletWebServerApplicationContext, and then use the previously initialized context (application context environment), environment (project running environment), listeners (running listeners), applicationArguments (project parameters) and printedBanner (project icon information) to create the application context Assemble the configuration and refresh the configuration

Step 4: Spring container pre-processing

This step is mainly a preparatory action before the container is refreshed. Set up the container environment, including various variables, etc., which includes a very critical operation: injecting the startup class into the container to lay the foundation for subsequent automated configuration

Step 5: Refresh the container

Start refreshing the spring container, initialize the entire IOC container through the refresh method (including bean resource positioning, parsing, registration, etc.), and register a shutdown hook with the JVM runtime. This context will be closed when the JVM is shut down, unless it is at that time Already closed

Step 6: Spring container post-processing

Extension interface, template method in design mode, defaults to empty implementation. If you have custom requirements, you can override this method. For example, printing some startup and completion logs, or some other post-processing.

Step 7: Issue an event that ends execution

Get the EventPublishingRunListener listener and execute its started method, and pass the created Spring container in, create an ApplicationStartedEvent event, and execute ConfigurableApplicationContext The

publishEvent method, that is to say, the event is published in the Spring container, not in SpringApplication. This is different from the previous starting. The previous starting is published directly to the listener in SpringApplication. Start event.

Step 8: Execute Runners

Used to call the custom executor XxxRunner class in the project to execute some specific programs immediately after the project is started. Among them, the executor interfaces provided by Spring Boot include ApplicationRunner and CommandLineRunner. When using it, you only need to customize an executor class to implement one of the interfaces and rewrite the corresponding run() method interface. Then the Spring Boot project will be started immediately. Execute these specific programs

Below, through a Spring Boot execution flow chart, let everyone know more clearly the overall execution process and main startup stages of Spring Boot:

The above is the detailed content of SpringBoot execution process example analysis. For more information, please follow other related articles on the PHP Chinese website!