首页  思维导图  详情

springboot启动流程详解

2023-02-28 18:08:06   0  举报





AI智能生成

基于spring-webmvc的springboot2.5版本启动流程。涉及spring spi，BeanDifition，FactoryBean/常规Bean的后置处理，Spring三级缓存部分解决循环依赖，spring常用扩展点

spring启动流程

spring三级缓存

spring扩展点

BeanFactoryPostProcessor

BeanPostProcessor

作者其他创作

大纲/内容

SpringApplication实例化
(以下简称SA实例)

属性：this.resourceLoader。ResourceLoader

属性：this.primarySources。Set<Class<?>>

属性：this.webApplicationType。WebApplicationType

WebApplicationType.deduceFromClasspath()

WebApplicationType.NONE

WebApplicationType.SERVLET (spring-webmvc.jar)

WebApplicationType.REACTIVE(spring-webflux.jar)

属性：this.bootstrapRegistryInitializers。ArrayList<BootstrapRegistryInitializer>

getBootstrapRegistryInitializersFromSpringFactories

getSpringFactoriesInstances

SpringFactoriesLoader.loadFactoryNames

loadSpringFactories

createSpringFactoriesInstances

AnnotationAwareOrderComparator.sort

方法：setInitializers

getSpringFactoriesInstances(ApplicationContextInitializer.class)

方法：setListeners

getSpringFactoriesInstances(ApplicationListener.class)

属性：this.mainApplicationClass。Class<?>

deduceMainApplicationClass()

执行run方法

DefaultBootstrapContext bootstrapContext = createBootstrapContext();

创建内部变量 DefaultBootstrapContext

implements interface ConfigurableBootstrapContext

extends interface BootstrapRegistry

extends interface BootstrapContext

createBootstrapContext()

遍历SA实例的引导注册器实例列表（bootstrapRegistryInitializers）。
对列表例的实例，使用DefaultBootstrapContext入参进行初始化。initialize(BootstrapRegistry ）

参考例子org.springframework.cloud.netflix.eureka.config.EurekaConfigServerBootstrapper

configureHeadlessProperty()

SpringApplicationRunListeners listeners

getRunListeners(args)

listeners.starting(bootstrapContext, this.mainApplicationClass)

例子：org.springframework.boot.context.event.EventPublishingRunListener

ApplicationArguments applicationArguments = new DefaultApplicationArguments(args)

ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, applicationArguments)

ConfigurableEnvironment关系

extends Environment,

extends PropertyResolver

extends ConfigurablePropertyResolver

extends PropertyResolver

getOrCreateEnvironment()推断应用环境，这里是
ApplicationServletEnvironment对象

configureEnvironment(environment, applicationArguments.getSourceArgs())

如果有ConversionService
设置环境setConversionService

configurePropertySources(environment, args)

configureProfiles(environment, args)

listeners.environmentPrepared(bootstrapContext, environment);

bindToSpringApplication

Banner printedBanner = printBanner(environment);

ConfigurableApplicationContext context = createApplicationContext();

ConfigurableApplicationContext ; interface

extends ApplicationContext

extends EnvironmentCapable

extends ListableBeanFactory

extends BeanFactory

extends HierarchicalBeanFactory

extends BeanFactory

extends MessageSource

extends ApplicationEventPublisher

extends ResourcePatternResolver

extends ResourceLoader

extends Lifecycle

extends Closeable

extends AutoCloseable

createApplicationContext()

ApplicationContextFactory applicationContextFactory = ApplicationContextFactory.DEFAULT;

return this.applicationContextFactory.create(this.webApplicationType);

AnnotationConfigServletWebServerApplicationContext

关系

extends ServletWebServerApplicationContext

extends GenericWebApplicationContext

extends GenericApplicationContext

extends AbstractApplicationContext

extends DefaultResourceLoader

implements ResourceLoader

implements ConfigurableApplicationContext

详见上文 ConfigurableApplicationContext关系

implements BeanDefinitionRegistry

extends AliasRegistry

implements ConfigurableWebApplicationContext

extends WebApplicationContext

extends ConfigurableApplicationContext

详见上文 ConfigurableApplicationContext关系

implements ThemeSource

implements ConfigurableWebServerApplicationContext

extends ConfigurableApplicationContext

详见上文 ConfigurableApplicationContext关系

extends WebServerApplicationContext

extends ApplicationContext

详见上文 ApplicationContext关系

implements AnnotationConfigRegistry

属性：AnnotatedBeanDefinitionReader reader

属性：ClassPathBeanDefinitionScanner scanner

默认构造方法 AnnotationConfigServletWebServerApplicationContext()

初始化父类的父类的父类属性beanFactory 为DefaultListableBeanFactory实例

DefaultListableBeanFactory实例

DefaultListableBeanFactory

extends AbstractAutowireCapableBeanFactory

extends AbstractBeanFactory

extends FactoryBeanRegistrySupport

extends DefaultSingletonBeanRegistry

extends SimpleAliasRegistry

implements AliasRegistry

implements SingletonBeanRegistry

implements ConfigurableBeanFactory

extends HierarchicalBeanFactory

extends BeanFactory

