What is the SpringBoot startup code and automatic assembly source code?-Java Tutorial-php.cn

With the rapid development of the Internet, various components emerge in endlessly, and more and more components require framework integration. Each component needs to implement relevant code to integrate with the Spring container. SpringMVC framework configuration is too cumbersome and relies on XML files; in order to facilitate the rapid integration of third-party components and reduce dependence on configuration files, SpringBoot came into being, which adopts the theory of convention over configuration so that developers do not need to configure too much. for development. Spring, used at the bottom of SpringBoot, integrates the automatic assembly of N multiple components by default. Using SpringBoot is simple, add a @SpringBootApplication in the main class, and call SpringApplication.run() and pass in the main class. The code is as follows

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

Copy after login

As can be seen from the above source code, SpringApplication.run() is the program entrance of SpringBoot. This article will analyze it from two aspects: SpringApplication.run() and @SpringBootApplication annotation.

1. SpringBoot startup code mainline analysis

The key code in SpringApplication.run(StartApp.class) is to first create a SpringApplication class and then execute the run method. The code is as follows,

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

Copy after login

1. The construction method code of SpringApplication is as follows

public SpringApplication(ResourceLoader resourceLoader, Class... primarySources) {
    // 设置资源加载器
    this.resourceLoader = resourceLoader;
    Assert.notNull(primarySources, "PrimarySources must not be null");
    // 设置应用主配置类
    this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
    // 获取web服务器类型
    this.webApplicationType = WebApplicationType.deduceFromClasspath();
    // 从spring.factories 文件中获取 ApplicationContextInitializer 的实现类
    setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
    // 从spring.factories 文件中获取 ApplicationListener 监听器的实现类
    setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
    // 设置main启动类
    this.mainApplicationClass = deduceMainApplicationClass();
}

Copy after login

The main logic in the construction method:

1. Set the main configuration class of the application, in the run method later It will be encapsulated into a BeanDefinitionHolder and loaded into the context's registry.

2. Get the web server type, which will be used in the later run method to create a specific web service type.

3. Get the implementation class of ApplicationContextInitializer from the spring.factories file and set it to the SpringApplication instance

4. Get the implementation class of the ApplicationListener listener from the spring.factories file and set it to SpringApplication instance

5. Set the main startup class

The main logic of the getSpringFactoriesInstances method is: get the specific implementation class string from the META-INF/spring.factories file according to the interface, and put the string Be instantiated as an object. The code is as follows,

// 获取类加载器
ClassLoader classLoader = getClassLoader();
// Use names and ensure unique to protect against duplicates
// 根据type 从META-INF/spring.factories获取 具体的实现类字符串列表
Set names = new LinkedHashSet<>(SpringFactoriesLoader.loadFactoryNames(type, classLoader));
// 实例化具体的实现类
List instances = createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);
// 排序
AnnotationAwareOrderComparator.sort(instances);
return instances;

Copy after login

The implementation class string corresponding to ApplicationContextInitializer.class in the META-INF/spring.factories file is,

org.springframework.boot.context.ConfigurationWarningsApplicationContextInitializer,\
org.springframework.boot.context.ContextIdApplicationContextInitializer,\
org.springframework.boot.context.config.DelegatingApplicationContextInitializer,\
org.springframework.boot.rsocket.context.RSocketPortInfoApplicationContextInitializer,\
org.springframework.boot.web.context.ServerPortInfoApplicationContextInitializer

Copy after login

ApplicationListener. in the META-INF/spring.factories file. The implementation class string corresponding to class is,

org.springframework.boot.ClearCachesApplicationListener,\
org.springframework.boot.builder.ParentContextCloserApplicationListener,\
org.springframework.boot.cloud.CloudFoundryVcapEnvironmentPostProcessor,\
org.springframework.boot.context.FileEncodingApplicationListener,\
org.springframework.boot.context.config.AnsiOutputApplicationListener,\
org.springframework.boot.context.config.ConfigFileApplicationListener,\
org.springframework.boot.context.config.DelegatingApplicationListener,\
org.springframework.boot.context.logging.ClasspathLoggingApplicationListener,\
org.springframework.boot.context.logging.LoggingApplicationListener,\
org.springframework.boot.liquibase.LiquibaseServiceLocatorApplicationListener

Copy after login

2. The code of the run method is as follows, the main logic in the

