Spring容器创建过程(基于注解)

实例代码：
ExtConfig配置类，给第一行代码打上断点

    @Test
    public  void test(){
        AnnotationConfigApplicationContext applicationContext=
                new AnnotationConfigApplicationContext(ExtConfig.class);
        applicationContext.close();
    }

Spring容器的refresh()[创建刷新]，看看此方法:
1.prepareRefresh(); 刷新前的预处理，记录启动时间，容器是否关闭，容器是否激活等
1），initPropertySources();初始化一些属性设置；子容器自定义个性化的属性设置方法
2），getEnvironment().validateRequiredProperties();检验属性的合法等
3），earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);保存容器中的一些早期事件

2.ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();获取BeanFactory
1），refreshBeanFactory();刷新【创建】bean工厂，进入会来到GenericApplicationContext类里面，如果是基于配置文件的会去到类AbstractRefreshableApplicationContext里面。
先是在构造函数里创建一个容器this.beanFactory = new DefaultListableBeanFactory();
设置idthis.beanFactory.setSerializationId(getId());
2），return getBeanFactory();返回刚才GenericApplicationContext创建的DefaultListableBeanFactory容器对象

3.prepareBeanFactory(beanFactory);BeanFactory的预准备工作（对容器进行一些设置）
1），设置BeanFactory的类加载器，支持表达式解析器。。。

beanFactory.setBeanClassLoader(getClassLoader());
beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));

2），添加部分BeanPostProcessor[ApplicationContextAwareProcessor]
3），设置忽略的自动装配的接口EnvironmentAware，EmbeddedValueResolverAware，xxx
作用是实现了这些接口的实现类，不能通过这些接口类型来自动注入。

		beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
		beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
		beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
		beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
		beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
		beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
		beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);

4），注册可以解析的自动装配，我们能直接在任何组件中自动注入：BeanFactory,ResourceLoader…

beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
beanFactory.registerResolvableDependency(ResourceLoader.class, this);
beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
beanFactory.registerResolvableDependency(ApplicationContext.class, this);

5），添加BeanPostProcessor[ApplicationListenerDetector]

beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

6），添加编译时的AspectJ
7），给BeanFactory中注册一些能用的组件

environment【ConfigurableEnvironment】，systemProperties【Map<String,
Object>】，systemEnvironment【Map<String, Object>】

4.到此为止，容器创建完毕，该设置的也设置了。postProcessBeanFactory(beanFactory);BeanFactory准备工作完成后进行的后置处理工作。进去看是空的。
1），子类通过重写这个方法来在BeanFactory创建并预准备完成以后做进一步的设置

以上是BeanFactory的创建和预准备工作
5.invokeBeanFactoryPostProcessors(beanFactory);执行BeanFactoryPostProcessors的方法
BeanFactoryPostProcessors:BeanFactory的后置处理器。在BeanFactory标准初始化之后执行的（就是前面4步）
两个接口BeanFactoryPostProcessors ，BeanDefinitionRegistryPostProcessor
进入：PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());

1），执行BeanFactoryPostProcessors的方法

先执行BeanDefinitionRegistryPostProcessor的方法
1.1），获取所有的BeanDefinitionRegistryPostProcessor
1.2），先执行实现了PriorityOrdered优先级接口的BeanDefinitionRegistryPostProcessor

//获取所有的`BeanDefinitionRegistryPostProcessor`
String[] postProcessorNames =beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
	if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
		currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
		processedBeans.add(ppName);
	}
}
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
//先执行实现了`PriorityOrdered`优先级接口的`BeanDefinitionRegistryPostProcessor`
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
currentRegistryProcessors.clear();

invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry)：

for (BeanDefinitionRegistryPostProcessor postProcessor : postProcessors) {
	postProcessor.postProcessBeanDefinitionRegistry(registry);
}

1.3)，再执行实现了Ordered优先级接口的BeanDefinitionRegistryPostProcessor，原理同上
1.4），最后执行没有实现任何优先级或者是任何顺序接口的BeanDefinitionRegistryPostProcessor

再执行BeanFactoryPostProcessor的方法
1.5），获取所有的BeanFactoryPostProcessor
1.6），然后按优先级分别放到集合A,B，C中

String[] postProcessorNames =
		beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
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);
	}
}

1.7），先执行实现PriorityOrdered优先级的BeanFactoryPostProcessor，排序执行
注意:上面的代码片中，实现PriorityOrdered的BeanFactoryPostProcessor通过getBean()已经实例化了

sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

invokeBeanFactoryPostProcessors：

for (BeanFactoryPostProcessor postProcessor : postProcessors) {
	postProcessor.postProcessBeanFactory(beanFactory);
}