extends SingletonBeanRegistry

implements AutowireCapableBeanFactory

extends BeanFactory

implements ConfigurableListableBeanFactory

extends ListableBeanFactory

extends BeanFactory

extends AutowireCapableBeanFactory

extends BeanFactory

extends ConfigurableBeanFactory

关系见上文 implements ConfigurableBeanFactory

implements BeanDefinitionRegistry

extends AliasRegistry

implements Serializable

this.reader = new AnnotatedBeanDefinitionReader(this)

AnnotatedBeanDefinitionReader(BeanDefinitionRegistry, Environment )

this.conditionEvaluator = new ConditionEvaluator(registry, environment, null)

AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry)

创建各种注解配置类的发布处理器（AnnotationProcessor）实例，并设置为rootBeanDefition
注册到beanFactory的属性beanDefinitionMap

k: org.springframework.context.annotation.internalConfigurationAnnotationProcessor
v: ConfigurationClassPostProcessor.class

k: org.springframework.context.annotation.internalAutowiredAnnotationProcessor
v: AutowiredAnnotationBeanPostProcessor.class

k: org.springframework.context.annotation.internalCommonAnnotationProcessor
v: CommonAnnotationBeanPostProcessor.class

k: org.springframework.context.event.internalEventListenerProcessor
v: EventListenerMethodProcessor.class

k: org.springframework.context.event.internalEventListenerFactory
v: DefaultEventListenerFactory

小结：初始化beanFactory实例的各种属性，如beanDeafintionNames, beanDeanfintionMaps

this.scanner = new ClassPathBeanDefinitionScanner(this)

因为spring-webmvc的配置应用上下文是AnnotationConfigServletWebServerApplicationContext
且其上级关系实现了接口BeanDefinitionRegistry，所以上述的this是AnnotationConfigServletWebServerApplicationContext对象

小结：AnnotationConfigServletWebServerApplicationContext有很长的父级链路，其初始化的过程中，父级链路类也初始化。例如父级GenericApplicationContext初始化beanFactroy为DefaultListableBeanFactory，DefaultListableBeanFactory创建过程中又初始化了父类AbstractBeanFactory 的属性beanClassLoader = ClassUtils.getDefaultClassLoader() 实现加载了所有的class资源。AbstractBeanFactory初始化过程中又触发了DefaultSingletonBeanRegistry父类，其中属性singletonObjects,earlySingletonObjects,singletonFactories 是spring的三级缓存；singletonObjects存放所有完成实例化的bean。整个阶段其实是spring ioc容器初始化的阶段

context.setApplicationStartup(this.applicationStartup);

prepareContext(DefaultBootstrapContext , ConfigurableApplicationContext ,
ConfigurableEnvironment , SpringApplicationRunListeners ,
ApplicationArguments , Banner )

context.setEnvironment(environment);

postProcessApplicationContext(context)

applyInitializers(ConfigurableApplicationContext )

listeners.contextPrepared(context);

bootstrapContext.close(context);

load(ApplicationContext , Object[] )

BeanDefinitionLoader loader = BeanDefinitionLoader createBeanDefinitionLoader(BeanDefinitionRegistry , Object[] )

loader.load()

load(Class<?> )

针对符合GroovyBeanDefinitionSource.class可用

针对注解类bean注册器使用

this.annotatedReader.register(source)
这里的source是启动类

doRegisterBean(Class<?>, null, null, null, null)

创建AnnotatedGenericBeanDefinition
作用定义mateDatal类属性为StandardAnnotationMetadata
把启动类所有注解类赋值到annotationTypes 等等

setBeanClass(beanClass);
beanClass 是启动类

AnnotationMetadata.introspect(Class<?> type)

StandardAnnotationMetadata.from(type)

StandardAnnotationMetadata(Class<?> introspectedClass, boolean nestedAnnotationsAsMap)

MergedAnnotations from(AnnotatedElement element, SearchStrategy searchStrategy,
RepeatableContainers repeatableContainers, AnnotationFilter annotationFilter)

MergedAnnotations实现类 TypeMappedAnnotations方法
from(AnnotatedElement element, SearchStrategy searchStrategy,
RepeatableContainers repeatableContainers, AnnotationFilter annotationFilter)

AnnotationsScanner.isKnownEmpty(element, searchStrategy)
这里的element是启动类

AnnotationsScanner。getDeclaredAnnotations(AnnotatedElement source, boolean defensive)
这里的source是启动类

调用启动类的Clss类方法getDeclaredAnnotations，获取启动类所有注解信息

完成创建AnnotatedGenericBeanDefinition adb

创建definitionHolder ， adb 为上述AnnotatedGenericBeanDefinition，beanName为启动类
BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);

把definitionHolder 赋值到应用上下文里的beanFactory的beanDefitionMaps，完成注册bean工作
BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);

load(Resource )

load(Package )

load(CharSequence)

listeners.contextLoaded(context)

refreshContext(ConfigurableApplicationContext )

调用ConfigurableApplicationContext的父类AbstractApplicationContext方法refresh()

refresh(); springboot启动流程中最主要复杂的处理方法

prepareRefresh()