StopWatch stopWatch = new StopWatch();
stopWatch.start();
ConfigurableApplicationContext context = null;
Collection exceptionReporters = new ArrayList<>();
// 设置了一个名为 java.awt.headless 的系统属性
// 其实是想设计应用程序，即使没有检测到显示器，也允许其启动
// 对于服务器来说，是不需要显示器的 ，所以要这样设置
configureHeadlessProperty();
// 获取 SpringApplicationRunListener 加载的是 EventPublishingRunListener
// 获取启动时的监听器
SpringApplicationRunListeners listeners = getRunListeners(args);
// 触发启动事件
listeners.starting();
try {
    // 构造一个应用程序的参数持有类
    ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
    // 创建并配置环境
    ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);
    // 配置需要忽略的BeanInfo信息
    configureIgnoreBeanInfo(environment);
    Banner printedBanner = printBanner(environment);
    // 创建上下文对象
    context = createApplicationContext();
    // 加载配置的启动异常处理器
    exceptionReporters = getSpringFactoriesInstances(SpringBootExceptionReporter.class,
                                                     new Class[] { ConfigurableApplicationContext.class }, context);
    // 刷新前操作
    prepareContext(context, environment, listeners, applicationArguments, printedBanner);
    // 刷新应用上下文 完成 Spring 容器的初始化
    refreshContext(context);
    // 刷新后操作
    afterRefresh(context, applicationArguments);
    stopWatch.stop();
    if (this.logStartupInfo) {
        new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
    }
    // 启动完成事件
    listeners.started(context);
    // 执行 ApplicationRunner 和 CommandLineRunner 实现类
    callRunners(context, applicationArguments);
}
catch (Throwable ex) {
    // 事件广播启动出错了
    handleRunFailure(context, ex, exceptionReporters, listeners);
    throw new IllegalStateException(ex);
}

try {
    // 运行事件
    listeners.running(context);
}
catch (Throwable ex) {
    handleRunFailure(context, ex, exceptionReporters, null);
    throw new IllegalStateException(ex);
}
return context;

Copy after login

run method:

1. From the spring.factories file Obtain the implementation class of SpringApplicationRunListener (listening event publisher) and execute related events in the context life cycle, such as triggering startup events, startup completion events, etc.

2. Create a Web application context object and create a specific web service type based on webApplicationType.

3. Before refreshing, encapsulate the main configuration class resource into BeanDefinitionHolder and load it into the context registry.

4. Refresh the application context to complete the initialization of the Spring container.

5. Execution Classes that implement the ApplicationRunner and CommandLineRunner interfaces.

2. Analysis of SpringBoot automatic assembly principle

1. Pre-knowledge of automatic assembly@Import

@SpringBootApplication annotation The main use of @Import annotation, @Import source code is as follows :

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Import {
    /**
	 * {@link Configuration @Configuration}, {@link ImportSelector},
	 * {@link ImportBeanDefinitionRegistrar}, or regular component classes to import.
	 */
    Class[] value();
}

Copy after login

@Import annotation is generally used together with @Configuration. The @Configuration annotation class will be parsed during the initialization process of the Spring container (the source code is in org.springframework.context.annotation.ConfigurationClassPostProcessor#processConfigBeanDefinitions). The process will parse the metadata of the @Import annotation of the annotated class and process it based on whether the class implements the relevant interface. Source code location: org.springframework.context.annotation.ConfigurationClassParser#processImports; the key code is as follows,

try {
    for (SourceClass candidate : importCandidates) {
        if (candidate.isAssignable(ImportSelector.class)) {
            // Candidate class is an ImportSelector -> delegate to it to determine imports
            Class candidateClass = candidate.loadClass();
            ImportSelector selector = ParserStrategyUtils.instantiateClass(candidateClass, ImportSelector.class,
                                                                           this.environment, this.resourceLoader, this.registry);
            Predicate selectorFilter = selector.getExclusionFilter();
            if (selectorFilter != null) {
                exclusionFilter = exclusionFilter.or(selectorFilter);
            }
            if (selector instanceof DeferredImportSelector) {
                this.deferredImportSelectorHandler.handle(configClass, (DeferredImportSelector) selector);
            }
            else {
                String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());
                Collection importSourceClasses = asSourceClasses(importClassNames, exclusionFilter);
                processImports(configClass, currentSourceClass, importSourceClasses, exclusionFilter, false);
            }
        }
        else if (candidate.isAssignable(ImportBeanDefinitionRegistrar.class)) {
            // Candidate class is an ImportBeanDefinitionRegistrar ->
            // delegate to it to register additional bean definitions
            Class candidateClass = candidate.loadClass();
            ImportBeanDefinitionRegistrar registrar =
                ParserStrategyUtils.instantiateClass(candidateClass, ImportBeanDefinitionRegistrar.class,
                                                     this.environment, this.resourceLoader, this.registry);
            configClass.addImportBeanDefinitionRegistrar(registrar, currentSourceClass.getMetadata());
        }
        else {
            // Candidate class not an ImportSelector or ImportBeanDefinitionRegistrar ->
            // process it as an @Configuration class
            this.importStack.registerImport(
                currentSourceClass.getMetadata(), candidate.getMetadata().getClassName());
            processConfigurationClass(candidate.asConfigClass(configClass), exclusionFilter);
        }
    }
}

