spring强化学习系列-扩展原理-----spring 容器创建过程-优快云博客

本文深入解析Spring容器的扩展原理，包括BeanFactoryPostProcessor、BeanDefinitionRegistryPostProcessor的作用机制，以及ApplicationListener在事件驱动模型中的应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

扩展原理

BeanFactoryPostProcessor，
BeanDefinitionRegistryPostProcessor，
ApplicationListe

BeanFactoryPostProcessor
beanFactory的后置处理器

BeanPostProcessor:bean后置处理器，bean创建对象初始化前后进行拦截工作的
 *	BeanFactoryPostProcessor:beanFactory的后置处理器，
 *	在beanfactory标准初始化之后调用，所有的bean定义已经保存加载到beanFactory，但是bean的实例还未创建
 *
 *	1.ioc容器创建对象
 *	2.invokeBeanFactoryPostProcessors(beanFactory);执行BeanFactoryPostProcessors
 *		如何找到所有的BeanFactoryPostProcessor并执行他们的方法
 *			1.直接在BeanFactory中找到所有类型是BeanFactoryPostProcessor的组件，并执行他们的方法	
 *			2.在初始化创建其他组件前面执行

BeanDefinitionRegistryPostProcessor
bean定义注册表后处理器

 BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor
 *		postProcessBeanDefinitionRegistry();
 *		在所有bean定义信息将要被加载，bean实例还未创建的；
 *		
 *		优先于BeanFactoryPostProcessor执行：
 *		利用BeanDefinitionRegistryPostProcessor给容器中在额外添加一些组件；
 *
 *	原理： 
 *		1.ioc创建对象
 *		2.refresh()->invokeBeanFactoryPostProcessors(beanFactory); 
 *		3.先从容器中获取所有的BeanDefinitionRegistryPostProcessor组件，
 *			1.依次触发所有的postProcessBeanDefinitionRegistry（）方法
 *			2.再来触发postProcessBeanFactory()方法BeanFactoryPostProcessor
 *		
 *		4.再来从容器中找到BeanFactoryPostProcessor组件，然后依次触发postProcessBeanFactory（）方法

ApplicationListener
应用程序监听器