上下文状态设置 AbstractApplicationContext

initPropertySources()

getEnvironment().validateRequiredProperties()

this.earlyApplicationListeners
this.applicationListeners

this.earlyApplicationEvents = new LinkedHashSet<>()

ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory()

prepareBeanFactory(beanFactory)

postProcessBeanFactory(beanFactory)

子类实现方法，如GenericWebApplicationContext

invokeBeanFactoryPostProcessors(beanFactory)
实例化所有已注册BeanFactoryPostProcessor的bean

PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors())

Invoke BeanDefinitionRegistryPostProcessors

Set<String> processedBeans = new HashSet<>() 已处理的bean

遍历入参beanFactoryPostProcessors，获取postProcessor。分别判断是否BeanDefinitionRegistryPostProcessor实例。
是则执行.postProcessBeanDefinitionRegistry(registry)。并加入registryProcessors，否则加入常规regularPostProcessors

List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>()
创建临时注解列表 currentRegistryProcessors。这里不实例化FactoryBeans，为了让常规bean在beanFactroy
做后置处理，例如PriorityOrdered, Ordered, 或者rest

寻找实现了PriorityOrdered.class 的BeanDefinitionRegistryPostProcessor

执行postProcessorNames =beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false)
从此前createApplicationContext()里执行registerAnnotationConfigProcessors的结果里，获取
org.springframework.context.annotation.ConfigurationClassPostProcessor，
这个是BeanFactoryPostProcessor的子类BeanDefinitionRegistryPostProcessor接口的实现类（ConfigurationClassPostProcessor）

判断ConfigurationClassPostProcessor是否PriorityOrdered.class实现类（是）

是则执行beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class)，创建ConfigurationClassPostProcessor实例
并且把ConfigurationClassPostProcessor 加入currentRegistryProcessors，作为invokeBeanDefinitionRegistryPostProcessors 的参数使用

getBean是一个核心方法，里面有spring三级缓存解决循环依赖的原理

以ConfigurationClassPostProcessor为例子，解析invokeBeanDefinitionRegistryPostProcessors 方法。其核心是执行
BeanDefinitionRegistryPostProcessor接口实现类的方法postProcessBeanDefinitionRegistry。实现应用上下文初始化之后，
在beanDefition注册到beanFactoy前，对beanDefition进行修改。此时bean还没有实例化

ConfigurationClassPostProcessor实现接口方法：
processConfigBeanDefinitions(BeanDefinitionRegistry )，
其作用是从配置类里面派生更多的bean

获取beanFatroy所有beanDefitionNames

判断beanDefition是否configurationClass属性，是则加入configCandidates
最后判断启动类有AnnotatedGenericBeanDefinition（上述prepareContext时候设置）

初始化ConfigurationClassParser(MetadataReaderFactory,
ProblemReporter, Environment , ResourceLoader ,
BeanNameGenerator , BeanDefinitionRegistry )对象

执行prase(configCandidates) 方法

最终执行是AnnotatedBeanDefinition类的prase方法

processConfigurationClass(ConfigurationClass , Predicate<String> )

SourceClass doProcessConfigurationClass(
ConfigurationClass, SourceClass, Predicate<String> )
ConfigurationClass为启动类的封装 SourceClass对象是启动类

处理所有 @PropertySource 注解，创建PropertySource对象加入到Environment对象中

处理所有 @ComponentScan 注解，最终创建所有注解类的beanDefintion

AnnotationConfigUtils.attributesForRepeatable(
AnnotationMetadata metadata, String containerClassName, String annotationClassName)
其中 metadata为启动类的beanDefition属性StandardAnnotationMetadata

执行StandardAnnotationMetadata 方法getAnnotationAttributes(String annotationName,
boolean classValuesAsString)

通过递归获取@ComponentScan上所有信息，包括注解属性值。这里的重点是获取了启动类
@SpringBootApplication 的属性scanBasePackages = {"com.xxx"}
@SpringBootApplication包含@SpringBootConfiguration包含@Configuration包含@Component

ComponentScanAnnotationParser.parse(AnnotationAttributes componentScan, String declaringClass)
componentScan 为上述所有扫描信息，包括属性。 declaringClass为启动类

pars方法里获取basePackageClasses 即com.xxx ，然后执行ClassPathBeanDefinitionScanner.doScan(String... basePackages)

findCandidateComponents(basePackage), 查找所有含注解@Component 的类，包括注解内含@Component的注解类，
如@Configuration，@RestController，@Service

遍历所有含@Component的类，调用.generateBeanName(candidate, this.registry)，生成首字母为小写的beanName

如果是AbstractBeanDefinition的实例，判断是否需要注入其它bean，如果需要设置注入候选状态

如果是AnnotatedBeanDefinition的实例，判断是注解是否需要设置各种属性，例如lazy，dependsOn，role，description

registerBeanDefinition(definitionHolder, this.registry); 创建defitionHolder并注册到
应用上下文factroy属性 beanDefitionMaps

处理所有@Import 注解，过程与处理@ComponentScan相似

处理 @ImportResource注解，处理加载xml配置文件

收集所有@Bean 的方法

把收集到的方法或接口，注入到configuration class

