[toc]
前言
为了记录 spring 的学习日志，以笔记的模式将学习过程记录下来，有问题或有脱漏请指出，谢谢！
现将spring boot启动流程进行梳理记录。
1. SpringApplication 筹备
@SpringBootApplicationpublic class DomeApplication extends SpringBootServletInitializer { public static void main(String[] args) { SpringApplication.run(DomeApplication.class, args); } @Override protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) { return builder.sources(this.getClass()); }}应用 @SpringBootApplication 注解，标识启动类，它是一个复合注解，标识应用主动拆卸、通过扫描注解注入bean。
@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) })public @interface SpringBootApplication{}在启动类中，运行main办法，将调用SpringApplication.run
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); } public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) { return new SpringApplication(primarySources).run(args); }通过源码看到，在SpringApplication.run中，应用primarySources结构 SpringApplication对象，而后调用run办法。筹备工作在结构器中实现。
public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) { // 用来获取 Resource 和 classLoader 以及加载资源。 this.resourceLoader = resourceLoader; Assert.notNull(primarySources, "PrimarySources must not be null"); // 寄存主加载类。 this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources)); // 推断 web 类型：servlet 或 reactive。 this.webApplicationType = WebApplicationType.deduceFromClasspath(); // 获取 ApplicationContextInitializer 的实现类，进行上下文初始化。 setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class)); // 获取利用事件监听器。 setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class)); // 推导入口类。 this.mainApplicationClass = deduceMainApplicationClass(); }2. SpringApplication 运行
run办法执行后，spring 开始正式运行。
public ConfigurableApplicationContext run(String... args) { // 计时器启动 StopWatch stopWatch = new StopWatch(); stopWatch.start(); ConfigurableApplicationContext context = null; Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>(); // 配置服务器环境有无外设：如显示器、鼠标，如果须要这些数据须要cpu模仿。 configureHeadlessProperty(); // 获取 spring 运行监听器，从spring.factories文件中加载 // 如: EventPublishingRunListener(SpringApplication application, String[] args) SpringApplicationRunListeners listeners = getRunListeners(args); // 1. 监听器公布利用筹备启动 ApplicationStartingEvent 事件 listeners.starting(); try { // 将传入的参数进行封装。 ApplicationArguments applicationArguments = new DefaultApplicationArguments(args); //2. 筹备应用程序环境，并触发事件 ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments); // 设置Introspector.getBeaninfo参数是否疏忽与参数class关联的所有beanInfo configureIgnoreBeanInfo(environment); // 获取横幅对象 Banner printedBanner = printBanner(environment); //3. 依据webApplicationType创立对应的spring context，并注册正文配置处理器 context = createApplicationContext(); // spring 启动谬误回调 exceptionReporters = getSpringFactoriesInstances(SpringBootExceptionReporter.class, new Class[] { ConfigurableApplicationContext.class }, context); //4. 筹备 applicationContext prepareContext(context, environment, listeners, applicationArguments, printedBanner); //5. 刷新context refreshContext(context); //11. 上下文刷新后触发 afterRefresh(context, applicationArguments); stopWatch.stop(); if (this.logStartupInfo) { new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch); } // 公布started事件 listeners.started(context); callRunners(context, applicationArguments); } catch (Throwable ex) { // 异样解决 handleRunFailure(context, ex, exceptionReporters, listeners); throw new IllegalStateException(ex); } try { // 触发running事件 listeners.running(context); } catch (Throwable ex) { handleRunFailure(context, ex, exceptionReporters, null); throw new IllegalStateException(ex); } return context;}2.1 触发SpringApplication开始启动事件
获取spring.factories中 key为SpringApplicationRunListener的对象实例。
// SpringApplication类中 private SpringApplicationRunListeners getRunListeners(String[] args) { Class<?>[] types = new Class<?>[] { SpringApplication.class, String[].class }; return new SpringApplicationRunListeners(logger, getSpringFactoriesInstances(SpringApplicationRunListener.class, types, this, args)); }# Run Listenersorg.springframework.boot.SpringApplicationRunListener=\org.springframework.boot.context.event.EventPublishingRunListener创立EventPublishingRunListener对象时将SpringApplication中的监听器存入播送器中，进行事件播送
public EventPublishingRunListener(SpringApplication application, String[] args) { this.application = application; this.args = args; this.initialMulticaster = new SimpleApplicationEventMulticaster(); for (ApplicationListener<?> listener : application.getListeners()) { this.initialMulticaster.addApplicationListener(listener); }}2.2 筹备环境 prepareEnvironment
将系统配置和零碎环境加载进 ConfigurableEnvironment 中，如果有spring cloud 我的项目 bootstrap上下文，则会优先加载spring cloud 配置和近程配置。
/** * SpringApplication类中 * 筹备应用程序环境以及配置。 * 将零碎的相干属性和环境变量配置加载进利用配置对象中，并把main办法输出参数 args 解析后也退出到利用配置中。 */ private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments) { //1. 依据容器类型创立环境配置 // 并将零碎的相干属性（systemProperties）和环境变量配置（systemEnvironment）加载进利用配置的对象中 ConfigurableEnvironment environment = getOrCreateEnvironment(); //2. 设置配置属性转换器、增加利用默认配置、设置 profile configureEnvironment(environment, applicationArguments.getSourceArgs()); //3. 将MutablePropertySources转换为ConfigurationPropertySourcesPropertySource，次要充当适配器 ConfigurationPropertySources.attach(environment); //4. 公布 ApplicationEnvironmentPreparedEvent 事件 // 其中 BootstrapApplicationListener 将疏导spring cloud 上下文，加载 bootstrap 配置文件 // ConfigFileApplicationListener 加载配置文件（application.yml） listeners.environmentPrepared(environment); //5. 将environment 中 spring.main 结尾的配置绑定到 application 实例上 bindToSpringApplication(environment); if (!this.isCustomEnvironment) { //6. 将 environment 转化为对应容器类型的 Environment 实例 // StandardServletEnvironment、StandardReactiveWebEnvironment、StandardEnvironment environment = new EnvironmentConverter(getClassLoader()) .convertEnvironmentIfNecessary(environment, deduceEnvironmentClass()); } //7. 将MutablePropertySources 转换为 ConfigurationPropertySourcesPropertySource ConfigurationPropertySources.attach(environment); return environment; }2.3 创立 createApplicationContext
创立时会依据利用类型 webApplicationType 创立对应的 ApplicationContext，并注册默认的 BeanDefinitionRegistryPostProcessor
/** * SpringApplication类中 * 创立对应的 ApplicationContext */ protected ConfigurableApplicationContext createApplicationContext() { Class<?> contextClass = this.applicationContextClass; if (contextClass == null) { try { switch (this.webApplicationType) { case SERVLET: // AnnotationConfigServletWebServerApplicationContext contextClass = Class.forName(DEFAULT_SERVLET_WEB_CONTEXT_CLASS); break; case REACTIVE: // AnnotationConfigReactiveWebServerApplicationContext contextClass = Class.forName(DEFAULT_REACTIVE_WEB_CONTEXT_CLASS); break; default: // AnnotationConfigApplicationContext contextClass = Class.forName(DEFAULT_CONTEXT_CLASS); } } catch (ClassNotFoundException ex) { throw new IllegalStateException( "Unable create a default ApplicationContext, please specify an ApplicationContextClass", ex); } } return (ConfigurableApplicationContext) BeanUtils.instantiateClass(contextClass); } // ------------------------------------------------------- /** * 这三个ApplicationContext的结构器中，都会创立 AnnotatedBeanDefinitionReader 和 ClassPathBeanDefinitionScanner */ public AnnotationConfigServletWebServerApplicationContext() { // 依据注解注册bean this.reader = new AnnotatedBeanDefinitionReader(this); // 依据class path 扫描bean this.scanner = new ClassPathBeanDefinitionScanner(this); } public AnnotationConfigReactiveWebServerApplicationContext() { this.reader = new AnnotatedBeanDefinitionReader(this); this.scanner = new ClassPathBeanDefinitionScanner(this); } public AnnotationConfigApplicationContext() { this.reader = new AnnotatedBeanDefinitionReader(this); this.scanner = new ClassPathBeanDefinitionScanner(this); } /** * AnnotatedBeanDefinitionReader 中会注册几个 BeanDefinitionRegistryPostProcessor */ public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment) { Assert.notNull(registry, "BeanDefinitionRegistry must not be null"); Assert.notNull(environment, "Environment must not be null"); this.registry = registry; this.conditionEvaluator = new ConditionEvaluator(registry, environment, null); AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry); } /** * AnnotationConfigUtils.registerAnnotationConfigProcessors * 注册注解后置处理器，将在 refresh 办法中被调用到。 */ public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors( BeanDefinitionRegistry registry, @Nullable Object source) { // 获取 beanFactory DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry); if (beanFactory != null) { // 设置默认排序器 if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) { beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE); } // 设置主动注入处理器 if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) { beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver()); } } Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8); // 注册 ConfigurationClassPostProcessor,他反对 @Configuration、@ComponentScans、@ComponentScan、@ImportResource、@Import 等注解进行注册bean。 if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) { RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class); def.setSource(source); beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)); } // 注册 AutowiredAnnotationBeanPostProcessor，反对应用 @Autowired 注解、Setter、@Value 主动注入、xml配置。 if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) { RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class); def.setSource(source); beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)); } // 反对 jsr250Present 时注册 CommonAnnotationBeanPostProcessor // Check for JSR-250 support, and if present add the CommonAnnotationBeanPostProcessor. if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) { RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class); def.setSource(source); beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)); } // 反对jpa，注册 PersistenceAnnotationBeanPostProcessor // Check for JPA support, and if present add the PersistenceAnnotationBeanPostProcessor. if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) { RootBeanDefinition def = new RootBeanDefinition(); try { def.setBeanClass(ClassUtils.forName(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, AnnotationConfigUtils.class.getClassLoader())); } catch (ClassNotFoundException ex) { throw new IllegalStateException( "Cannot load optional framework class: " + PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, ex); } def.setSource(source); beanDefs.add(registerPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)); } // 注册 EventListenerMethodProcessor ，为事件监听器提供反对 if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) { RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class); def.setSource(source); beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME)); } // 注册 DefaultEventListenerFactory，设置默认的监听器工厂 if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) { RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class); def.setSource(source); beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME)); } return beanDefs; }2.4 筹备 prepareContext
配置 applicationContext，调用 ApplicationContextInitializer 实现类
/** * SpringApplication 中 * 对 applicationContext 进行初始化设置。 */ private void prepareContext(ConfigurableApplicationContext context, ConfigurableEnvironment environment, SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments, Banner printedBanner) { //1. 设置环境 context.setEnvironment(environment); //2. 设置 beanNameGenerator和bean 属性数据类型转换服务 postProcessApplicationContext(context); //3. 调用 ApplicationContextInitializer applyInitializers(context); //4. 公布 contextPrepared 事件 listeners.contextPrepared(context); if (this.logStartupInfo) { logStartupInfo(context.getParent() == null); logStartupProfileInfo(context); } //5. 获取 beanFactory ConfigurableListableBeanFactory beanFactory = context.getBeanFactory(); //6. 注册args参数为单例bean beanFactory.registerSingleton("springApplicationArguments", applicationArguments); if (printedBanner != null) { // 7. 注册banner为单例 beanFactory.registerSingleton("springBootBanner", printedBanner); } //8. 设置 beanFactory 中能够笼罩定义 bean if (beanFactory instanceof DefaultListableBeanFactory) { ((DefaultListableBeanFactory) beanFactory) .setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding); } //9. 启用懒加载所有bean：在spring启动时不会加载bean，会在应用时进行加载 if (this.lazyInitialization) { context.addBeanFactoryPostProcessor(new LazyInitializationBeanFactoryPostProcessor()); } //10 加载 main 办法所在的主类 Set<Object> sources = getAllSources(); Assert.notEmpty(sources, "Sources must not be empty"); //11 将主类加载进beanFactory中 load(context, sources.toArray(new Object[0])); //12 触发contextLoade事件 listeners.contextLoaded(context); } /** * SpringApplication 中 * 2. 设置 applicationContext */ protected void postProcessApplicationContext(ConfigurableApplicationContext context) { //2.1 注册 bean 名称生成器 if (this.beanNameGenerator != null) { context.getBeanFactory().registerSingleton(AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR, this.beanNameGenerator); } //2.2 为上下文设置 资源加载器resourceLoader 和 classLoader if (this.resourceLoader != null) { if (context instanceof GenericApplicationContext) { ((GenericApplicationContext) context).setResourceLoader(this.resourceLoader); } if (context instanceof DefaultResourceLoader) { ((DefaultResourceLoader) context).setClassLoader(this.resourceLoader.getClassLoader()); } } //2.3 注册类型转换服务：ConversionService if (this.addConversionService) { context.getBeanFactory().setConversionService(ApplicationConversionService.getSharedInstance()); } } /** * SpringApplication 中 * 3. 调用 ApplicationContextInitializer 初始化接口 */ protected void applyInitializers(ConfigurableApplicationContext context) { for (ApplicationContextInitializer initializer : getInitializers()) { // 查看泛型的类型与context统一 Class<?> requiredType = GenericTypeResolver.resolveTypeArgument(initializer.getClass(), ApplicationContextInitializer.class); Assert.isInstanceOf(requiredType, context, "Unable to call initializer."); initializer.initialize(context); } }2.5 加载或刷新 refreshContext
该办法次要是将应用程序中的bean注册到spring application context 中，也就是 BeanFactory 中，进行对立治理；并且在注册前后对bean 进行加强解决，如BeanDefinitionRegistryPostProcessor \`BeanFactoryPostProcessor` ，加强 bean 的注册。
/** * SpringApplication 中 */ private void refreshContext(ConfigurableApplicationContext context) { if (this.registerShutdownHook) { try { // 注册容器敞开钩子 context.registerShutdownHook(); } catch (AccessControlException ex) { // Not allowed in some environments. } } refresh((ApplicationContext) context); } /** * SpringApplication 中 * 加载或刷新springContext */ @Override public void refresh() throws BeansException, IllegalStateException { // 同步 synchronized (this.startupShutdownMonitor) { //1 筹备上下文刷新：将 applicationContext标记为 active状态 prepareRefresh(); //2 刷新 beanFactory ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory(); //3 筹备beanFactory，并手动注册一些bean、增加 BeanPostProcessor prepareBeanFactory(beanFactory); try { //4 对 beanFactory 进行后置解决，交由子类实现 postProcessBeanFactory(beanFactory); //5 调用曾经注册的BeanFactoryPostProcessors：如从xml中以及用scan扫描java config、Component、configuration加载java bean Definition到beanFactory中 invokeBeanFactoryPostProcessors(beanFactory); //6 注册 BeanPostProcessor，仅仅是注册，调用在getBean的时候 registerBeanPostProcessors(beanFactory); //7 初始化国际化资源 i18n initMessageSource(); //8 初始化事件播送器 initApplicationEventMulticaster(); //9 留给子类实现的刷新办法，在子类中，会创立对应的web容器：tomcat、jetty onRefresh(); //10 注册事件监听器 registerListeners(); //11 初始化非懒加载的bean finishBeanFactoryInitialization(beanFactory); //12 最初一步，实现刷新过程，公布利用事件 finishRefresh(); } catch (BeansException ex) { if (logger.isWarnEnabled()) { logger.warn("Exception encountered during context initialization - " + "cancelling refresh attempt: " + ex); } //产生异样，则将曾经初始化的bean登记掉 destroyBeans(); // Reset 'active' flag. // 勾销刷新，将active 置为false cancelRefresh(ex); // Propagate exception to caller. throw ex; } finally { // Reset common introspection caches in Spring's core, since we // might not ever need metadata for singleton beans anymore... // 将缓存清空 resetCommonCaches(); } } } 2.5.1 beanFactory 刷新筹备
将spring context 标记为激活状态（active），并且初始化和验证配置文件，保障配置能被正确解析和指定的配置属性必须存在。
/** * AbstractApplicationContext 中 * 1. 筹备刷新 */ protected void prepareRefresh() { // Switch to active. this.startupDate = System.currentTimeMillis(); //1.1 激活 this.closed.set(false); this.active.set(true); if (logger.isDebugEnabled()) { if (logger.isTraceEnabled()) { logger.trace("Refreshing " + this); } else { logger.debug("Refreshing " + getDisplayName()); } } // Initialize any placeholder property sources in the context environment. //1.2 在上下文环境中初始化配置的占位符，启动时为空实现 initPropertySources(); // Validate that all properties marked as required are resolvable: // see ConfigurablePropertyResolver#setRequiredProperties //1.3 对所有的必要属性进行验证，如果有必要的属性没有配置，则会抛出异样 getEnvironment().validateRequiredProperties(); //1.4 保留刷新之前的监听器 // Store pre-refresh ApplicationListeners... if (this.earlyApplicationListeners == null) { this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners); } else { // 将监听器的状态重置 // Reset local application listeners to pre-refresh state. this.applicationListeners.clear(); this.applicationListeners.addAll(this.earlyApplicationListeners); } //1.5 收集事件，一旦播送器筹备好就能够公布事件 // Allow for the collection of early ApplicationEvents, // to be published once the multicaster is available... this.earlyApplicationEvents = new LinkedHashSet<>(); }2.5.2 beanFactory 获取
/** * AbstractApplicationContext 中 */ protected ConfigurableListableBeanFactory obtainFreshBeanFactory() { //2.1 能够在该办法中刷新 beanFactory，如替换新的 beanFactory、重新配置 beanFactory等。 refreshBeanFactory(); //2.2 获取更新后的beanFactory return getBeanFactory(); }2.5.3 beanFactory 配置
/** * AbstractApplicationContext 中 * 3. 设置 beanFactory */ protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) { // Tell the internal bean factory to use the context's class loader etc. //3.1 设置类加载器 beanFactory.setBeanClassLoader(getClassLoader()); //3.2 设置el表达式解析器 beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader())); // beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment())); // Configure the bean factory with context callbacks. //3.3 增加 BeanPostProcessor ，实现与bean相干的XXXAware接口的注入工作 beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this)); //3.4 疏忽这些接口的实现类中的依赖主动注入（setter注入），接口的依赖由 ApplicationContextAwareProcessor 对立解决注入的接口。 beanFactory.ignoreDependencyInterface(EnvironmentAware.class); beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class); beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class); beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class); beanFactory.ignoreDependencyInterface(MessageSourceAware.class); beanFactory.ignoreDependencyInterface(ApplicationContextAware.class); //3.5 注册主动拆卸对象，这样BeanFactory/ApplicationContext尽管没有以bean的形式被定义在工厂中，也反对主动注入。 // BeanFactory interface not registered as resolvable type in a plain factory. // MessageSource registered (and found for autowiring) as a bean. beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory); beanFactory.registerResolvableDependency(ResourceLoader.class, this); beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this); beanFactory.registerResolvableDependency(ApplicationContext.class, this); //3.6 在 bean 初始化后，查看该bean是否为 ApplicationListener，如是则将其退出到SpringContext中 // Register early post-processor for detecting inner beans as ApplicationListeners. beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this)); // Detect a LoadTimeWeaver and prepare for weaving, if found. //3.7 https://www.cnblogs.com/wade-luffy/p/6078446.html if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) { beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory)); // Set a temporary ClassLoader for type matching. // 设置长期类加载器 beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader())); } //3.8 注册默认的环境单例对象 // Register default environment beans. if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) { beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment()); } if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) { beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties()); } if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) { beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment()); } }2.5.4 beanFactory 后置解决
/** * AbstractApplicationContext 中 * 对 beanFactory 进行后置解决，交由子类实现 */ protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) { }2.5.5 beanFactory 后置处理器调用
首先依据程序策略调用 BeanDefinitionRegistryPostProcessor 实现类。
之后依据程序策略调用 BeanFactoryPostProcessor 实现类， 同时实现了BeanDefinitionRegistryPostProcessor和BeanFactoryPostProcessor接口的实现类比只实现BeanFactoryPostProcessor接口的实现类先调用。
程序策略：优先调用实现了 PriorityOrdered 接口的实现类、在调用实现了 Ordered 接口的实现类，之后调用未实现后面两个接口的实现类。
BeanDefinitionRegistryPostProcessor接口提供了能够注册、删除BeanDefinition 的反对， BeanFactoryPostProcessor接口提供了增加或批改BeanDefinition 的属性反对。这两个接口执行时，操作的是 BeanDefinition，这时 bean 还未被实例化的。
在 createApplicationContext 办法中会加载 ConfigurationClassPostProcessor 、AutowiredAnnotationBeanPostProcessor、CommonAnnotationBeanPostProcessor，这几个 beanFactory 后置处理器将会在这里执行，进行扫描须要由spring治理的 BeanDefinition 。
/** * AbstractApplicationContext 中 * 5. 调用beanFactory后置处理器 */ protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) { //5.1 理论调用 PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors()); // Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime // (e.g. through an @Bean method registered by ConfigurationClassPostProcessor) if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) { beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory)); beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader())); } } /** * PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors * 5.1 调用beanFactory后置处理器 * 后置处理器的执行流程 */ public static void invokeBeanFactoryPostProcessors( ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) { // Invoke BeanDefinitionRegistryPostProcessors first, if any. Set<String> processedBeans = new HashSet<>(); // beanFactory 是BeanDefinitionRegistry类型 if (beanFactory instanceof BeanDefinitionRegistry) { BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory; // 惯例的BeanFactoryPostProcessor List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>(); // BeanDefinitionRegistryPostProcessor类型的对象 List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>(); for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) { // 为BeanDefinitionRegistryPostProcessor实现类设置BeanDefinitionRegistry if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) { BeanDefinitionRegistryPostProcessor registryProcessor = (BeanDefinitionRegistryPostProcessor) postProcessor; registryProcessor.postProcessBeanDefinitionRegistry(registry); registryProcessors.add(registryProcessor); } else { regularPostProcessors.add(postProcessor); } } // Do not initialize FactoryBeans here: We need to leave all regular beans // uninitialized to let the bean factory post-processors apply to them! // Separate between BeanDefinitionRegistryPostProcessors that implement // PriorityOrdered, Ordered, and the rest. List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>(); // 获取 BeanDefinitionRegistryPostProcessor 类型的bean名称汇合， // 首先执行实现了 PriorityOrdered 接口的 BeanDefinitionRegistryPostProcessor 实现类。 // First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered. String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false); for (String ppName : postProcessorNames) { // 将实现了PriorityOrdered的 BeanDefinitionRegistryPostProcessor 对象退出汇合 if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) { currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class)); processedBeans.add(ppName); } } // 对实现了PriorityOrdered的 BeanDefinitionRegistryPostProcessor 进行排序 sortPostProcessors(currentRegistryProcessors, beanFactory); // 退出到 registryProcessors 汇合中，对 注册处理器进行汇总 registryProcessors.addAll(currentRegistryProcessors); // 调用钩子：BeanDefinitionRegistryPostProcessor#postProcessBeanDefinitionRegistry // bean定义曾经被加载，然而没有实例化的，容许增加自定义的bean定义 invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry); currentRegistryProcessors.clear(); // Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered. postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false); // 执行实现了 Ordered 接口的 BeanDefinitionRegistryPostProcessor 。 for (String ppName : postProcessorNames) { if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) { currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class)); processedBeans.add(ppName); } } // 排序 sortPostProcessors(currentRegistryProcessors, beanFactory); // 退出到 registryProcessors 汇合中，对 注册处理器进行汇总 registryProcessors.addAll(currentRegistryProcessors); // 调用钩子：BeanDefinitionRegistryPostProcessor#postProcessBeanDefinitionRegistry // 实现 PriorityOrdered 接口比实现 Ordered 接口的实现类先执行 invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry); // 清空以后汇合 currentRegistryProcessors.clear(); // 执行其余的 BeanDefinitionRegistryPostProcessors 。 // Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear. boolean reiterate = true; while (reiterate) { reiterate = false; postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false); for (String ppName : postProcessorNames) { if (!processedBeans.contains(ppName)) { currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class)); processedBeans.add(ppName); reiterate = true; } } // 排序，而后执行，再清空。 sortPostProcessors(currentRegistryProcessors, beanFactory); registryProcessors.addAll(currentRegistryProcessors); invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry); currentRegistryProcessors.clear(); } // 执行 BeanFactoryPostProcessor 和 BeanDefinitionRegistryPostProcessor 的独特实现类的 postProcessBeanFactory()。 // 所有的bean 定义曾经被加载，能够增加或批改其中的属性值，在 BeanDefinitionRegistryPostProcessor#postProcessBeanDefinitionRegistry 前面执行。 // 保障 spring 提供的 BeanFactoryPostProcessor 实现类先被执行 // Now, invoke the postProcessBeanFactory callback of all processors handled so far. invokeBeanFactoryPostProcessors(registryProcessors, beanFactory); invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory); } else { // Invoke factory processors registered with the context instance. invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory); } // 执行其余未执行 postProcessBeanFactory() 办法的 BeanFactoryPostProcessor实现类。 // Do not initialize FactoryBeans here: We need to leave all regular beans // uninitialized to let the bean factory post-processors apply to them! String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false); // Separate between BeanFactoryPostProcessors that implement PriorityOrdered, // Ordered, and the rest. List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>(); List<String> orderedPostProcessorNames = new ArrayList<>(); List<String> nonOrderedPostProcessorNames = new ArrayList<>(); for (String ppName : postProcessorNames) { if (processedBeans.contains(ppName)) { // skip - already processed in first phase above } else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) { priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class)); } else if (beanFactory.isTypeMatch(ppName, Ordered.class)) { orderedPostProcessorNames.add(ppName); } else { nonOrderedPostProcessorNames.add(ppName); } } // First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered. sortPostProcessors(priorityOrderedPostProcessors, beanFactory); invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory); // Next, invoke the BeanFactoryPostProcessors that implement Ordered. List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size()); for (String postProcessorName : orderedPostProcessorNames) { orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class)); } sortPostProcessors(orderedPostProcessors, beanFactory); invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory); // Finally, invoke all other BeanFactoryPostProcessors. List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size()); for (String postProcessorName : nonOrderedPostProcessorNames) { nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class)); } invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory); // Clear cached merged bean definitions since the post-processors might have // modified the original metadata, e.g. replacing placeholders in values... beanFactory.clearMetadataCache(); }2.5.6 beanFactory 注册BeanPostProcessors
注册BeanPostProcessor 实现，BeanPostProcessor反对对bean进行加强，在bean创立前后进行非凡操作。
/** * postProcessBeforeInitialization：在创立好bean之后执行，反对在bean创立后进行加强，比方批改bean的属性、应用代理进行代理。 * * postProcessAfterInitialization：在执行了bean的 init 办法后执行（实现了`InitializingBean#afterPropertiesSet()`接口或xml配置中指定了init-method 属性的bean）。 * postProcessAfterInitialization 办法与 postProcessBeforeInitialization 办法一样，只是执行机会不一样，一个是在执行init办法之前，一个是在init办法之后。 */ public interface BeanPostProcessor { /** * InitializingBean#afterPropertiesSet() 之前执行 */ @Nullable default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { return bean; } /** * InitializingBean#afterPropertiesSet() 之后执行 */ @Nullable default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { return bean; }}注册 BeanPostProcessors。
/** * * AbstractApplicationContext 中 */ protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) { PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this); } /** * PostProcessorRegistrationDelegate.registerBeanPostProcessors * 5.1 向BeanFactory 注册 BeanPostProcessors */ public static void registerBeanPostProcessors( ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) { // 获取BeanPostProcessor 实现类的bean名称 String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false); // Register BeanPostProcessorChecker that logs an info message when // a bean is created during BeanPostProcessor instantiation, i.e. when // a bean is not eligible for getting processed by all BeanPostProcessors. // 记录bean处理器的总数，用于记录执行过的处理器与记录的处理器个数是否统一 int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length; beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount)); // Separate between BeanPostProcessors that implement PriorityOrdered, // Ordered, and the rest. // 将处理器依照实现的接口进行拆分。 // 实现了PriorityOrdered接口的BeanPostProcessor List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>(); // 外部BeanPostProcessor，也就是实现了MergedBeanDefinitionPostProcessor接口的类 List<BeanPostProcessor> internalPostProcessors = new ArrayList<>(); // 实现类Order接口的类 List<String> orderedPostProcessorNames = new ArrayList<>(); // 未实现Order接口的类 List<String> nonOrderedPostProcessorNames = new ArrayList<>(); for (String ppName : postProcessorNames) { if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) { BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class); priorityOrderedPostProcessors.add(pp); // 记录外部BeanPostProcessor if (pp instanceof MergedBeanDefinitionPostProcessor) { internalPostProcessors.add(pp); } } else if (beanFactory.isTypeMatch(ppName, Ordered.class)) { orderedPostProcessorNames.add(ppName); } else { nonOrderedPostProcessorNames.add(ppName); } } // First, register the BeanPostProcessors that implement PriorityOrdered. // 排序并注册实现了PriorityOrdered接口的BeanPostProcessors，包含了外部BeanPostProcessors sortPostProcessors(priorityOrderedPostProcessors, beanFactory); registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors); // Next, register the BeanPostProcessors that implement Ordered. // 排序并注册实现了Ordered接口的BeanPostProcessors List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size()); for (String ppName : orderedPostProcessorNames) { BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class); orderedPostProcessors.add(pp); // 记录外部BeanPostProcessor if (pp instanceof MergedBeanDefinitionPostProcessor) { internalPostProcessors.add(pp); } } sortPostProcessors(orderedPostProcessors, beanFactory); registerBeanPostProcessors(beanFactory, orderedPostProcessors); // 注册未实现Order接口的BeanPostProcessors // Now, register all regular BeanPostProcessors. List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size()); for (String ppName : nonOrderedPostProcessorNames) { BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class); nonOrderedPostProcessors.add(pp); // 记录外部BeanPostProcessor if (pp instanceof MergedBeanDefinitionPostProcessor) { internalPostProcessors.add(pp); } } registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors); // 排序并从新注册外部BeanPostProcessors // Finally, re-register all internal BeanPostProcessors. sortPostProcessors(internalPostProcessors, beanFactory); registerBeanPostProcessors(beanFactory, internalPostProcessors); // 将监听器后置处理器注册在最初，以记录监听器。 // Re-register post-processor for detecting inner beans as ApplicationListeners, // moving it to the end of the processor chain (for picking up proxies etc). beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext)); }2.5.7 初始化MessageSource
初始化 MessageSource，将 MessageSource委托给 DelegatingMessageSource，并注册进 beanFactory 中
/** * AbstractApplicationContext 中 */ protected void initMessageSource() { ConfigurableListableBeanFactory beanFactory = getBeanFactory(); if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) { this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class); // Make MessageSource aware of parent MessageSource. if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) { HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource; if (hms.getParentMessageSource() == null) { // Only set parent context as parent MessageSource if no parent MessageSource // registered already. hms.setParentMessageSource(getInternalParentMessageSource()); } } if (logger.isTraceEnabled()) { logger.trace("Using MessageSource [" + this.messageSource + "]"); } } else { // Use empty MessageSource to be able to accept getMessage calls. DelegatingMessageSource dms = new DelegatingMessageSource(); dms.setParentMessageSource(getInternalParentMessageSource()); this.messageSource = dms; beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource); if (logger.isTraceEnabled()) { logger.trace("No '" + MESSAGE_SOURCE_BEAN_NAME + "' bean, using [" + this.messageSource + "]"); } } }2.5.8 初始化事件播送器
/** * 注册事件播送器，默认应用 SimpleApplicationEventMulticaster */ protected void initApplicationEventMulticaster() { ConfigurableListableBeanFactory beanFactory = getBeanFactory(); if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) { this.applicationEventMulticaster = beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class); if (logger.isTraceEnabled()) { logger.trace("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]"); } } else { this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory); beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster); if (logger.isTraceEnabled()) { logger.trace("No '" + APPLICATION_EVENT_MULTICASTER_BEAN_NAME + "' bean, using " + "[" + this.applicationEventMulticaster.getClass().getSimpleName() + "]"); } } }2.5.9 初始化其余非凡bean
// AbstractApplicationContext protected void onRefresh() throws BeansException { // For subclasses: do nothing by default. } // ServletWebServerApplicationContext @Override protected void onRefresh() { super.onRefresh(); try { createWebServer(); } catch (Throwable ex) { throw new ApplicationContextException("Unable to start reactive web server", ex); } } // ServletWebServerApplicationContext，创立web服务 private void createWebServer() { WebServerManager serverManager = this.serverManager; if (serverManager == null) { String webServerFactoryBeanName = getWebServerFactoryBeanName(); ReactiveWebServerFactory webServerFactory = getWebServerFactory(webServerFactoryBeanName); boolean lazyInit = getBeanFactory().getBeanDefinition(webServerFactoryBeanName).isLazyInit(); this.serverManager = new WebServerManager(this, webServerFactory, this::getHttpHandler, lazyInit); getBeanFactory().registerSingleton("webServerGracefulShutdown", new WebServerGracefulShutdownLifecycle(this.serverManager)); getBeanFactory().registerSingleton("webServerStartStop", new WebServerStartStopLifecycle(this.serverManager)); } initPropertySources(); }2.5.10 注册事件到事件播送器中
注册事件监听器，并公布晚期事件
/** * AbstractApplicationContext */ protected void registerListeners() { // 注册在spring boot启动时创立的监听器实例到事件播送器中： // SpringApplication#prepareContext() 和 SpringApplication#applyInitializers() 中执行 // ApplicationContextInitializer#initialize 时，增加的监听器 for (ApplicationListener<?> listener : getApplicationListeners()) { getApplicationEventMulticaster().addApplicationListener(listener); } // 查找利用中ApplicationListener实现类，获取beanName，注册到播送器中 String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false); for (String listenerBeanName : listenerBeanNames) { getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName); } // 播送在之前捕捉到的事件（在容器初始化完bean前公布的事件将会暂存在earlyApplicationEvents中，进行提早公布） // Publish early application events now that we finally have a multicaster... Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents; // 这之后的事件都间接公布，不在暂存到earlyApplicationEvents中进行提早公布 this.earlyApplicationEvents = null; if (!CollectionUtils.isEmpty(earlyEventsToProcess)) { for (ApplicationEvent earlyEvent : earlyEventsToProcess) { getApplicationEventMulticaster().multicastEvent(earlyEvent); } } }2.5.11 实例化残余非lazy load bean
除懒加载标记的bean外，都将在这一步进行实例化。
/** * Finish the initialization of this context's bean factory, * initializing all remaining singleton beans. */ protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) { // Initialize conversion service for this context. // 注册类型转换服务：ConversionService，在 SpringApplication#postProcessApplicationContext 中默认曾经注册 // 这里进行再次查看 if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) && beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) { beanFactory.setConversionService( beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)); } // Register a default embedded value resolver if no bean post-processor // (such as a PropertyPlaceholderConfigurer bean) registered any before: // at this point, primarily for resolution in annotation attribute values. // 再次查看是否有字符串转换器：StringValueResolver，没有则将解析委托给 PropertySourcesPropertyResolver if (!beanFactory.hasEmbeddedValueResolver()) { beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal)); } // 先创立LoadTimeWeaverAware 类型的实例 bean // Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early. String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false); for (String weaverAwareName : weaverAwareNames) { getBean(weaverAwareName); } // 将长期类加载器置空 // Stop using the temporary ClassLoader for type matching. beanFactory.setTempClassLoader(null); // 容许缓存 bean definition // Allow for caching all bean definition metadata, not expecting further changes. beanFactory.freezeConfiguration(); // 实例化不是懒加载的bean // Instantiate all remaining (non-lazy-init) singletons. beanFactory.preInstantiateSingletons(); } /** * 实例化单例对象 */ @Override public void preInstantiateSingletons() throws BeansException { if (logger.isTraceEnabled()) { logger.trace("Pre-instantiating singletons in " + this); } // Iterate over a copy to allow for init methods which in turn register new bean definitions. // While this may not be part of the regular factory bootstrap, it does otherwise work fine. List<String> beanNames = new ArrayList<>(this.beanDefinitionNames); // 创立非懒加载的实例对象 // Trigger initialization of all non-lazy singleton beans... for (String beanName : beanNames) { // 获取顶层bean定义 RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName); // 不是形象、单例、非懒加载 if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) { // 判断是否是工程bean if (isFactoryBean(beanName)) { // 如果是工程bean，则增加前缀进行查找 Object bean = getBean(FACTORY_BEAN_PREFIX + beanName); if (bean instanceof FactoryBean) { FactoryBean<?> factory = (FactoryBean<?>) bean; // 是否立刻创立bean boolean isEagerInit; if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) { isEagerInit = AccessController.doPrivileged( (PrivilegedAction<Boolean>) ((SmartFactoryBean<?>) factory)::isEagerInit, getAccessControlContext()); } else { isEagerInit = (factory instanceof SmartFactoryBean && ((SmartFactoryBean<?>) factory).isEagerInit()); } // 如果须要立刻创立，则马上创立 if (isEagerInit) { getBean(beanName); } } } else { // 非 beanFactory 的，则马上创立 getBean(beanName); } } } // Trigger post-initialization callback for all applicable beans... for (String beanName : beanNames) { // 获取单例对象，如果这个对象是 SmartInitializingSingleton 接口的实现类， // 则调用 afterSingletonsInstantiated() 办法 Object singletonInstance = getSingleton(beanName); if (singletonInstance instanceof SmartInitializingSingleton) { SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance; if (System.getSecurityManager() != null) { AccessController.doPrivileged((PrivilegedAction<Object>) () -> { smartSingleton.afterSingletonsInstantiated(); return null; }, getAccessControlContext()); } else { smartSingleton.afterSingletonsInstantiated(); } } } }2.5.12 最初一步刷新实现
/** * AbstractApplicationContext */ protected void finishRefresh() { // 革除上下文中的资源缓存 // Clear context-level resource caches (such as ASM metadata from scanning). clearResourceCaches(); // 注册 LifecycleProcessor 接口实现类，默认应用 DefaultLifecycleProcessor // Initialize lifecycle processor for this context. initLifecycleProcessor(); // 触发刚刚注册的 LifecycleProcessor 接口实现类的 onRefresh 事件 // Propagate refresh to lifecycle processor first. getLifecycleProcessor().onRefresh(); // 公布上下文刷新实现事件 // Publish the final event. publishEvent(new ContextRefreshedEvent(this)); // 想bean视图注册上下文对象。 // Participate in LiveBeansView MBean, if active. LiveBeansView.registerApplicationContext(this); }总结
spring boot 启动流程次要通过初始化和加载监听器、筹备应用程序环境（配置信息）、创立容器上下文、刷新容器上下文，其中最要害的是刷新上下文 refresh。在刷新上下文中，加载 BeanFactoryPostProcessor，应用 BeanFactoryPostProcessor加载程序中须要注入的BeanDefinition，筹备事件播送器，最初创立单例并且不是懒加载的bean。
spring提供的后置处理器执行程序：
BeanDefinitionRegistryPostProcessor#postProcessBeanDefinitionRegistry(BeanDefinitionRegistry)动静注册、批改与删除
BeanDefinitionBeanFactoryPostProcessor#postProcessBeanFactory(ConfigurableListableBeanFactory)增加或批改
BeanDefinition的属性doCreateBean创立bean
- 对bean注入依赖
BeanPostProcessor#postProcessBeforeInitialization()创立 bean 之后，在对bean 进行注入依赖对象后，调用这个 bean 后置处理器。
InitializingBean#afterPropertiesSetspring提供的 bean 进行初始化接口
BeanPostProcessor#postProcessAfterInitialization()在
bean初始化实现后执行。如果是
InitializingBean的实现类，则在afterPropertiesSet办法执行后执行，否则在BeanPostProcessor#postProcessBeforeInitialization()之后执行。