ApplicationListener:监听容器中发布的时间，事件驱动模型开发；
 *		public interface ApplicationListener<E extends ApplicationEvent>
 *			监听ApplicationEvent及其子事件；
 *
 *	步骤：
 *		1.写一个监听器来监听某个时间（ApplicationEvent及其子类）
 *		2.把监听器加入到容器；
 *		3.只要容器有相关事件的发布，我们就能监听到这个事件 ；
 *				ContextRefreshedEvent：容器刷新完成事件（所有bean都完全创建）会发布这个事件；
 *				ContextClosedEvent：关闭容器会发布这个事件；
 *		4.发布一个事件：
 *			applicationContext:publishEvent();
 *
 *	原理：
	 *		ContextRefreshedEvent、IOCTest_Ext$1[source=我发布的时间]、ContextClosedEvent；
	 *  1）、ContextRefreshedEvent事件：
	 *  	1）、容器创建对象：refresh()；
	 *  	2）、finishRefresh();容器刷新完成会发布ContextRefreshedEvent事件
	 *  2）、自己发布事件；
	 *  3）、容器关闭会发布ContextClosedEvent；
 *  【事件发布流程】：
 *  	3）、publishEvent(new ContextRefreshedEvent(this));
 *  			1）、获取事件的多播器（派发器）：getApplicationEventMulticaster()
 *  			2）、multicastEvent派发事件：
 *  			3）、获取到所有的ApplicationListener；
 *  				for (final ApplicationListener<?> listener : getApplicationListeners(event, type)) {
 *  				1）、如果有Executor，可以支持使用Executor进行异步派发；
 *  					Executor executor = getTaskExecutor();
 *  				2）、否则，同步的方式直接执行listener方法；invokeListener(listener, event);
 *  				 拿到listener回调onApplicationEvent方法；
 *  
 *  【事件多播器（派发器）】
 *  	1）、容器创建对象：refresh();
 *  	2）、initApplicationEventMulticaster();初始化ApplicationEventMulticaster；
 *  		1）、先去容器中找有没有id=“applicationEventMulticaster”的组件；
 *  		2）、如果没有this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
 *  			并且加入到容器中，我们就可以在其他组件要派发事件，自动注入这个applicationEventMulticaster；
 *  
 *  【容器中有哪些监听器】
 *  	1）、容器创建对象：refresh();
 *  	2）、registerListeners();
 *  		从容器中拿到所有的监听器，把他们注册到applicationEventMulticaster中；
 *  		String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
 *  		//将listener注册到ApplicationEventMulticaster中
 *  		getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
 *  		
 *   SmartInitializingSingleton 原理：->afterSingletonsInstantiated();
 *   		1）、ioc容器创建对象并refresh()；
 *   		2）、finishBeanFactoryInitialization(beanFactory);初始化剩下的单实例bean；
 *   			1）、先创建所有的单实例bean；getBean();
 *   			2）、获取所有创建好的单实例bean，判断是否是SmartInitializingSingleton类型的；
 *   				如果是就调用afterSingletonsInstantiated();

spring容器创建过程：

spring容器的refresh（）【创建刷新】；
1.prepareRefresh();	刷新前的预处理；
	1.initPropertySources();初始化一些属性设置，子类自定义个性化的属性设置方法；
	2.getEnvironment().validateRequiredProperties();检验属性的合法等；
	3.earlyApplicationEvents = new LinkedHashSet<ApplicationEvent>();保存容器中的一些早期的事件；

2. obtainFreshBeanFactory();获取BeanFactory;
	1.refreshBeanFactory();刷新BeanFactory；
		创建了一个this.beanFactory = new DefaultListableBeanFactory();
		设置id；
	2.getBeanFactory()；返回刚才GenericApplicationContext创建的BeanFactory对象；
	3.将创建的BeanFactory【DefaultListableBeanFactory】返回；

3.prepareBeanFactory(beanFactory);BeanFactory的预准备工作（BeanFactory进行一些设置）；
	1.设置BeanFactory的类加载器，支持表达式解析器...
	2.添加部分BeanPostProcessor【ApplicationContextAwareProcessor】
	3.设置忽略的自动装配的接口EnvironmentAware，EmbeddedValueResolverAware，xxx...
	4.注册可以解析的自动装配；我们能直接在任何组件中自动注入：
		BeanFactory,ResourceLoader,ApplicationEventPublisher,ApplicationContext
	5.添加BeanPostProcessor【ApplicationListenerDetector】
	6.添加编译时的AspectJ；
	7.给BeanFactory中注册一些能用的组件；
		environment【ConfigurableEnvironment】、
		systemProperties【Map<String, Object>】、
		systemEnvironment【Map<String, Object>】

4.postProcessBeanFactory(beanFactory);BeanFactory准备工作完成后进行的后置处理工作；
	1.子类通过重写这个方法来在Beanfactory创建并预准备完成以后做进一步的设置
========================以上是BeanFactory的创建及预准备工作====================

5.invokeBeanFactoryPostProcessors(beanFactory);执行BeanFactoryPostProcessor的方法;
	BeanFactoryPostProcessor：BeanFactory的后置处理器 。在BeanFactory标准初始化之后执行的；
	两个接口BeanFactoryPostProcessor，子接口BeanDefinitionRegistryPostProcessor
	1.执行BeanFactoryPostProcessor的方法；先执行子接口中的方法
		1.获取所有的BeanDefinitionRegistryPostProcessor；
		2.先执行实现了PriorityOrdered优先级接口的BeanDefinitionRegistryPostProcessor、
			postProcessor.postProcessBeanDefinitionRegistry(registry);
		3.在执行实现了Ordered顺序接口BeanDefinitionRegistryPostProcessor、
			postProcessor.postProcessBeanDefinitionRegistry(registry);
		4.最后执行没有实现任何优先级或者是顺序接口的BeanDefinitionRegistryPostProcessor；
			postProcessor.postProcessBeanDefinitionRegistry(registry);
			
		在执行BeanFactoryPostProcessor的方法
		1.获取所有的BeanFactoryPostProcessor；
		2.先执行实现了PriorityOrdered优先级接口的BeanDefinitionRegistryPostProcessor、
			postProcessor.postProcessBeanDefinitionRegistry(registry);
		3.在执行实现了Ordered顺序接口BeanDefinitionRegistryPostProcessor、
			postProcessor.postProcessBeanDefinitionRegistry(registry);
		4.最后执行没有实现任何优先级或者是顺序接口的BeanDefinitionRegistryPostProcessor；
			postProcessor.postProcessBeanDefinitionRegistry(registry);

6.registerBeanPostProcessors(beanFactory);注册BeanPostProcessor（bean的后置处理器）【拦截bean的创建过程】
	不同接口类型的BeanPostProcessor；在bean创建前后的执行时机是不一样的
	BeanPostProcessor、
	DestructionAwareBeanPostProcessor、
	InstantiationAwareBeanPostProcessor、
	SmartInstantiationAwareBeanPostProcessor、
	MergedBeanDefinitionPostProcessor【internalPostProcessors】、		
	
	1.获取所有的BeanPostProcessor，后置处理器都默认可以通过PriorityOrdered、Ordered接口来指定优先级 
	2.先注册PriorityOrdered优先级接口的BeanPostProcessor；
		把每一个BeanPostProcessor，添加到BeanFactory中
		beanFactory.addBeanPostProcessor(postProcessor);
	3.在注册实现Ordered接口的
	4.最后注册没有实现任何优先级接口的
	5.最终注册MergedBeanDefinitionPostProcessor；
	6.注册一个ApplicationListenerDetector；来在bean创建完成后检查是否是ApplicationListener，如果是
		applicationContext.addApplicationListener((ApplicationListener<?>) bean);

7、initMessageSource();初始化MessageSource组件（做国际化功能；消息绑定，消息解析）；
	1.获取BeanFactory
	2.看容器中是否有ID为messageSource的，类型是MessageSouce组件
		如果有赋值给messageSource，如果没有自己创建一个DelegatingMessageSource；
			MessageSource：取出国际化配置文件中的某个key的值；能按照区域信息获取；
	3.把创建好的MessageSource注册在容器中，以后获得国际化配置文件的值得时候，可以自动注入MessageSource；
			beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);	
			MessageSource.getMessage(String code, Object[] args, String defaultMessage, Locale locale);