1.8），再执行实现了Ordered接口的BeanFactoryPostProcessor

List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
for (String postProcessorName : orderedPostProcessorNames) {
	orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
sortPostProcessors(orderedPostProcessors, beanFactory);
invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

1.9），最后执行没有实现任何优先级接口的BeanFactoryPostProcessor

BeanFactoryPostProcessors的方法执行完之后
6.registerBeanPostProcessors(beanFactory);注册bean的后置处理器(拦截bean创建过程)，不执行只是注册

BeanPostProcessor：不同接口类型的BeanPostProcessor在bean创建前后的执行时机是不一样的
InstantiationAwareBeanPostProcessor，DestructionAwareBeanPostProcessor，SmartInstantiationAwareBeanPostProcessor，MergedBeanDefinitionPostProcessor

1）,获取所有的BeanPostProcessor，后置处理器多可以通过优先级接口PriorityOrdered，Ordered来执行优先级
分别把实现了接口PriorityOrdered，Ordered和没有实现优先级的接口放到集合中，同时把MergedBeanDefinitionPostProcessor的BeanPostProcessor也放到一个集合【internalPostProcessors】中

//获取所有的`BeanPostProcessor
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
List<String> orderedPostProcessorNames = new ArrayList<>();
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);
		if (pp instanceof MergedBeanDefinitionPostProcessor) {
			internalPostProcessors.add(pp);
		}
	}
	else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
		orderedPostProcessorNames.add(ppName);
	}
	else {
		nonOrderedPostProcessorNames.add(ppName);
	}
}

2），先注册PriorityOrdered优先级接口的BeanPostProcessor
先排序，在注册

sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

registerBeanPostProcessors：

for (BeanPostProcessor postProcessor : postProcessors) {
	beanFactory.addBeanPostProcessor(postProcessor);
}

3），再注册实现Ordered接口的
4），最后注册没有实现任何优先级接口的
5），最终注册MergedBeanDefinitionPostProcessor

sortPostProcessors(internalPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, internalPostProcessors);

6），注册一个ApplicationListenerDetector，来在bean创建完成后检查是否是ApplicationListener，如果是添加到容器中
容器(类)里有很多属性，有的存放BeanPostProcessor,有的存BeanFactoryPostProcessor,有的存放单实例的Bean，还有ClassLoader，StringValueResolver等。。。

beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));

this.applicationContext.addApplicationListener((ApplicationListener<?>) bean);

Bean的后置处理器注册完啦
7.initMessageSource();初始化Messagesource组件(做国际化功能，消息绑定，消息解析)
1），获取BeanFactory
2），看容器中是否有id为messageSource的组件，类型为MessageSource
如果有赋值给messageSource属性，如果没有自己创建一个DelegatingMessageSource dms = new DelegatingMessageSource();
MessageSource作用：取出国际化配置文件中的某个key的值，能按照区域信息获取
然后在把创建好的MessageSource注册在容器中，以后获取国际化配置文件的值的时候，可以在自动注入MessageSource

	protected void initMessageSource() {
	    //获取`BeanFactory`
		ConfigurableListableBeanFactory beanFactory = getBeanFactory();
		//看容器中是否有id为`messageSource`的组件
		if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
		    //如果有赋值给`messageSource`属性
			this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);}
		else {
			//如果没有,创建一个MessageSource
			DelegatingMessageSource dms = new DelegatingMessageSource();
			dms.setParentMessageSource(getInternalParentMessageSource());
			this.messageSource = dms;
			//把创建好的`MessageSource`注册在容器中
			beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);}}

Messagesource组件初始化之后
8.initApplicationEventMulticaster();初始化事件多播器（派发器）
1），获取BeanFactory

ConfigurableListableBeanFactory beanFactory = getBeanFactory();

2），先去容器中找有没有自定义的id="applicationEventMulticaster"的组件

if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
this.applicationEventMulticaster =
beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);

有直接创建bean,赋值，初始化
如果没有，自己手动创建并且加入到容器中，我们就可以在其他组件要派发事件，自动注入这个applicationEventMulticaster组件

else {
this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);

多播器初始化之后
9.onRefresh();留给子容器（子类）进去是空方法。子类重写这个方法，在容器刷新的时候可以自定义逻辑。

10.registerListeners();注册监听器
1），从容器中获取所有的监听器定义，把它们注册到applicationEventMulticaster多播器组件中

String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
for (String listenerBeanName : listenerBeanNames) {
	getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
}