寻找实现了Ordered.class 的BeanDefinitionRegistryPostProcessor，执行实现类invokeBeanDefinitionRegistryPostProcessors方法

最好寻找所有BeanDefinitionRegistryPostProcessors的实现类，执行invokeBeanDefinitionRegistryPostProcessors方法

invoke postProcessBeanFactory

概述：因为BeanDefinitionRegistryPostProcessor类扩展 BeanFactoryPostProcessor类
因此BeanDefinitionRegistryPostProcessor的实现类也实现BeanFactoryPostProcessor类的方法
postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) ，其核心是：
实现应用上下文初始化之后，在beanDefition注册到beanFactory后，对beanDefiotn进行增删改查
此时bean还没有实例化。

invokeBeanFactoryPostProcessors(registryProcessors, beanFactory)

invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory)

还是以ConfigurationClassPostProcessor为例子，实现接口
postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)

String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false)

查找实现BeanFactoryPostProcessor 的 bean

过滤已经处理过的beanFactoryPostProcessor
例如上述的ConfigurationClassPostProcessor

按顺序对继承PriorityOrdered.class，Ordered.class，没有任何继承的beanFactoryPostProcessor
执行其父类接口实现方法invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory)。
此过程与上述ConfigurationClassPostProcessor的例子一样

registerBeanPostProcessors(beanFactory);
实例化Bean处理器

过程与上述Invoke BeanDefinitionRegistryPostProcessors，invoke postProcessBeanFactory类似

String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
获取所有实现了BeanPostProcessor.class的类

添加BeanPostProcessorChecker 到 beanFactroy 的bean处理器（BeanPostProcessor）
BeanPostProcessorChecker用于bean实例化后的日志打印，和判断是否基础设施bean

遍历postProcessorNames，按照bean处理器实现类是否也实现PriorityOrdered，Ordered，无实现(常规)的顺序
收集到对应的bean处理器集合，此过程会同时实例化bean处理器，加入到IOC容器。并且判断是否实现MergedBeanDefinitionPostProcessor，并把实现了的加入对应的internal bean处理器集合。

在实例化的过程中，bean处理器会调用实现其父类接口（BeanPostProcessor.class）的方法
postProcessBeforeInitialization
postProcessAfterInitialization

依次对PriorityOrdered，Ordered，常规，internal bean处理器集合，作为参数，
调用PostProcessorRegistrationDelegate.registerBeanPostProcessors(ConfigurableListableBeanFactory , List<BeanPostProcessor> )
把已实例化的bean处理器，加入到beanFactory的beanPostProcessors

ApplicationListenerDetector 赋值当前应用上下文

initMessageSource()

initApplicationEventMulticaster()

onRefresh()
初始化应用上下文特殊的bean，这个方法给子类实现
这里继续用AnnotationConfigServletWebServerApplicationContext 为例子

调用父类GenericWebApplicationContext onRefresh 方法
进行web应用的主题资源初始化 initThemeSource

createWebServer()

从上下文获取webService，servletContext

如果都为空，走创建webService流程

调用getWebServerFactory()获取ServletWebServerFactory

从beanFactory的BeanDefitionMaps获取ServletWebServerFactory的定义是
tomcatServletWebServerFactory，然后调用工厂执行getBean方法，创建
TomcatServletWebServerFactory对象

TomcatServletWebServerFactory.getWebServer()
作用是启动tomcat服务

getBeanFactory().registerSingleton("webServerGracefulShutdown",
new WebServerGracefulShutdownLifecycle(this.webServer))

getBeanFactory().registerSingleton("webServerStartStop",
new WebServerStartStopLifecycle(this, this.webServer))

initPropertySources

registerListeners()

获取上下文所有ApplicationListener，使用ApplicationEventMulticaster，并把ApplicationListener加入到
ApplicationEventMulticaster的内部类DefaultListenerRetriever属性ApplicationListener集合

获取所有实现ApplicationListener.class 的beanName，并且加入
ApplicationEventMulticaster的内部类DefaultListenerRetriever属性applicationListenerBeans集合

发布在prepareRefresh()阶段应用上下文收集的早期应用事件earlyApplicationEvents

finishBeanFactoryInitialization(beanFactory)
遍历上下文beanFactory的beanDefitionMaps，对所有非抽象，非懒加载，单例的bean进行实例化

实例化实现ConversionService.class 的bean

为beanFactory 增加addEmbeddedValueResolver
例如PropertySourcesPlaceholderConfigurer bean

实例化实现LoadTimeWeaverAware.class 的bean

beanFactory.freezeConfiguration()
冻结beanDefitionMaps

beanFactory.preInstantiateSingletons()
beanDefitionMaps 的bean实例化

这里是应用上下文beanFactroy的实现类DefaultListableBeanFactory为例子解析

获取beanFactory 所有的beanDefinitionNames 元素

遍历beanDefinitionNames，根据beanName获取RootBeanDefinition

根据RootBeanDefinition 判断bean非抽象，非懒加载，是单例。开始实例化

根据RootBeanDefinition 判断是否工厂bean，如果是走工厂bean实例化流程AbstractBeanFactory.getBean