8、initApplicationEventMulticaster();初始化事件派发器；	
	1.获取BeanFactory
	2.从BeanFactory中获取applicationEventMulticaster的ApplicationEventMulticaster；
	3.如果上一步没有配置，创建一个SimpleApplicationEventMulticaster
	4.将创建的ApplicationEventMulticaster添加到BeanFactory中，以后其他组件直接自动注入

9、onRefresh();留给子容器（子类）
		1、子类重写这个方法，在容器刷新的时候可以自定义逻辑；
		
10、registerListeners();给容器中将所有项目里面的ApplicationListener注册进来；
		1、从容器中拿到所有的ApplicationListener
		2、将每个监听器添加到事件派发器中；
			getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
		3、派发之前步骤产生的事件；

11.finishBeanFactoryInitialization(beanFactory);初始化所有剩下的单实例bean；
	1.获取容器中所有的bean，依次进行初始化和创建对象 
	2.拿到bean的定义信息：RootBeanDefinition
	3.判断bean不是抽象的，是单实例的，是懒加载的；
		1.判断是否是FactoryBean;是否是实现FactoryBean接口的Bean
		2.不是工厂bean，利用getBean(beanName);创建对象
			0.getBean(beanName);ioc.getBean();
			1、doGetBean(name, null, null, false);
			2.先过去缓存中保存的单实例Bean。如果能获取到说明这个Bean之前被创建过（所有创建过的单实例Bean都会被缓存起来）
				从private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(256);获取的
			3.缓存中获取不到，开始bean的创建对象流程
			4.标记当前bean已经被创建
			5.获取bean的定义信息
			6.【获取当前bean依赖的其他bean；如果有 按照getBean()把依赖的Bean先创建出来；】
			7.启动单实例Bean的创建流程：
				1.createBean(beanName, mbd, args);
				2.Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
					让BeanPostProcessor先拦截返回代理对象；
					【InstantiationAwareBeanPostProcessor】：提前执行；
					先触发：postProcessBeforeInstantiation()；
					如果有返回值：触发postProcessAfterInitialization()；
				3.如果前面的InstantiationAwareBeanPostProcessor没有返回代理对象；调用4
				4. Object beanInstance = doCreateBean(beanName, mbdToUse, args);创建Bean
					1.【创建Bean实例】；createBeanInstance(beanName, mbd, args);
						利用工厂方法或者对象的构造器创建出Bean实例
					2.applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
						调用MergedBeanDefinitionPostProcessor的postProcessMergedBeanDefinition(mbd, beanType, beanName);
					3.【bean属性赋值】	populateBean(beanName, mbd, instanceWrapper);
						赋值之前：
							1.拿到InstantiationAwareBeanPostProcessor后置处理器；
								postProcessAfterInstantiation()；
							2.拿到InstantiationAwareBeanPostProcessor后置处理器；
						 		postProcessPropertyValues()；		
						========赋值之前====		
							3.应用Bean属性的值：为属性利用setter方法等进行赋值；
								applyPropertyValues(beanName, mbd, bw, pvs)
					4.【bean初始化】initializeBean(beanName, exposedObject, mbd);
						1）、【执行Aware接口方法】invokeAwareMethods(beanName, bean);执行xxxAware接口的方法
						 		BeanNameAware\BeanClassLoaderAware\BeanFactoryAware
						 2）、【执行后置处理器初始化之前】applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
						 		BeanPostProcessor.postProcessBeforeInitialization（）;
						 3）、【执行初始化方法】invokeInitMethods(beanName, wrappedBean, mbd);
						 		1）、是否是InitializingBean接口的实现；执行接口规定的初始化；
						 		2）、是否自定义初始化方法；
						 4）、【执行后置处理器初始化之后】applyBeanPostProcessorsAfterInitialization
						 		BeanPostProcessor.postProcessAfterInitialization()；
					5.注册Bean的销毁方法；
				5.将创建的bean添加到缓存中singletonObjects；
	
				ioc容器就是这些Map:很多的Map里面保存了单实例bean，环境信息。。。
		
				所有bean都利用getBean创建完成以后；
					检查所有的Bean是否是SmartInitializingSingleton接口的；如果是；就执行afterSingletonsInstantiated()；

