springBoot-启动原理

注：SpringBoot版本 2.6.2

SpringBoot的入口是从SpringApplication.run()传入我们的主启动类开始

@SpringBootApplication
public class LeeSpringbootApplication {

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

run()方法：

　　　　1、初始化SrpingApplication对象

　　　　2、执行run() 方法(primarySources：主启动类class)

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

1、初始化SrpingApplication对象

　　1、设置应用类型，后面会根据类型初始化对应的环境，常用的一般都是servlet环境

　　2、加载系统中引导器Bootstrapper（从META-INF/spring.factories中加载）

　　3、初始化classpath下 META-INF/spring.factories 中已配置的ApplicationContextInitalizer

　　4、初始化classpath下所以已配置的 ApplicationListener

　　5、根据调用栈，设置 main 方法的类名

public SpringApplication(ResourceLoader resourceLoader, Class... primarySources) {
    //设置资源加载器为null
    this.resourceLoader = resourceLoader;
    //断言加载资源不能为null
    Assert.notNull(primarySources, "PrimarySources must not be null");
    //将primarySources数组转换为list，最后放到LinkedHashSet集合中
    this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
    // 1.1 推断应用类型，后面会根据类型初始化对应的环境，常用的一般都是servlet环境
    this.webApplicationType = WebApplicationType.deduceFromClasspath();
    // 1.2 加载系统中引导器Bootstrapper
    this.bootstrapRegistryInitializers = new ArrayList<>(
            getSpringFactoriesInstances(BootstrapRegistryInitializer.class));
    // 1.3 初始化classpath下 META-INF/spring.factories 中已配置的ApplicationContextInitalizer
    setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
    // 1.4 初始化classpath下所以已配置的 ApplicationListener
    setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
    // 1.5 根据调用栈，设置 main 方法的类名
    this.mainApplicationClass = deduceMainApplicationClass();
}

　　在执行 getSpringFactoriesInstances(BootstrapRegistryInitializer.class) 中会调用 loadSpringFactories() 方法遍历所有jar包中classpath下 META-INF/spring.factories文件，并保存在缓存中

private static Map> loadSpringFactories(ClassLoader classLoader) {
    Map> result = cache.get(classLoader);
    if (result != null) {
        return result;
    }

    result = new HashMap<>();
    try {
        Enumeration urls = classLoader.getResources(FACTORIES_RESOURCE_LOCATION);
        while (urls.hasMoreElements()) {
            URL url = urls.nextElement();
            UrlResource resource = new UrlResource(url);
            Properties properties = PropertiesLoaderUtils.loadProperties(resource);
            for (Map.Entry entry : properties.entrySet()) {
                String factoryTypeName = ((String) entry.getKey()).trim();
                String[] factoryImplementationNames =
                        StringUtils.commaDelimitedListToStringArray((String) entry.getValue());
                for (String factoryImplementationName : factoryImplementationNames) {
                    result.computeIfAbsent(factoryTypeName, key -> new ArrayList<>())
                            .add(factoryImplementationName.trim());
                }
            }
        }

        // Replace all lists with unmodifiable lists containing unique elements
        result.replaceAll((factoryType, implementations) -> implementations.stream().distinct()
                .collect(Collectors.collectingAndThen(Collectors.toList(), Collections::unmodifiableList)));
        cache.put(classLoader, result);
    }
    catch (IOException ex) {
        throw new IllegalArgumentException("Unable to load factories from location [" +
                FACTORIES_RESOURCE_LOCATION + "]", ex);
    }
    return result;
}

loadSpringFactories

 

2、执行run() 方法

　　1、获取并启动监听器

　　2、构造上下文环境

　　3、初始化应用上下文

　　4、刷新应用上下文前的准备阶段   

　　5、刷新上下文

　　6、刷新应用上下文后的扩展接口

public ConfigurableApplicationContext run(String... args) {
    //记录程序运行时间
    long startTime = System.nanoTime();
    // 创建 DefaultBootstrapContext 的一项
    DefaultBootstrapContext bootstrapContext = createBootstrapContext();
    // ConfigurableApplicationContext spring的上下文
    ConfigurableApplicationContext context = null;
    configureHeadlessProperty();
    // 1、获取并启动监听器
    SpringApplicationRunListeners listeners = getRunListeners(args);
    listeners.starting(bootstrapContext, this.mainApplicationClass);
    try {
        ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
        // 2、构造上下文环境
        ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, applicationArguments);
        // 处理需要忽略的Bean
        configureIgnoreBeanInfo(environment);
        // 打印banner （springboot图标）
        Banner printedBanner = printBanner(environment);
        // 3、初始化应用上下文
        context = createApplicationContext();
        context.setApplicationStartup(this.applicationStartup);
        // 4、刷新应用上下文前的准备阶段
        prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);
        // 5、刷新上下文
        refreshContext(context);
        // 6、刷新应用上下文后的扩展接口
        afterRefresh(context, applicationArguments);
        // 记录执行时间
        Duration timeTakenToStartup = Duration.ofNanos(System.nanoTime() - startTime);
        if (this.logStartupInfo) {
            new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), timeTakenToStartup);
        }
        listeners.started(context, timeTakenToStartup);
        callRunners(context, applicationArguments);
    }
    catch (Throwable ex) {
        handleRunFailure(context, ex, listeners);
        throw new IllegalStateException(ex);
    }
    try {
        Duration timeTakenToReady = Duration.ofNanos(System.nanoTime() - startTime);
        listeners.ready(context, timeTakenToReady);
    }
    catch (Throwable ex) {
        handleRunFailure(context, ex, null);
        throw new IllegalStateException(ex);
    }
    return context;
}