Copy after login

From the above code, we can know that there are three scenarios for using the value class of @Import:

1. Implemented Scenario of the ImportSelector.class interface; directly call the selectImports method of the instance selector to return the full class name list of the Bean object to be instantiated, and create the instance object based on the full class name string list, and then recursively call the current processImports method, which will eventually be added To the configurationClasses collection, the objects in the configurationClasses collection will be registered to the registry object of the BeanDefinitionRegistry type. In this case, the interface ImportSelector is implemented and the DeferredImportSelector interface is extended. This interface is used to implement the delayed injection function of BeanDefinition. The DeferredImportSelector interface extends the ImportSelector interface and has an internal interface Group. If a value class annotated with @Import implements the DeferredImportSelector interface and also implements the internal class Group interface of the interface, it appears that this implementation class needs to be deferred. If delayed processing is required, the ImportSelector instance selector will be assembled into a DeferredImportSelectorHolder object and added to the deferredImportSelectors collection. The processing logic source code location: org.springframework.context.annotation.ConfigurationClassParser.DeferredImportSelectorHandler#handle; the key code is as follows,

public void handle(ConfigurationClass configClass, DeferredImportSelector importSelector) {
    DeferredImportSelectorHolder holder = new DeferredImportSelectorHolder(configClass, importSelector);
    if (this.deferredImportSelectors == null) {
        DeferredImportSelectorGroupingHandler handler = new DeferredImportSelectorGroupingHandler();
        handler.register(holder);
        handler.processGroupImports();
    }
    else {
        this.deferredImportSelectors.add(holder);
    }
}

Copy after login

The implementation logic of the DeferredImportSelector interface will be called in the org.springframework.context.annotation.ConfigurationClassParser#parse method. The specific code is in this.deferredImportSelectorHandler.process(). The key code is as follows,

public void process() {
    List deferredImports = this.deferredImportSelectors;
    this.deferredImportSelectors = null;
    try {
        if (deferredImports != null) {
            DeferredImportSelectorGroupingHandler handler = new DeferredImportSelectorGroupingHandler();
            deferredImports.sort(DEFERRED_IMPORT_COMPARATOR);
            deferredImports.forEach(handler::register);
            // 具体的执行逻辑
            handler.processGroupImports();
        }
    }
    finally {
        this.deferredImportSelectors = new ArrayList<>();
    }
}

Copy after login

在processGroupImports()方法中，先通过grouping.getImports()拿到需要自动装配的Group.Entry（封装了全类名）对象集合，然后通过processImports()方法根据Entry类名字符串进行创建SourceClass类（该类可以通过asConfigClass()方法转成ConfigurationClass对象），最终添加到configurationClasses集合中。代码如下，

public void processGroupImports() {
    for (DeferredImportSelectorGrouping grouping : this.groupings.values()) {
        Predicate exclusionFilter = grouping.getCandidateFilter();
        grouping.getImports().forEach(entry -> {
            ConfigurationClass configurationClass = this.configurationClasses.get(entry.getMetadata());
            try {
                processImports(configurationClass, asSourceClass(configurationClass, exclusionFilter),
                               Collections.singleton(asSourceClass(entry.getImportClassName(), exclusionFilter)),
                               exclusionFilter, false);
            }
            catch (BeanDefinitionStoreException ex) {
                throw ex;
            }
            catch (Throwable ex) {
                throw new BeanDefinitionStoreException(
                    "Failed to process import candidates for configuration class [" +
                    configurationClass.getMetadata().getClassName() + "]", ex);
            }
        });
    }
}