监听器都注册到多播器中之后
11.finishBeanFactoryInitialization(beanFactory);初始化剩下的所有单实例bean
1），beanFactory.preInstantiateSingletons();初始化剩下的单实例bean
1.1），获取容器中的所有bean，依次进行初始化和创建对象

beanDefinitionNames是容器的一个List属性，存放的是所有的BeanDefinition的名字。
可以根据这个名字获取BeanDefinition,BeanDefinition存放在容器的一个Map属性里：private final Map<String, RootBeanDefinition> mergedBeanDefinitions = new ConcurrentHashMap<>(256);

List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

1.2），获取bean的定义信息RootBeanDefinition ，就是根据BeanDefinition名字去获取bean定义

RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);

1.3)，bean不是抽象的，是单例的，不是懒加载的
1.3.1),判断是否是FactoryBean,是否是实现FactoryBean接口的Bean
1.3.2),不是FactoryBean。利用getBean()创建对象

for (String beanName : beanNames) {
			//根据`BeanDefinition`名字去获取bean定义
			RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
			//判断bean不是抽象的，是单例的，不是懒加载的
			if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
				//判断是否是`FactoryBean`
				if (isFactoryBean(beanName)) {
					Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
					if (bean instanceof FactoryBean) {
						final FactoryBean<?> factory = (FactoryBean<?>) 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 {
					//不是`FactoryBean`。利用`getBean()`创建对象
					getBean(beanName);
				}
			}
		}

getBean(beanName)->doGetBean(name, null, null, false)看看doGetBean
1），先获取缓存中的单例bean。如果能获取到说明之前已经被创过了(所有创建过的单例bean都会被缓存起来)

Object sharedInstance = getSingleton(beanName);
//进去getSingleton方法，就是缓存中获取bean
Object singletonObject = this.singletonObjects.get(beanName);

创建好的bean会放到DefaultSingletonBeanRegistry中缓存起来：
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);

2),如果缓存中获取不到，开始Bean的创建对象流程
2.1），标记当前bean已经被创建

if (!typeCheckOnly) {
	markBeanAsCreated(beanName);
}

2.2），获取Bean定义信息final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
2.3），获取当前bean依赖的其他Bean,String[] dependsOn = mbd.getDependsOn();

假设类A依赖类B,即A有属性B,那么depends-on的作用就是，创建A之前先把B给创建好；使用xml配置方式的时候，直接在A的bean标签上指定即可，使用注解的方式时，使用@DependsOn注解可以指定。源码上也是体现了先获取当前bean依赖的其他bean,然后再创建当前bean.

如果有按照getBean()把依赖的bean先创建出来

if (dependsOn != null) {
		for (String dep : dependsOn) {
			registerDependentBean(dep, beanName);
				getBean(dep);

2.4），启动单实例bean的创建流程
先判断是不是单实例bean，是的话调createBean(beanName, mbd, args)创建bean

if (mbd.isSingleton()) {
	sharedInstance = getSingleton(beanName, () -> {
		try {
			return createBean(beanName, mbd, args);

2.4.1）， createBean(beanName, mbd, args);进入
2.4.2）， resolveBeforeInstantiation(beanName, mbdToUse); 解析BeforeInstantiation
希望后置处理器在此能返回一个代理对象，如果能返回代理对象就使用，如果不能就doCreateBean，先提前拦截返回代理对象，InstantiationAwareBeanPostProcessor提前执行

//applyBeanPostProcessorsBeforeInstantiation()逻辑
//遍历所有后置处理器，如果是InstantiationAwareBeanPostProcessor，就执行postProcessBeforeInstantiation()
bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
if (bean != null) {
bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
}

2.4.3），如果前面的InstantiationAwareBeanPostProcessor没有返回代理对象，执行：

Object beanInstance = doCreateBean(beanName, mbdToUse, args);

doCreateBean:
1),createBeanInstance(beanName, mbd, args);创建bean实例
利用工厂方法或者对象的构造器创建出Bean实例
2），applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);使用MergedBeanDefinitionPostProcessor修改bean定义，很多BeanPostProcessor的执行时机都不一样，这个的执行时机是bean实例化之后

for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof MergedBeanDefinitionPostProcessor) {
	MergedBeanDefinitionPostProcessor bdp = (MergedBeanDefinitionPostProcessor) bp;
	bdp.postProcessMergedBeanDefinition(mbd, beanType, beanName);
}
}

3），populateBean(beanName, mbd, instanceWrapper);对bean进行赋值
3.1），拿到InstantiationAwareBeanPostProcessor后置处理器，执行postProcessAfterInstantiation方法
3.2），拿到InstantiationAwareBeanPostProcessor后置处理器，执行postProcessPropertyValues方法
3.3），applyPropertyValues(beanName, mbd, bw, pvs);应用Bean属性的值，为属性利用setter方法等进行赋值
4），initializeBean(beanName, exposedObject, mbd);初始化bean
4.1),invokeAwareMethods(beanName, bean);执行xxxAware接口的方法
BeanNameAware，BeanClassLoaderAware，BeanFactoryAware,如果当前bean实现了这些接口，就回调

		if (bean instanceof Aware) {
			if (bean instanceof BeanNameAware) {
				((BeanNameAware) bean).setBeanName(beanName);}
			if (bean instanceof BeanClassLoaderAware) {
				ClassLoader bcl = getBeanClassLoader();
				if (bcl != null) {
					((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);}}
			if (bean instanceof BeanFactoryAware) {
				((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);}}

4.2），applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);执行后置处理器初始化之前的方法
BeanPostProcessor.postProcessBeforeInitialization()
4.3)，invokeInitMethods(beanName, wrappedBean, mbd);执行初始化方法
是否是InitializingBean接口的实现：执行接口规定的初始化
是否自定义初始化方法：是的话invokeCustomInitMethod(beanName, bean, mbd);
4.4）， applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);执行后置处理器初始化之后的方法
BeanPostProcessor.postProcessAfterInitialization()