　　2.1 加载监听器

　　　　加载META-INF/spring.factories 中的 SpringApplicationRunListener，SpringApplicationRunListeners负责在springBoot启动的不同阶段，广播出不同的消息，传递给ApplicationListener监听器实现类

private SpringApplicationRunListeners getRunListeners(String[] args) {
    Class[] types = new Class[] { SpringApplication.class, String[].class };
    return new SpringApplicationRunListeners(logger,
            getSpringFactoriesInstances(SpringApplicationRunListener.class, types, this, args),
            this.applicationStartup);
}

　　　　在 getSpringFactoriesInstances 中加载构建监听器对象并根据order进行排序

private  Collection getSpringFactoriesInstances(Class type, Class[] parameterTypes, Object... args) {
    ClassLoader classLoader = getClassLoader();
    // Use names and ensure unique to protect against duplicates
    Set names = new LinkedHashSet<>(SpringFactoriesLoader.loadFactoryNames(type, classLoader));
    List instances = createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);
    AnnotationAwareOrderComparator.sort(instances);
    return instances;
}

　　2.2 构造上下文环境

　　　　根据之前标记的应用类型(SERVLET)创建相应的环境，并根据配置文件，配置相应的系统环境

private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners,
            DefaultBootstrapContext bootstrapContext, ApplicationArguments applicationArguments) {
    // Create and configure the environment
    //  创建并配置相应环境
    ConfigurableEnvironment environment = getOrCreateEnvironment();
    // 根据用户配置，配置系统环境
    configureEnvironment(environment, applicationArguments.getSourceArgs());
    ConfigurationPropertySources.attach(environment);
    // 启动监听器，其中一个重要的监听器 ConfigFileApplicationListener 加载项目配置文件的监听器
    listeners.environmentPrepared(bootstrapContext, environment);
    DefaultPropertiesPropertySource.moveToEnd(environment);
    Assert.state(!environment.containsProperty("spring.main.environment-prefix"),
            "Environment prefix cannot be set via properties.");
    bindToSpringApplication(environment);
    if (!this.isCustomEnvironment) {
        environment = convertEnvironment(environment);
    }
    ConfigurationPropertySources.attach(environment);
    return environment;
}

　　2.3 初始化应用上下文

　　　　根据配置的应用类型(SERVLET)创建对应的context (AnnotationConfigServletWebServerApplicationContext) 并在父类 GenericApplicationContext 的构造方法中创建了DefaultListableBeanFactory（ioc容器）

    protected ConfigurableApplicationContext createApplicationContext() {
        return this.applicationContextFactory.create(this.webApplicationType);
    }

ApplicationContextFactory DEFAULT = (webApplicationType) -> {
    try {
        switch (webApplicationType) {
        case SERVLET:
            return new AnnotationConfigServletWebServerApplicationContext();
        case REACTIVE:
            return new AnnotationConfigReactiveWebServerApplicationContext();
        default:
            return new AnnotationConfigApplicationContext();
        }
    }
    catch (Exception ex) {
        throw new IllegalStateException("Unable create a default ApplicationContext instance, "
                + "you may need a custom ApplicationContextFactory", ex);
    }
};

　　2.4 刷新应用上下文前的准备阶段

　　　　主要完成应用上下文属性设置，并且将启动类生成实例对象保存到容器中。

private void prepareContext(DefaultBootstrapContext bootstrapContext, ConfigurableApplicationContext context,
    ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,
    ApplicationArguments applicationArguments, Banner printedBanner) {
    // 设置容器环境
    context.setEnvironment(environment);
    // 执行容器后置处理(主要设置转换器)
    postProcessApplicationContext(context);
    // 应用初始化器，执行容器中的 ApplicationContextInitializer 包括spring.factories
    applyInitializers(context);
    // 向各个容器中发送容器已经准备好的事件
    listeners.contextPrepared(context);
    bootstrapContext.close(context);
    if (this.logStartupInfo) {
        logStartupInfo(context.getParent() == null);
        logStartupProfileInfo(context);
    }
    // Add boot specific singleton beans
    ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
    // 将main函数中的args参数封装成单例Bean，注册到容器
    beanFactory.registerSingleton("springApplicationArguments", applicationArguments);
    if (printedBanner != null) {
        // 将printedBanner 封装成单例Bean 注册到容器
        beanFactory.registerSingleton("springBootBanner", printedBanner);
    }
    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
    // 获取主启动类
    Set