Spring注解驱动:主要原理(三)

1.扩展原理


 * 扩展原理:
 * BeanPostProcessor:bean后置处理器,bean创建对象初始化前后进行拦截工作的
 * 
 * 1、BeanFactoryPostProcessor:beanFactory的后置处理器;
 * 		在BeanFactory标准初始化之后调用,来定制和修改BeanFactory的内容;
 * 		所有的bean定义已经保存加载到beanFactory,但是bean的实例还未创建
 * 
 * 
 * BeanFactoryPostProcessor原理:
 * 1)、ioc容器创建对象
 * 2)invokeBeanFactoryPostProcessors(beanFactory);
 * 		如何找到所有的BeanFactoryPostProcessor并执行他们的方法;
 * 			1)、直接在BeanFactory中找到所有类型是BeanFactoryPostProcessor的组件,并执行他们的方法
 * 			2)、在初始化创建其他组件前面执行
 * 
 * 2、BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor
 * 		postProcessBeanDefinitionRegistry();
 * 		在所有bean定义信息将要被加载,bean实例还未创建的;
 * 
 * 		优先于BeanFactoryPostProcessor执行;
 * 		利用BeanDefinitionRegistryPostProcessor给容器中再额外添加一些组件;
 * 
 * 	原理:
 * 		1)、ioc创建对象
 * 		2)、refresh()-invokeBeanFactoryPostProcessors(beanFactory);
 * 		3)、从容器中获取到所有的BeanDefinitionRegistryPostProcessor组件。
 * 			1、依次触发所有的postProcessBeanDefinitionRegistry()方法
 * 			2、再来触发postProcessBeanFactory()方法BeanFactoryPostProcessor;
 * 
 * 		4)、再来从容器中找到BeanFactoryPostProcessor组件;然后依次触发postProcessBeanFactory()方法
 * 	
 * 3、ApplicationListener:监听容器中发布的事件。事件驱动模型开发;
 * 	  public interface ApplicationListener<E extends ApplicationEvent>
 * 		监听 ApplicationEvent 及其下面的子事件;
 * 
 * 	 步骤:
 * 		1)、写一个监听器(ApplicationListener实现类)来监听某个事件(ApplicationEvent及其子类)
 * 			@EventListener;
 * 			原理:使用EventListenerMethodProcessor处理器来解析方法上的@EventListener* 
 * 		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();
 * 		
 * 
 *

1.1 BeanFactoryPostProcessor

@Component
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        System.out.println("MyBeanFactoryPostProcessor...postProcessBeanFactory...");
        int count = beanFactory.getBeanDefinitionCount();
        String[] names = beanFactory.getBeanDefinitionNames();
        System.out.println("当前BeanFactory中有"+count+" 个Bean");
        System.out.println(Arrays.asList(names));
    }

}
public class Blue {
    public Blue() {
        System.out.println(" Blue构造方法执行.. ");
    }
}
@ComponentScan("com.zy.ext")
@Configuration
public class ProConfig {
    @Bean
    public Blue blue(){
        return new Blue();
    }
}
    @Test
    public void testProc(){
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(ProConfig.class);
        applicationContext.close();
    }

在这里插入图片描述

1.2 BeanDefinitionRegistryPostProcessor

在上一个代码中,增加一个BeanDefinitionRegistryPostProcessor类

@Component
public class MyBeanDefinitionRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor{

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        // TODO Auto-generated method stub
        System.out.println("MyBeanDefinitionRegistryPostProcessor...bean的数量:"+beanFactory.getBeanDefinitionCount());
    }

    //BeanDefinitionRegistry Bean定义信息的保存中心,以后BeanFactory就是按照BeanDefinitionRegistry里面保存的每一个bean定义信息创建bean实例;
    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
        // TODO Auto-generated method stub
        System.out.println("postProcessBeanDefinitionRegistry...bean的数量:"+registry.getBeanDefinitionCount());
        //RootBeanDefinition beanDefinition = new RootBeanDefinition(Blue.class);
        AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.rootBeanDefinition(Blue.class).getBeanDefinition();
        registry.registerBeanDefinition("hello", beanDefinition);
    }

}

在这里插入图片描述

1.3 ApplicationListener

@Component
public class MyApplicationListener implements ApplicationListener<ApplicationEvent> {

    //当容器中发布此事件以后,方法触发
    @Override
    public void onApplicationEvent(ApplicationEvent event) {
        // TODO Auto-generated method stub
        System.out.println("收到事件:"+event);
    }

}

在这里插入图片描述

1.4 @EventListener

@Service
public class ExtService {

    @EventListener(classes={ApplicationEvent.class})
    public void listen(ApplicationEvent event){
        System.out.println("ExtService。。监听到的事件:"+event);
    }
}

在这里插入图片描述

2.Spring容器创建原理

Spring容器的refresh()【创建刷新】;
1prepareRefresh()刷新前的预处理;
	1)、initPropertySources()初始化一些属性设置;子类自定义个性化的属性设置方法;
	2)、getEnvironment().validateRequiredProperties();检验属性的合法等
	3)、earlyApplicationEvents= new LinkedHashSet<ApplicationEvent>();保存容器中的一些早期的事件;