5),registerDisposableBeanIfNecessary(beanName, bean, mbd);注册Bean的销毁方法

6），return 初始化完的bean

到这：doCreateBean 终于是返回了一个bean实例

2.4.4) ，return beanInstance;返回Object beanInstance = doCreateBean(beanName, mbdToUse, args);创建的对象，createBean()走完

2.5），进入2.4中的getSingleton(beanName，刚刚createBean()返回的bean实例)

//获取bean实例
singletonObject = singletonFactory.getObject();
//将bean实例添加到单实例bean里面
addSingleton(beanName, singletonObject);

缓存起来

	protected void addSingleton(String beanName, Object singletonObject) {
		synchronized (this.singletonObjects) {
			this.singletonObjects.put(beanName, singletonObject);
			this.singletonFactories.remove(beanName);
			this.earlySingletonObjects.remove(beanName);
			this.registeredSingletons.add(beanName);
		}
	}

ioc容器就是这些Map，很多Map里面保存了单实例bean,环境信息。。。

2.6），然后doGetBean走完，getBean走完，获取到一个bean实例，1.3.2可以看到所有的bean是通过一个for循环一个一个getBean的创建出来的(缓存有就从缓存拿，没有就创建)

1.4）回到1.3)中所有的bean都创建完之后，继续往下走
遍历创建好的所有的单实例bean,判断是否实现了SmartInitializingSingleton，如果是调用smartSingleton.afterSingletonsInstantiated();

for (String beanName : beanNames) {
	Object singletonInstance = getSingleton(beanName);
	if (singletonInstance instanceof SmartInitializingSingleton) {
		final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
		if (System.getSecurityManager() != null) {
			AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
				smartSingleton.afterSingletonsInstantiated();
				return null;
			}, getAccessControlContext());
		}
		else {
			smartSingleton.afterSingletonsInstantiated();
		}
	}
}

初始化完剩下的所有单实例bean后
12.finishRefresh();完成BeanFactory的初始化创建工作，IOC容器就创建完成

	protected void finishRefresh() {
		clearResourceCaches();
		//初始化和生命周期有关的后置处理器LifecycleProcessor【onRefresh(),onClose()】
		//默认从容器中找是否有lifecycleProcessor的组件，如果没有new DefaultLifecycleProcessor
		//并加入到容器中
		initLifecycleProcessor();
		//拿到生命周期处理器回调onRefresh方法
		getLifecycleProcessor().onRefresh();
		//发布容器刷新完成事件
		publishEvent(new ContextRefreshedEvent(this));
		// Participate in LiveBeansView MBean, if active.
		LiveBeansView.registerApplicationContext(this);
	}

总结：
1.Spring容器在启动的时候，先会保存所有注册进来的bean定义信息：
xml注册bean：<bean>
注解注册Bean:@Service,@Component,@Bean…
2.Spring容器会在合适的时机创建这些bean
用到这个bean的时候，利用getBean()创建bean,创建好后保存在容器中
统一创建剩下的所有的单实例bean
3.后置处理器：每一个bean创建完成后，都会使用后置处理器来增强bean的功能
4.事件驱动：ApplicationListener 事件监听 ApplicationEventMulticaster事件派发

来源：CSDN

作者：weixin_42412601

链接：https://blog.csdn.net/weixin_42412601/article/details/104074078

标签

容器