否则走常规bean实例化 AbstractBeanFactory.getbean

完成实例化后，判断bean是否实现SmartInitializingSingleton.class，是执行afterSingletonsInstantiated
实现bean实例化后，执行某些业务。这个阶段特定是IOC容器快要启动完成了

这个是常用扩展点，例如EventListenerMethodProcessor实现SmartInitializingSingleton，
完成@EventListener注解方式的事件监听

Spring Cloud Ribbon中，LoadBalancerAutoConfiguration实现SmartInitializingSingleton接口方法
对@LoadBalanced注解的RestTemplate对象利用RestTemplateCustomizer进行定制处理

单独说一下核心流程
AbstractBeanFactory.getBean(String name)

AbstractBeanFactory.doGetBean
Spring真正干活的都有一个do字

Object sharedInstance = getSingleton(beanName)
获取bean实例，也可能获取FactoryBean

DefaultSingletonBeanRegistry.getSingleton(beanName, true)
在Spring三级缓存那实例，流程如下

根据beanName从一级缓存singletonObjects获取bean实例（完成实例化且完成赋值的bean缓存，
狭义的spring容器，数据结构为ConcurrentHashMap<String,Object>）

如果一级缓存的bean实例为空，且bean实例在当前创建过程中，则进入后继流程。否则结束流程，返回为空对象

根据beanName从二级缓存earlySingletonObjects获取bean实例,存放未完成的bean实例（例如属性没有赋值）
的缓存，如果有代理的话，存放的是代理对象，数据结构为ConcurrentHashMap<String,Object>）

如果二级缓存的bean实例为非空，则返回bean实例。如果为空，且允许循环依赖，则继续流程

对singletonObjects加synchronized，且再次从singletonObjects 获取bean实例。
因此上游流程判断bean在当前创建中，有可能已经创建完毕，需要再次判断。
如果为非空，则结束流程，返回bean实例。否则继续流程

再次从二级缓存earlySingletonObjects获取bean实例，如果非空则结束流程，
返回bean实例，否则继续流程

根据beanName从三级缓存singletonFactories获取对应的singletonFactory，（数据结构是HashMap<String, ObjectFactory<?>>。
三级缓存是用于保存bean创建工厂，以便于后面扩展有机会创建代理对象）
如果singletonFactory为空，结束流程，返回空对象。如果singletonFactory为非空，直接在对象工厂getObject获取bean实例
（这里其实时会触发AbstractAutowireCapableBeanFactory。getEarlyBeanReference方法，此方法在加入三级缓存时候设置的），
然后把bean实例设置到二级缓存earlySingletonObjects，且删除singletonFactories对应的ObjectFactory，最后返回bean实例

如果sharedInstance 不为空

AbstractAutowireCapableBeanFactory.getObjectForBeanInstance(beanInstance, name, beanName, mbd)

String currentlyCreatedBean = this.currentlyCreatedBean.get()

如果currentlyCreatedBean非空，注册依赖bean
registerDependentBean(beanName, currentlyCreatedBean);

getObjectForBeanInstance(sharedInstance, name, beanName, mbd)
从bean实例获取对象，也有可能获取FactroyBean对象

判断beanName是否FactoryBeanName（beanName以&开头），如果是FactoryBeanName但又不是FactoryBean实例，
则抛异常。否则直接返回入参bean实例（符合FactoryBeanName的FactoryBean实例）

上游判断beanName已经不是FactoryBeanName，再判断是否非FactoryBean实例，
符合则直接返回bean实例（不符合FactoryBeanName的常规bean实例）

因此得到了不符合FactoryBeanName的FactoryBean实例(例如org.mybatis.spring.mapper.MapperFactoryBean)

判断入参RootBeanDefinition mbd是否为空，是则证明已经创建FactoryBean对象，直接从应用上下文属性BeanFactory的
父类FactoryBeanRegistrySupport属性factoryBeanObjectCache获取对，对象不为空即返回。否则继续流程

创建FeactoryBean

把入参bean实例强转FactoryBean

如果mbd为空，通过getMergedLocalBeanDefinition获取mdb

通过mdb判断是否后置处理shouldPostProcess

getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess)

FeactoryBean是单例，且singletonObjects存在bean实例。

对整个singletonObjects对象加锁synchronized

从factoryBeanObjectCache.get(beanName)获取对象bean对象

如果bean对象不为空，直接返回

如果为空，则object = doGetObjectFromFactoryBean(factory, beanName)

Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
因为factoryBeanObjectCache.put(beanName, object) 是在完成后才放入，在循环依赖过程中，
有可能bean在做后置处理，导致上面的第二点的get没有返回数据。因此需要再查询一次

如果alreadyThere 不为空（证明已经做了后置处理），直接返回

如果alreadyThere为空

且需要后置处理

isSingletonCurrentlyInCreation(beanName)
是则直接返回

beforeSingletonCreation(beanName)
创建实例预处理，就是往singletonsCurrentlyInCreation加数据

postProcessObjectFromFactoryBean(object, beanName)
或执行FactoryBean 对象后置处理，子类可重载方法

