Spring Boot 源码分析 版本2.1.x

new SpringApplication(DebugApplication.class)
    1.推断应用类型 WebApplicationType.deduceFromClasspath()
        Class.forName(name, false, clToUse)加载是否成功
    2.获取初始器 ApplicationContextInitializer.class（META-INF/spring.factories）
        加载
        缓存
        创建实例 class.getDeclaredConstructor(parameterTypes)获取构造器，ctor.newInstance(args)
    3.获取应用监听器 ApplicationListener.class 同上（META-INF/spring.factories）
    4.推断主类 deduceMainApplicationClass()
        通过异常 new RuntimeException().getStackTrace()找出main方法所在类的类型，然后加载Class.forName(stackTraceElement.getClassName())

.run(args)
    1.启动秒表 stopWatch.start()
    2.获取监听 getRunListeners(args)
        获取Spring应用运行监听实例 SpringApplicationRunListener.class（META-INF/spring.factories）
    3.通知starting事件 EventPublishingRunListener
        listeners.starting()
        广播事件 this.initialMulticaster.multicastEvent(new ApplicationStartingEvent(this.application, this.args));
            获取监听 this.getApplicationListeners(event, type) 根据事件和ResolvableType从应用的所有监听器中过滤出需要的监听器 SimpleApplicationEventMulticaster
                this.retrieveApplicationListeners(eventType, sourceType, retriever) 根据event和source类型获取监听
                    循环所有监听 找到support监听 this.supportsEvent(listener, eventType, sourceType)
                        每个监听有supportsEventType和supportsSourceType
    4.准备环境 prepareEnvironment(listeners, applicationArguments)
        1.创建环境 getOrCreateEnvironment() 根据应用类型创建不同的环境 new StandardServletEnvironment() 设置系统属性和环境变量
            servletConfigInitParams----servlet config init 参数
            servletContextInitParams------contex 参数
            systemProperties-----------------jvm系统属性
            systemEnvironment----------------环境变量
        2.配置环境 configureEnvironment(environment, applicationArguments.getSourceArgs())
            1.配置转换服务 environment.setConversionService
            2.配置 PropertySources 设置初始化参数，   无
            3.配置 Profiles  无
        3.通知environmentPrepared事件 listeners.environmentPrepared(environment)
            loadPostProcessors（） 3 + 1  ConfigFileApplicationListener 第一个监听器
                EnvironmentPostProcessor.class（META-INF/spring.factories）
            RandomValuePropertySource.addToEnvironment(environment)  random
            loadForFileExtension  file:./config/application .properties
            load  加载配置文件
                PropertiesPropertySourceLoader  { "properties", "xml" }
                YamlPropertySourceLoader        { "yml", "yaml" }
                file:./config/application.properties
                file:./config/application.xml
                file:./config/application.yml
                file:./config/application.yaml
                file:./application.properties
                file:./application.xml
                file:./application.yml
                file:./application.yaml
        4.绑定到SpringApplication bindToSpringApplication(environment);
    5.打印Banner
    6.创建上下文Context createApplicationContext()
        实例化 （根据webApplicationType创建不同context）
            SERVLET     AnnotationConfigServletWebServerApplicationContext
            REACTIVE    AnnotationConfigReactiveWebServerApplicationContext
            default     AnnotationConfigApplicationContext
            利用反射构造器创建实例 ctor.newInstance(args)
                this.reader = new AnnotatedBeanDefinitionReader(this);
                    注册自动装配5个 internal Processor -- AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry)
                        注册自动装配5个 internal Processor -- AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry)
                        Map<String, BeanDefinition> beanDefinitionMap DefaultListableBeanFactory
                        将Internal的Bean放入beanDefinitionMap
                this.scanner = new ClassPathBeanDefinitionScanner(this);
                    注册默认include过滤器 includeFilters this.registerDefaultFilters()-----Component.class,ManagedBean,Named
    7.获取异常报告者实例 SpringBootExceptionReporter.class（META-INF/spring.factories）
    8.准备上下文 prepareContext
        1.配置环境 environment
        2.配置转换服务 ConversionService
        3.运用Initializer
        4.通知contextPrepared事件 listeners.contextPrepared(context)
        5.注册参数Bean beanFactory.registerSingleton("springApplicationArguments", applicationArguments);
        6.load source启动类  <-----------------封装并注册启动类的BeanDefinition
            AnnotatedBeanDefinitionReader.doRegisterBean
                BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry)
                    BeanDefinitionLoader.load()
                        AnnotationUtils.findAnnotation(type, Component.class) 判断是否Component组件
                            this.annotatedReader.register(source) --- AnnotatedBeanDefinitionReader
                                new AnnotatedGenericBeanDefinition(beanClass);  封装成BeanDefinition
                                this.conditionEvaluator.shouldSkip(abd.getMetadata())   检查是否包含Conditional注解
                                BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
        7.listeners.contextLoaded(context)
            ConfigFileApplicationListener.onApplicationEvent(ApplicationEvent event)
                context.addBeanFactoryPostProcessor(new PropertySourceOrderingPostProcessor(context))
    9.刷新上下文 refreshContext(context)
        1.refresh(context)
            context.refresh() AbstractApplicationContext
                1.this.prepareRefresh()
                    super.prepareRefresh() 初始化context属性
                        清除工厂缓存
                        设置context属性 closed active
                        this.initPropertySources()--无
                        validateRequiredProperties--无
                2.this.obtainFreshBeanFactory()----DefaultListableBeanFactory，获取新Bean工厂
                    设置序列号Id setSerializationId
                3.this.prepareBeanFactory(beanFactory) 给Bean工厂设置属性
                4.this.postProcessBeanFactory(beanFactory); <--------------- 注册BeanPostProcessor  WebApplicationContextServletContextAwareProcessor
                    调用 super.postProcessBeanFactory(beanFactory); 注册 resolvableDependencies （ServletRequest,ServletResponse,HttpSession,WebRequest）
                    扫描制定basePackages的Bean this.scanner.scan(this.basePackages)
                    注册上述Bean this.reader.register(ClassUtils.toClassArray(this.annotatedClasses))
                5.this.invokeBeanFactoryPostProcessors(beanFactory);
                    遍历并调用 按顺序调用 PriorityOrdered-->Ordered-->
                    invokeBeanDefinitionRegistryPostProcessors
                        BeanDefinitionRegistryPostProcessor.postProcessBeanDefinitionRegistry(registry) <------------------自动装配 EnableAutoConfiguration.class
                        ConfigurationClassPostProcessor.postProcessBeanDefinitionRegistry(registry) <------------------自动扫描装配 @Service/@RestController
                            ConfigurationClassPostProcessor
                                parser.parse(candidates) --- ConfigurationClassParser
                                    handler.processGroupImports() --- ConfigurationClassParser.DeferredImportSelectorGroupingHandler
                                        grouping.getImports() ---ConfigurationClassParser.DeferredImportSelectorGrouping
                                            this.group.process  this=AutoConfigurationImportSelector
                                                AutoConfigurationImportSelector.getAutoConfigurationEntry(getAutoConfigurationMetadata(), annotationMetadata);
                                                    fireAutoConfigurationImportEvents
                                                        获取自动import的所有监听
                                                            invokeAwareMethods(listener) 调用aware方法--BeanClassLoaderAware/BeanFactoryAware/EnvironmentAware/ResourceLoaderAware
                                                            listener.onAutoConfigurationImportEvent(event) 调用监听方法
                                                this.getCandidateConfigurations(annotationMetadata, attributes);
                                                    SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(), getBeanClassLoader());
                                                        EnableAutoConfiguration.class <-------- getSpringFactoriesLoaderFactoryClass()
                                                        --ClassPathScanningCandidateComponentProvider.scanCandidateComponents
                                this.reader.loadBeanDefinitions(configClasses)     装在其他 Springboot auto configuration
                    invokeBeanFactoryPostProcessors
                        BeanFactoryPostProcessor.postProcessBeanFactory(beanFactory);
                6.this.registerBeanPostProcessors(beanFactory);---->PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
                    priorityOrderedPostProcessors--->orderedPostProcessors--->nonOrderedPostProcessors--->internalPostProcessors
　　　　　　　　　　　　
                7.this.initMessageSource(); 注册 messageSource beanFactory.registerSingleton
                8.this.initApplicationEventMulticaster(); 注册 applicationEventMulticaster beanFactory.registerSingleton
                9.this.onRefresh();
                    super.onRefresh();     初始化主题 initThemeSource -------- ServletWebServerApplicationContext
                    createWebServer();  创建Server
                        从工厂获取Bean工厂名称 ServletWebServerFactory.class ----tomcatServletWebServerFactory
                        调用工厂getBean() 获取工厂实例
                        生成webServer factory.getWebServer(getSelfInitializer());
                            new Tomcat()
                                创建临时目录 C:\Users\xxx\AppData\Local\Temp\tomcat.4199858188215657764.8080
                            new Connector(this.protocol)
                            new StandardServer()
                            new TomcatWebServer(tomcat, getPort())
                                initialize()  Tomcat initialized with port(s): 8080 (http)
                                    this.tomcat.start();
                                        this.server.start();
                                            this.startInternal();
                10.this.registerListeners();
                    给广播注册监听  SimpleApplicationEventMulticaster
                    广播 this.getApplicationEventMulticaster().multicastEvent(earlyEvent);
                11.this.finishBeanFactoryInitialization(beanFactory);
　　　　　　　　　　　　　　

  　　　　　　　　　　　　beanFactory.getBean  <------------创建Bean
                        this.doGetBean
                        this.createBean
                            this.resolveBeforeInstantiation(beanName, mbdToUse) ---> AbstractAutowireCapableBeanFactory
                                this.applyBeanPostProcessorsBeforeInstantiation
                                    InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation(beanClass, beanName) <-------Instantiation
                                bean非null时执行 this.applyBeanPostProcessorsAfterInitialization(bean, beanName);
                                    BeanPostProcessor.postProcessAfterInitialization(result, beanName);
                            doCreateBean
                                this.createBeanInstance(beanName, mbd, args);
                                    this.determineConstructorsFromBeanPostProcessors(beanClass, beanName)
                                        SmartInstantiationAwareBeanPostProcessor.determineCandidateConstructors(beanClass, beanName)
                                        InstantiationAwareBeanPostProcessorAdapter.xx
                                    this.instantiateBean(beanName, mbd)
                                        clazz.getDeclaredConstructor()
                                        ctor.newInstance(args)
                                this.applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName)
                                    MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition(mbd, beanType, beanName);
                                this.populateBean(beanName, mbd, instanceWrapper);
                                    InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName) <-------Instantiation
                                    InstantiationAwareBeanPostProcessor.postProcessProperties((PropertyValues)pvs, bw.getWrappedInstance(), beanName);
                                    this.applyPropertyValues(beanName, mbd, bw, (PropertyValues)pvs);
                                        BeanWrapper.setPropertyValues(new MutablePropertyValues(deepCopy))
                                            值的转换
                                            BeanWrapperImpl.setValue()
                                            拼接set方法名
                                            利用反射获取Method
                                            调用method.invoke方法 writeMethod.invoke(BeanWrapperImpl.this.getWrappedInstance(), value);
                                this.initializeBean(beanName, exposedObject, mbd);
                                    this.invokeAwareMethods(beanName, bean);
                                        BeanNameAware
                                        BeanClassLoaderAware
                                        BeanFactoryAware
                                    this.applyBeanPostProcessorsBeforeInitialization(bean, beanName);
                                        BeanPostProcessor.postProcessBeforeInitialization(result, beanName); <-------------Initialization  before
                                    this.invokeInitMethods(beanName, wrappedBean, mbd);
                                        ((InitializingBean)bean).afterPropertiesSet();
                                        this.invokeCustomInitMethod(beanName, bean, mbd);
                                            methodToInvoke.invoke(bean);  <-------------init method
                                    this.applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
                                        BeanPostProcessor.postProcessAfterInitialization(result, beanName); <-------------Initialization  after

                12.this.finishRefresh();
                    startWebServer();
                        webServer.start();  Tomcat started on port(s): 8080 (http) with context path ''
                13.this.resetCommonCaches();
        2.注册关闭钩子 context.registerShutdownHook();
            Runtime.getRuntime().addShutdownHook(Thread)
                thread 调用AbstractApplicationContext.this.doClose()
    10.刷新上下文之后 afterRefresh(context, applicationArguments) --无
    11.停止秒表 stopWatch.stop();
    12.通知started事件 listeners.started(context);
    13.调用runner.run() callRunners ApplicationRunner CommandLineRunner
    13.通知running事件 listeners.running(context)
    14.返回context