12. finishRefresh();完成BeanFactory的初始化创建工作；IOC容器就创建完成；					
	1.initLifecycleProcessor();初始化和声明周期有关的后置处理器；LifecycleProcessor
		默认从容器中找是否有LifecycleProcessor的组件【LifecycleProcessor】；如果没有new DefaultLifecycleProcessor();
		加入到容器；
		写一个LifecycleProcessor的实现类，可以在BeanFactory		
			void onRefresh();
			void onClose();	
	2.getLifecycleProcessor().onRefresh();
		拿到前面定义的声明周期处理器（BeanFactory）；回调onRefresh();
	3.publishEvent(new ContextRefreshedEvent(this));发布容器刷新完成事件；
	4.liveBeansView.registerApplicationContext(this);
=============总结============
		1.Spring容器在启动的时候，会先保存所有注册进来的Bean的定义信息；
			1.xml注册bean
			2.使用@Bean注解；@Service,@Componenet,@Bean....xxx
		2.spring容器会在何时的时机创建这些bean
			1.用到这个bean的时候；利用getBean创建bean；创建好以后保存在容器中
			2.统一创建剩下所有的bean的时候；finishBeanFactoryInitialization()；
		3.后置处理器:
			1.每一个bean创建完成，都会使用各种后置处理器进行处理，来增强bean的功能；
				AutowiredAnnotationBeanPostProcessor:处理自动注入
				AnnotationAwareAspectJAutoProxyCreator:来做AOP功能；
				xxx....
				增强的功能注解：
				AsyncAnnotationBeanPostProcessor
				....
		4.事件驱动模型：
			ApplicationListener；事件监听；
			ApplicationEventMulticaster；事件派发：