afterSingletonCreation(beanName)
创建实例后处理，在singletonsCurrentlyInCreation数据

this.factoryBeanObjectCache.put(beanName, object)

FeactoryBean不是单例，或者singletonObjects不存在bean实例。

doGetObjectFromFactoryBean(factory, beanName)

postProcessObjectFromFactoryBean(object, beanName)
或执行FactoryBean 对象后置处理，子类可重载方法

如果sharedInstance 为空

isPrototypeCurrentlyInCreation(beanName)
如果是一个属性bean，则抛异常。多半在循环依赖中出现

判断是否有父类工厂，如果有则执行父类工厂方法getBean并返回

如果需要标记已创建缓存，这执行markBeanAsCreated(String beanName)

设置beanCreation 实例化start

RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName)
根据BeanName获取RootBeanDefinition

String[] dependsOn = mbd.getDependsOn();
获取bean的依赖

isDependent(beanName, dep)
判断当前的bean和依赖的bean是否已经存在循环依赖缓存，是则抛异常

registerDependentBean(dep, beanName)
没有依赖缓存，则加入缓存

使用依赖的beanName 执行getBean(dep)，doGetBean(dep)。
先创建依赖的bean

完成依赖的bean创建（如果有的话），继续执行原来的bean创建

创建单例bean

Object getSingleton(String beanName, ObjectFactory<?> singletonFactory)

synchronized (this.singletonObjects)

从一级缓存singletonObjects，获取beanName的bean实例，如果非空，则马上返回。否则继续流程

加入当前创建缓存singletonsCurrentlyInCreation，目的是解决单例模式下的循环依赖

singletonObject = singletonFactory.getObject()，实际是子类DefaultListableBeanFactory的createBean方法

AbstractAutowireCapableBeanFactory.
createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)

resolveBeanClass(mbd, beanName)
通过mbd获取beanClass

resolveBeforeInstantiation(beanName, mbdToUse)执行bean创建前的业务处理
（bean要实现接口InstantiationAwareBeanPostProcessor）

Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)

在factoryBeanInstanceCache 获取或直接创建bean包装器BeanWrapper（BeanWrapper继承ConfigurablePropertyAccessor）

applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName)
如果是merged bean，则进行改方法的业务

用bean包装器实例化被包装的bean（此时只是实例化，bean的属性都为null，半成品）
并判断bean是单例且允许循环依赖，且在创建过程中。则调用ObjectFactory的匿名内部方法
getEarlyBeanReference，获取objectFactory加入第三级工厂缓存singletonFactories

populateBean(beanName, mbd, instanceWrapper)
用给定的属性填充bean

主要遍历InstantiationAwareBeanPostProcessor的实现类，调用实现类方法
postProcessProperties对beanName做动态代理，autowired等属性操作

AutowiredAnnotationBeanPostProcessor
此实现类类实现依赖注入。假设B注入A，A注入B，
A先实例化

InjectionMetadata metadata=findAutowiringMetadata(beanName, bean.getClass(), pvs)
从injectionMetadataCache 发现A有依赖注入，获取A的注入元 B

metadata.inject(bean, beanName, pvs)

AutowiredAnnotationBeanPostProcessor#AutowiredMethodElement.inject()

AutowiredAnnotationBeanPostProcessor#AutowiredMethodElement
.resolveFieldValue(field, bean, beanName), 返回field.set(bean, value);

Object value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter)
这里的beanFactory是DefaultListableBeanFactory，解决依赖的bean，即创建B

doResolveDependency(descriptor, requestingBeanName,
autowiredBeanNames, typeConverter)

resolveMultipleBeans(descriptor, beanName, autowiredBeanNames, typeConverter)

descriptor.resolveCandidate(autowiredBeanName, type, this)

AbstractBeanFactory.dogetBean()
先创建需要依赖注入的对象B，执行
doGetBean方法

此时发现B依赖A，A又重新走dogetBean方法。此时在
getSingleton(String beanName, boolean allowEarlyReference)
里，把singletonFactory.getObject()的实例暴露到二级缓存
earlySingletonObjects。然后直接返回A实例，A未注入B
即属性B为NULL（现在是创建B的流程）

AutowiredAnnotationBeanPostProcessor.registerDependentBeans(String beanName, autowiredBeanNames)

field.set(bean, value); 首先完成B的实例化（B注入A的实例，但A的实例属性B为null）。
完成B的实例化，再回弹到解决A依赖B的解决方法栈

exposedObject = initializeBean(beanName, exposedObject, mbd)
给bean初始化，并返回处理好的bean对象exposedObject

invokeAwareMethods
各种Aware的实例bean处理

invokeInitMethods
InitializingBean的实例bean处理

applyBeanPostProcessorsAfterInitialization
Bean完成实例化的后置处理

获取二级缓存 Object earlySingletonReference = getSingleton(beanName, false);
这里注意入参是false，只从一二级缓存拿数据。如果二级缓存能拿到数据，证明别人已经从三级缓存拿过数据

如果是提前暴露的bean，且二级缓存不为空，检查包装的原始bean和初始化完成的exposedObject是否一致

