springboot启动源码解析

/**
*SpringApplication
*/

//构造器初始化
public SpringApplication(ResourceLoader resourceLoader, Class... primarySources) {
        this.sources = new LinkedHashSet();
        //横幅模式 OFF,CONSOLE,LOG;
        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");
        this.primarySources = new LinkedHashSet(Arrays.asList(primarySources));
        //应用类型NONE,SERVLET,REACTIVE;存在DispatcherHandler，不存在DispatcherServlet，ServletContainer，则为REACTIVE
        //不存在javax.servlet.Servlet", "org.springframework.web.context.ConfigurableWebApplicationContext，则为NONE，则为SERVLET
        this.webApplicationType = WebApplicationType.deduceFromClasspath();
        //spring.factories文件中org.springframework.context.ApplicationContextInitializer=\
        //org.springframework.boot.context.ConfigurationWarningsApplicationContextInitializer,\
        //org.springframework.boot.context.ContextIdApplicationContextInitializer,\
        //org.springframework.boot.context.config.DelegatingApplicationContextInitializer,\
        //org.springframework.boot.web.context.ServerPortInfoApplicationContextInitializer
        this.setInitializers(this.getSpringFactoriesInstances(ApplicationContextInitializer.class));
        //org.springframework.context.ApplicationListener=\
        //org.springframework.boot.ClearCachesApplicationListener,\
        //org.springframework.boot.builder.ParentContextCloserApplicationListener,\
        //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 进行初始化
        this.setListeners(this.getSpringFactoriesInstances(ApplicationListener.class));
        //推论出主类main
        this.mainApplicationClass = this.deduceMainApplicationClass();
    }
//核心开始运行
public ConfigurableApplicationContext run(String... args) {
          //秒表，用于记录启动时间，记录每个任务 的时间，
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        //spring应用上下文，spring容器
        ConfigurableApplicationContext context = null;
        //自定义SpringApplication启动错误的回调接口
        Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList();
        //java.awt.headless模式 默认为true开启
        this.configureHeadlessProperty();
        //开启监听
        //org.springframework.boot.SpringApplicationRunListener=\
        //org.springframework.boot.context.event.EventPublishingRunListener
        SpringApplicationRunListeners listeners = this.getRunListeners(args);
        //
        listeners.starting();

        Collection exceptionReporters;
        try {
            //参数封装，在命令行下启动应用带的参数，如--server.port
            ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
            //环境准备 1.加载外部化配置的资源到environment 2.触发ApplicationEnvironmentPreparedEvent事件
            ConfigurableEnvironment environment = this.prepareEnvironment(listeners, applicationArguments);
            //配置系统属性spring.beaninfo.ignore
            this.configureIgnoreBeanInfo(environment);
            //打印横幅
            Banner printedBanner = this.printBanner(environment);
            //创建ApplicationContext 根据webApplicationType
            //SERVLET:
            //        contextClass = Class.forName("org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext");
            //REACTIVE:
            //        contextClass = Class.forName("org.springframework.boot.web.reactive.context.AnnotationConfigReactiveWebServerApplicationContext");
            //    default:
            //        contextClass = Class.forName("org.springframework.context.annotation.AnnotationConfigApplicationContext");
            /**
            *AnnotationConfigServletWebServerApplicationContext层级关系-》ServletWebServerApplicationContext-》GenericWebApplicationContext
            *-》GenericApplicationContext-》AbstractApplicationContext
            */
            //部分属性：reader、scanner、beanFactory进行了实例化
            context = this.createApplicationContext();
            //实例化 用来支持报告关于启动的错误
            //# Error Reporters
            //org.springframework.boot.SpringBootExceptionReporter=\
            //org.springframework.boot.diagnostics.FailureAnalyzers
            exceptionReporters = this.getSpringFactoriesInstances(SpringBootExceptionReporter.class, new Class[]{ConfigurableApplicationContext.class}, context);
            //ApplicationContext准备 加载
            this.prepareContext(context, environment, listeners, applicationArguments, printedBanner);
            //核心：
            this.refreshContext(context);
            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);
        }
    }
//环境准备
private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments) {
        //创建环境 SERVLET StandardServletEnvironment； REACTIVE StandardReactiveWebEnvironment； StandardEnvironment
        ConfigurableEnvironment environment = this.getOrCreateEnvironment();
        this.configureEnvironment((ConfigurableEnvironment)environment, applicationArguments.getSourceArgs());
        listeners.environmentPrepared((ConfigurableEnvironment)environment);
        this.bindToSpringApplication((ConfigurableEnvironment)environment);
        if (!this.isCustomEnvironment) {
            environment = (new EnvironmentConverter(this.getClassLoader())).convertEnvironmentIfNecessary((ConfigurableEnvironment)environment, this.deduceEnvironmentClass());
        }

        ConfigurationPropertySources.attach((Environment)environment);
        return (ConfigurableEnvironment)environment;
    }

/**
*AbstractApplicationContext
*/ 
//刷新
public void refresh() throws BeansException, IllegalStateException {
        Object var1 = this.startupShutdownMonitor;
        synchronized(this.startupShutdownMonitor) {
              //刷新前准备 校验
            this.prepareRefresh();
            //获取DefaultListableBeanFactory实例
            ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
            //beanFactory加载配置
            this.prepareBeanFactory(beanFactory);

            try {
                  //beanFactory后置处理，重写ApplicationContext的postProcessBeanFactory方法
                this.postProcessBeanFactory(beanFactory);
                //核心：
                this.invokeBeanFactoryPostProcessors(beanFactory);
                //注册BeanPostProcessor
                this.registerBeanPostProcessors(beanFactory);
                this.initMessageSource();
                this.initApplicationEventMulticaster();
                this.onRefresh();
                this.registerListeners();
                this.finishBeanFactoryInitialization(beanFactory);
                this.finishRefresh();
            } catch (BeansException var9) {
                if (this.logger.isWarnEnabled()) {
                    this.logger.warn("Exception encountered during context initialization - cancelling refresh attempt: " + var9);
                }

                this.destroyBeans();
                this.cancelRefresh(var9);
                throw var9;
            } finally {
                this.resetCommonCaches();
            }

        }
    }