2obtainFreshBeanFactory();获取BeanFactory;
	1)、refreshBeanFactory();刷新【创建】BeanFactory;
			创建了一个this.beanFactory = new DefaultListableBeanFactory();
			设置id;
	2)、getBeanFactory();返回刚才GenericApplicationContext创建的BeanFactory对象;
	3)、将创建的BeanFactory【DefaultListableBeanFactory】返回;
3prepareBeanFactory(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>4postProcessBeanFactory(beanFactory);BeanFactory准备工作完成后进行的后置处理工作;
	1)、子类通过重写这个方法来在BeanFactory创建并预准备完成以后做进一步的设置
======================以上是BeanFactory的创建及预准备工作==================================
5invokeBeanFactoryPostProcessors(beanFactory);执行BeanFactoryPostProcessor的方法;
	BeanFactoryPostProcessor:BeanFactory的后置处理器。在BeanFactory标准初始化之后执行的;
	两个接口:BeanFactoryPostProcessor、BeanDefinitionRegistryPostProcessor
	1)、执行BeanFactoryPostProcessor的方法;
		先执行BeanDefinitionRegistryPostProcessor
		1)、获取所有的BeanDefinitionRegistryPostProcessor;
		2)、看先执行实现了PriorityOrdered优先级接口的BeanDefinitionRegistryPostProcessor、
			postProcessor.postProcessBeanDefinitionRegistry(registry)
		3)、在执行实现了Ordered顺序接口的BeanDefinitionRegistryPostProcessor;
			postProcessor.postProcessBeanDefinitionRegistry(registry)
		4)、最后执行没有实现任何优先级或者是顺序接口的BeanDefinitionRegistryPostProcessors;
			postProcessor.postProcessBeanDefinitionRegistry(registry)
			
		
		再执行BeanFactoryPostProcessor的方法
		1)、获取所有的BeanFactoryPostProcessor
		2)、看先执行实现了PriorityOrdered优先级接口的BeanFactoryPostProcessor、
			postProcessor.postProcessBeanFactory()
		3)、在执行实现了Ordered顺序接口的BeanFactoryPostProcessor;
			postProcessor.postProcessBeanFactory()
		4)、最后执行没有实现任何优先级或者是顺序接口的BeanFactoryPostProcessor;
			postProcessor.postProcessBeanFactory()
6registerBeanPostProcessors(beanFactory);注册BeanPostProcessor(Bean的后置处理器)【 intercept bean creation】
		不同接口类型的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);
7initMessageSource();初始化MessageSource组件(做国际化功能;消息绑定,消息解析);
		1)、获取BeanFactory
		2)、看容器中是否有id为messageSource的,类型是MessageSource的组件
			如果有赋值给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);
8initApplicationEventMulticaster();初始化事件派发器;
		1)、获取BeanFactory
		2)、从BeanFactory中获取applicationEventMulticaster的ApplicationEventMulticaster;
		3)、如果上一步没有配置;创建一个SimpleApplicationEventMulticaster
		4)、将创建的ApplicationEventMulticaster添加到BeanFactory中,以后其他组件直接自动注入
9onRefresh();留给子容器(子类)
		1、子类重写这个方法,在容器刷新的时候可以自定义逻辑;
10registerListeners();给容器中将所有项目里面的ApplicationListener注册进来;
		1、从容器中拿到所有的ApplicationListener
		2、将每个监听器添加到事件派发器中;
			getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
		3、派发之前步骤产生的事件;
11finishBeanFactoryInitialization(beanFactory);初始化所有剩下的单实例bean;
	1、beanFactory.preInstantiateSingletons();初始化后剩下的单实例bean
		1)、获取容器中的所有Bean,依次进行初始化和创建对象
		2)、获取Bean的定义信息;RootBeanDefinition
		3)、Bean不是抽象的,是单实例的,是懒加载;
			1)、判断是否是FactoryBean;是否是实现FactoryBean接口的Bean;
			2)、不是工厂Bean。利用getBean(beanName);创建对象
				0getBean(beanName); ioc.getBean();
				1doGetBean(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没有返回代理对象;调用44)、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()12finishRefresh();完成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;<bean>
		2)、注解注册Bean;@Service@Component@Bean、xxx
	2)、Spring容器会合适的时机创建这些Bean
		1)、用到这个bean的时候;利用getBean创建bean;创建好以后保存在容器中;
		2)、统一创建剩下所有的bean的时候;finishBeanFactoryInitialization()3)、后置处理器;BeanPostProcessor
		1)、每一个bean创建完成,都会使用各种后置处理器进行处理;来增强bean的功能;
			AutowiredAnnotationBeanPostProcessor:处理自动注入
			AnnotationAwareAspectJAutoProxyCreator:来做AOP功能;
			xxx....
			增强的功能注解:
			AsyncAnnotationBeanPostProcessor
			....
	4)、事件驱动模型;
		ApplicationListener;事件监听;
		ApplicationEventMulticaster;事件派发:
	

3.servlet3.0

后续更新吧。。

已标记关键词 清除标记
相关推荐
©️2020 CSDN 皮肤主题: 护眼 设计师:闪电赇 返回首页