如果不一致，判断beanName是否已经创建（doGetBean时候，如果发现bean不存在，会走创建流程，这时执行
markBeanAsCreated）。意思是检查前后的bean是否一致。如果不一致，则证明其它的bean使用了不是最终版本的，
这时候要抛异常BeanCurrentlyInCreationException。这个也是为什么要使用三级缓存而不是二级缓存的原因

registerDisposableBeanIfNecessary(beanName, bean, mbd)
注册需要注销的bean

删除singletonsCurrentlyInCreation

把createBean的返回加入级缓存singletonObjects

创建Prototype bean，同样调用子类方法createBean

创建scope bean，例如request，session等,同样调用子类方法createBean

finishRefresh()

clearResourceCaches();

initLifecycleProcessor()

getLifecycleProcessor().onRefresh()

publishEvent(new ContextRefreshedEvent(this))

resetCommonCaches()

ReflectionUtils.clearCache()

AnnotationUtils.clearCache()

ResolvableType.clearCache()

CachedIntrospectionResults.clearClassLoader(getClassLoader())

afterRefresh(context, applicationArguments)

listeners.started(context);

callRunners(context, applicationArguments)

实现ApplicationRunner的bean

实现CommandLineRunner的bean

listeners.running(context)

return context

spring扩展点
(按启动时序说明)

ApplicationContextInitializer

作用：再spring容器初始化之前，初始化ConfigurableApplicationContext
对上下文环境作一些操作，如运行环境属性注册、激活配置文件。

接口方法

void initialize(C applicationContext)

实现方式:

Spring SPI: 在spring.factories 加入映射

SpringApplication#addInitializers

applicaiton.properties

初始化时机：SpringApplication实例化时候

执行时机：springApplication实例执行run方法的prepareContext方法，执行applyInitializers(context)

内置实现类见SpringApplication
属性initializers

ContextIdApplicationContextInitializer

SharedMetadataReaderFactoryContextInitializer

DelegatingApplicationContextInitializer

。。。。。。。。。。

BeanDefinitionRegistryPostProcessor

作用：容器级后置处理器，在所有的BeanDefinition加载完成之后，Bean真正被实例化之前，进行属性修改。
或进行复杂的业务，例如动态注册自己的beanDefinition，可以加载classpath之外的bean

接口方法

postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry)

实现方式: IOC容器内使用，@Component

执行时机：ioc容器初始化之后，SptingApplication实例refresh() 阶段。
方法invokeBeanFactoryPostProcessors()中执行

内置实现类

ConfigurationClassPostProcessor

。。。。。。。。。。

BeanFactoryPostProcessor

作用与BeanDefinitionRegistryPostProcessor一样，BeanDefinitionRegistryPostProcessor是继承BeanFactoryPostProcessor。
执行流程在BeanDefinitionRegistryPostProcessor触发之后

接口方法

postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)

实现方式: IOC容器内使用，@Component

区别

官方建议 BeanDefinitionRegistryPostProcessor 在所有常规bean definitions加载后，用于新增额外的bean definitions

官方建议 BeanFactoryPostProcessor 用于修改bean definitions

FactoryBean

作用： FactoryBean是一个工厂bean，让我们自定义Bean的创建过程。FactoryBean本质就是用来给我们实例化、或者动态的注入
一些比较复杂的Bean，比如像一些接口的代理对象, 例如mybattis的MapperFactoryBean，mysql SqlSessionFactoryBean

接口方法

T getObject()

Class<?> getObjectType()

default boolean isSingleton()

实现方式

继承FactoryBean，实现接口方法

对FactoryBean 注解@Component("beanName")，托管给spring容器，创建对beanName实例化的工厂bean

执行阶段：AbstractBeanFactory#doGetBean--->#getObjectForBeanInstance--->FactoryBeanRegistrySupport#getObjectFromFactoryBean

内置实现类: 内置70多个FactoryBean的实现

InstantiationAwareBeanPostProcessor

作用：继承BeanPostProcessor，对bean实例化过程中做后置业务处理

执行阶段：SpirngApplication实例refresh的最后阶段，在方法finishBeanFactoryInitialization -> beanFactory.preInstantiateSingletons()

接口方法
（执行顺序排列）

postProcessBeforeInstantiation(Class<?> beanClass, String beanName)
实例化bean 之前操作

postProcessAfterInstantiation(Object bean, String beanName)
实例化bean 之后操作

postProcessProperties(PropertyValues pvs, Object bean, String beanName)
bean已经实例化完成，在属性注入时阶段触发。@Autowired,@Resource等注解原理基于此方法实现

postProcessPropertyValues( PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName)
bean已经实例化完成，在属性注入时阶段触发。此方法已弃用标记

extends BeanPostProcessor postProcessBeforeInitialization(Object bean, String beanName)
bean初始化之前，即注入应用上下文之前

extends BeanPostProcessor postProcessAfterInitialization(Object bean, String beanName)
bean初始化之后，即注入应用上下文之后

实现方式: IOC容器内使用，@Component

内置实现类

AutowiredAnnotationBeanPostProcessor

CommonAnnotationBeanPostProcessor

。。。。。。。。。。

SmartInstantiationAwareBeanPostProcessor