Copy after login

grouping.getImports()方法中主要执行具体的实现类的process方法和selectImports()方法（如果是AutoConfigurationImportSelector类，则调用org.springframework.boot.autoconfigure.AutoConfigurationImportSelector.AutoConfigurationGroup#process和org.springframework.boot.autoconfigure.AutoConfigurationImportSelector.AutoConfigurationGroup#selectImports，两个方法的具体类容请看2.2.2章节的说明），selectImports返回需要自动装配的Group.Entry对象集合，Entry对象中保存了全类名。代码如下：

public Iterable getImports() {
    for (DeferredImportSelectorHolder deferredImport : this.deferredImports) {
        this.group.process(deferredImport.getConfigurationClass().getMetadata(),
                           deferredImport.getImportSelector());
    }
    return this.group.selectImports();
}

Copy after login

ImportSelector接口代码代码如下：

public interface ImportSelector {
	String[] selectImports(AnnotationMetadata importingClassMetadata);
	@Nullable
	default Predicate getExclusionFilter() {
		return null;
	}
}

Copy after login

DeferredImportSelector接口的代码如下：

public interface DeferredImportSelector extends ImportSelector {

    @Nullable
    default Class getImportGroup() {
        return null;
    }
    interface Group {
        void process(AnnotationMetadata metadata, DeferredImportSelector selector);
        Iterable selectImports();
        class Entry {
			// 省略
        }
    }
}

Copy after login

2.实现了 ImportBeanDefinitionRegistrar.class接口的场景;会先创建ImportBeanDefinitionRegistrar 实例类 registrar，再把 registrar 添加到 configClass 的 importBeanDefinitionRegistrars中，接口的registerBeanDefinitions方法的调用是在 org.springframework.context.annotation.ConfigurationClassPostProcessor#processConfigBeanDefinitions方法里的this.reader.loadBeanDefinitions(configClasses)代码中。具体执行语句loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());关键代码如下，

private void loadBeanDefinitionsFromRegistrars(Map registrars) {
    registrars.forEach((registrar, metadata) ->
                       registrar.registerBeanDefinitions(metadata, this.registry, this.importBeanNameGenerator));
}

Copy after login

ImportBeanDefinitionRegistrar接口代码如下：

public interface ImportBeanDefinitionRegistrar {

    default void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry,
                                         BeanNameGenerator importBeanNameGenerator) {
        registerBeanDefinitions(importingClassMetadata, registry);
    }

    default void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
    }
}

Copy after login

3.没有实现以上两接口的普通类，会直接调用org.springframework.context.annotation.ConfigurationClassParser#processImports里面的processConfigurationClass方法，把当前configClass添加至 configurationClasses 集合中。configurationClasses集合中的对象最终会被注册到BeanDefinitionRegistry类型的 registry 对象中。

2.@SpringApplication注解分析

@SpringApplication注解主要包括了@SpringBootConfiguration、@EnableAutoConfiguration、@ComponentScan。代码如下，

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
		@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })

Copy after login

2.1@SpringBootConfiguration

配置注解，包含了@Configuration注解，表明是配置类。

2.2@EnableAutoConfiguration

自动装配注解，主要逻辑是：根据 EnableAutoConfiguration 类型从META-INF/spring.factories 文件加载需要自动装配的类，并注入到Spring容器中。它包括了@AutoConfigurationPackage注解和一个@Import(AutoConfigurationImportSelector.class)注解。代码如下，

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)

Copy after login

2.2.1@AutoConfigurationPackage

注册名为 org.springframework.boot.autoconfigure.AutoConfigurationPackages ，BeanClass为BasePackages.class 的GenericBeanDefinition 到 BeanDefinitionRegistry 中，通过@Import 注解实现注入功能，代码如下，

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@Import(AutoConfigurationPackages.Registrar.class)
public @interface AutoConfigurationPackage {
}

Copy after login

AutoConfigurationPackages.Registrar.class实现了ImportBeanDefinitionRegistrar接口，所以在Spring容器初始化的过程中会调用它的registerBeanDefinitions方法把PackageImport类注入到Spring容器中去。代码如下，

static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
        register(registry, new PackageImport(metadata).getPackageName());
    }
    @Override
    public Set