作用：同样继承BeanPostProcessor和InstantiationAwareBeanPostProcessor，做bean后置业务操作。实际业务场景开发使用不多，主要在Spring内部应用

接口方法及执行时机

predictBeanType(Class<?> beanClass, String beanName)
在postProcessBeforeInstantiation之前执行，用于预测bean类型。一般返回null

Constructor<?>[] determineCandidateConstructors(Class<?> beanClass, String beanName)
在postProcessBeforeInstantiation之后，postProcessAfterInstantiation之前执行。
决定使用哪个（无参/有参）构造器构造Bean，作用不大。

getEarlyBeanReference(Object bean, String beanName)
获得提前暴露的bean引用，主要用于Spring循环依赖问题的解决

实现方式: IOC容器内使用，@Component

内置实现类

AnnotationAwareAspectJAutoProxyCreator
创建代理对象使用

ApplicationContextAwareProcessor

不是扩展点，是一个特殊的BeanPostProcessor，内置对各种Aware bean实现类进行
属性设置。如：最熟悉的ApplicationContextAware的实现类， setApplicationContext
就在这里后置处理，把上文contex设置到实现类的类变量context

EnvironmentAware

作用: 可以获取系统所有Environment参数设置，比较少用。spring内部都可以通过注入的方式来直接获得

执行阶段: springApplication实例 refresh() --》invokeBeanFactoryPostProcessors(beanFactory)
/finishBeanFactoryInitialization(beanFactory)，具体哪个阶段执行取决于实现了BeanFactoryPostProcessor还是BeanPostProcessor

实现方式: IOC容器内使用，@Component

内置实现类

ConfigurationClassPostProcessor

PropertySourcesPlaceholderConfigurer

EmbeddedValueResolverAware

作用：StringValueResolver的一个扩展类， StringValueResolver用于获取基于
String类型的properties的变量，一般用@Value的方式也可以获取。

实现方式: IOC容器内使用，@Component

内置实现类

DefaultFormattingConversionService

WebConversionService

RequestMappingHandlerMapping

ResourceLoaderAware

作用：用于获取ResourceLoader，通过ResouceLoader获取classpath内所有的资源对象

实现方式: IOC容器内使用，@Component

内置实现类

ConfigurationClassPostProcessor

TomcatServletWebServerFactory

WebMvcAutoConfiguration

ApplicationEventPublisherAware

作用：用于获取ApplicationEventPublisher，用来发布事件，
也可以通过spring注入的方式来获得此对象

实现方式: IOC容器内使用，@Component

无内置实现类

这个要结合ApplicationListener来使用。
常用于业务监听处理。举个简单的例子

Event

创建Event类扩展ApplicationEvent，构建Event事件要素

EventPublisher

创建EventPublisher类实现接口ApplicationEventPublisherAware，EventPublisher有类属性ApplicationEventPublisher，并用@Component给IOC容器托管
EventPublisher 实例化时候会触发后置处理器ApplicationContextAwareProcessor，执行setApplicationEventPublisher，把applicationContext设置到EventPublisher的属性ApplicationEventPublisher。
现在EventPublisher类有了applicationEventPublisher.publishEvent功能，可以把EventPublisher注入到需要的服务使用事件发布功能。

ApplicationListener

创建ApplicationListener类实现ApplicationListener<Event>，覆盖父类方法onApplicationEvent，并托管到IOC容器。完成自动监听

创建ApplicationListener类，托管到IOC容器。新增void方法，入参为Event。方法加上@EventListener，完成自动监听

MessageSourceAware

作用：获取MessageSource的一个扩展类，做国际化处理

执行阶段: springApplication实例 refresh() --》finishBeanFactoryInitialization(beanFactory)

实现方式: IOC容器内使用，@Component

无内置实现类

ApplicationStartupAware

作用，获取ApplicationStartup 类，可以标记应用启动期间的步骤

实现方式: IOC容器内使用，@Component

内置实现类

ConfigurationClassPostProcessor

ApplicationContextAware

作用：ApplicationContext的一个扩展类，常用于手动获取上下文里注册的bean。

实现方式: IOC容器内使用，@Component

内置实现类

EventListenerMethodProcessor

ConfigurationPropertiesBindingPostProcessor

DispatcherServlet

@PostConstruct

执行时机：@PostConstruct方法，在其所在的bean执行 postProcessBeforeInitialization之后，
（如果bean同时实现了InitializingBean，InitializingBean.afterPropertiesSet 之前执行）
执行postProcessAfterInitialization 之前。

InitializingBean

相当于init-method，但执行时机早于init-method，实现自定义初始化操作

方法 afterPropertiesSet()

执行时机：在其所在的bean执行 postProcessBeforeInitialization之后，postProcessAfterInitialization 之前。

TestSmartInitializingSingleton

作用，所有bean完成完全实例化后，做业务定制

执行时机，在refreshContext(context)阶段最后执行

CommandLineRunner和ApplicationRunner

作用：热点数据的预加载、清除临时文件、读取自定义配置信息等

方法

ApplicationRunner run(ApplicationArguments args)

CommandLineRunner run(String... args)