BeanFactory的后置处理器:在BeanFactory标准初始化之后调用,来定制和修改BeanFactory的内容;所有的bean定义已经保存加载到beanFactory,但是bean的实例还未创建。
源码:MyBeanFactoryPostProcess
@Component public class Demo01_MyBeanFactoryPostProcess implements BeanFactoryPostProcessor { @Override public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException { System.out.println("MyBeanFactoryPostProcessor...postProcessBeanFactory..."); int definitionCount = beanFactory.getBeanDefinitionCount(); String[] definitionNames = beanFactory.getBeanDefinitionNames(); System.out.println("beanFactory中一共有 " + definitionCount + " 个bean,分别为: " + Arrays.toString(definitionNames)); } }
源码:MyBeanDefinitionRegistryPostProcessor
@Component public class Demo02_MyBeanDefinitionRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor { /** * @param registry Bean定义信息的保存中心,以后BeanFactory就是按照BeanDefinitionRegistry里面 * 保存的每一个bean定义信息创建bean实例; */ @Override public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException { System.out.println("postProcessBeanDefinitionRegistry...bean的数量:"+registry.getBeanDefinitionCount()); RootBeanDefinition definition = new RootBeanDefinition(Dog.class); registry.registerBeanDefinition("dog",definition); } @Override public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException { System.out.println("MyBeanDefinitionRegistryPostProcessor...bean的数量:"+beanFactory.getBeanDefinitionCount()); } }
源码:MyApplicationEvent
@Component public class Demo4_ApplicationEvent implements ApplicationListener { //监听所有ApplicationEvent以及其子类发布的事件 @Override public void onApplicationEvent(ApplicationEvent event) { System.out.println("ApplicaitonEvent ====> " + event); } }
【事件发布流程】:
publishEvent(new ContextRefreshedEvent(this));
for (final ApplicationListener<?> listener : getApplicationListeners(event, type)) {..}
【事件多播器(派发器)】
【容器中有哪些监听器】
源码:MyListener
/** * 普通方法加注解就可以监听任意指定的Class */ @EventListener(classes = {Cat.class}) public void listener(Cat cat){ System.out.println(cat); }
@EventListener -> EventListenerMethodProcessor -> SmartInitializingSingleton
SmartInitializingSingleton 原理:->afterSingletonsInstantiated();
//创建基于注解的springIOC容器 ApplicationContext applicationContext = new AnnotationConfigApplicationContext(BeanConfig.class); //创建基于配置文件的springIOC容器 ApplicationContext applicationContext = new ClassPathXmlApplicationContext("/spring-app.xml");
@Override public void refresh() throws BeansException, IllegalStateException { synchronized (this.startupShutdownMonitor) { // 1. Prepare this context for refreshing. prepareRefresh(); // 2. Tell the subclass to refresh the internal bean factory. ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory(); // 3. Prepare the bean factory for use in this context. prepareBeanFactory(beanFactory); try { // 4. Allows post-processing of the bean factory in context subclasses. postProcessBeanFactory(beanFactory); // 5. Invoke factory processors registered as beans in the context. invokeBeanFactoryPostProcessors(beanFactory); // 6. Register bean processors that intercept bean creation. registerBeanPostProcessors(beanFactory); // 7. Initialize message source for this context. initMessageSource(); // 8. Initialize event multicaster for this context. initApplicationEventMulticaster(); // 9. Initialize other special beans in specific context subclasses. onRefresh(); // 10. Check for listener beans and register them. registerListeners(); // 11. Instantiate all remaining (non-lazy-init) singletons. finishBeanFactoryInitialization(beanFactory); // 12. Last step: publish corresponding event. finishRefresh(); } catch (BeansException ex) { if (logger.isWarnEnabled()) { logger.warn("Exception encountered during context initialization - " + "cancelling refresh attempt: " + ex); } // Destroy already created singletons to avoid dangling resources. destroyBeans(); // Reset 'active' flag. 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(); } } }
(1) initPropertySources() 自定义属性设置,空方法,留给子类继承
(2) getEnvironment.validateRequiredProperties 首先获取环境配置,然后校验必需属性
(3) this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners); 初始化事件监听器
(4) this.earlyApplicationEvents = new LinkedHashSet<>(); 初始化早期事件
(1) refreshBeanFactory 新建一个组件工厂,类型为DefaultListableBeanFactory,然后对这个组件工厂设置了一个序列化ID
(2) getBeanFactory 返回刚刚创建的组件工厂
(1) 在组件工厂中设置类加载器、属性解析器等
(2) 在组件工厂中添加部分组件后置处理器,例如ApplicationContextAwareProcessor、ApplicationListenerDetector
(3) 在组件工厂中设置忽略自动注入的接口
(4) 设置自动装配规则
(5) 在组件工厂中注册一些组件,例如环境配置ConfigurableEnvironment
这一步是在组件工厂的标准初始化(1-4)之后进行的,主要是执行BeanFactoryPostProcessor及其子接口的
BeanFactoryPostProcessor的子接口主要是指BeanDefinitionRegistryPostProcessor,可以向容器中注册新的组件,这个接口的特点是有两个方法,一个是自身的postProcessBeanDefinitionRegistry,另一个继承自BeanFactoryPostProcessor的postProcessBeanFactory,从源码可以看出,spring会先执行BeanDefinitionRegistryPostProcessor类型的组件的自身方法,然后执行其继承方法,最后才调用非BeanDefinitionRegistryPostProcessor的BeanFactoryPostProcessor的后置处理方法
(1) 从容器器中获取BeanDefinitionRegistryPostProcessor类型的组件
(2) 将BeanDefinitionRegistryPostProcessor类型的组件按照顺序分类并排序,即是否实现了PriorityOrdered、Ordered接口
(3) 依次执行实现了PriorityOrdered接口的、实现了Ordered接口的、没有实现任何顺序接口的组件的postProcessBeanDefinitionRegistry方法
(4) 执行所有BeanDefinitionRegistryPostProcessor组件的postProcessBeanFactory方法
(5) 从容器中获取其他的BeanFactoryPostProcessor类型的组件,即不是BeanDefinitionRegistryPostProcessor类型的
(6) 剩下的步骤跟上面类似,就是先按照实现的顺序接口分类,在每个类别下排序,然后依次执行它们的postProcessBeanFactory方法
这种处理器用于拦截bean的创建过程。beanPostProcessor有很多子接口,每种子接口的执行时机各有不同
|-DestructionAwareBeanPostProcessor
|-InstantiationAwareBeanPostProcessor
|-MergedBeanDefinitionPostProcessor
|-SmartInstantiationAwareBeanPostProcessor
(1) 获取所有的beanPostProcessor的组件名
(2) 将所有的组件按优先顺序分为三类:
|-实现了PriorityOrdered接口的列表priorityOrderedPostProcessors
|-实现了Ordered接口的列表orderedPostProcessors
|-没有实现任何顺序接口的列表nonOrderedPostProcessors
还有一种特殊情况,凡是MergedBeanDefinitionPostProcessor类型的,都放在internalPostProcessors中
(3) 注册priorityOrderedPostProcessors
(4) 注册orderedPostProcessors
(5) 注册nonOrderedPostProcessors
(6) 注册internalPostProcessors
(7) 注册ApplicationListenerDetector,它的作用是在组件初始化之后判断其是否为ApplicationListner类型,如果是,则将其添加进容器的监听器集合。
用于消息绑定、消息解析等功能,并且提供国际化解决方案
(1) 获取beanFactory
(2) 判断beanFactory中是否包含id为messageSource的组件
(3) 如果已存在,则赋值给容器的messageSource属性,这种情况是我们自己在容器中注册了这个组件
(4) 如果不存在,则新建一个DelegatingMessageSource,并赋值给容器的messageSource属性,然后在beanFactory中注册这个新组件,并设置其id为messageSource
(1) 获取beanFactory
(2) 判断beanFactory中是否存在id为applicationEventMulticaster的组件
(3) 如果已存在,则赋值给容器的applicationEventMulticaster属性,这种情况是我们自己在容器中注册了这个组件
(4) 如果不存在,则新建一个SimpleApplicationEventMulticaster,并赋值给容器的 applicationEventMulticaster属性,然后在beanFactory中注册这个新组件, 并设置其id为applicationEventMulticaster。
留给子类继承的,我们可以自定义子容器,在重写方法中做一些我们想要的操作
(1) 获取容器的属性applicationListeners,这是一个事件监听器的集合,将集合中的每个元素都添加进事件广播器getApplicationEventMulticaster().addApplicationListener(listener);
(2) 从容器中获取所有ApplicationListener类型的组件,将这些组件添加进事件广播器
(3) 派发之前步骤产生的事件。
(1) 进入DefaultListableBeanFactory.preInstantiateSingletons方法,获取容器中所有的组件id列表
(2) 获取容器中的所有Bean,依次进行初始化和创建对象
(3) Bean不是抽象的,是单实例的,是非懒加载;
1)、判断是否是FactoryBean;是否是实现FactoryBean接口的Bean;如果是就用工厂bean来创建及FacBean中的getObject同SpringIOC中的二(3)。
2)、不是工厂Bean。利用getBean(beanName);创建对象
0、getBean(beanName); ioc.getBean();
1、AbstractBeanFactory.doGetBean(name, null, null, false);
2、先获取缓存中保存的单实例Bean。如果能获取到说明这个Bean之前被创建过(所有创建过的单实例Bean都会被缓存起来),Object sharedInstance = getSingleton(beanName);缓存到DefaultSingletonBeanRegistry类的singletonObjects单例对象存储的Map一级缓存。
3、缓存中获取不到,开始Bean的创建对象流程;
4、标记当前bean已经被创建,markBeanAsCreated(beanName);
5、获取Bean的定义信息;RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName)
6、【获取当前Bean依赖的其他Bean;如果有按照getBean(dep)把依赖的Bean先创建出来;】String[] dependsOn = mbd.getDependsOn()
7、启动单实例Bean的创建流程;
1)AbstractAutowireCapableBeanFactory.createBean(beanName, mbd, args);
2)Object bean = resolveBeforeInstantiation(beanName, mbdToUse);让BeanPostProcessor先拦截返回代理对象;【InstantiationAwareBeanPostProcessor】:提前执行;先触发:postProcessBeforeInstantiation();如果有返回值:触发postProcessAfterInitialization();
3)如果前面的InstantiationAwareBeanPostProcessor没有返回代理对象;调用AbstractAutowireCapableBeanFactory.doCreateBean创建Bean。
1. 【创建Bean实例】;createBeanInstance(beanName, mbd, args);利用工厂方法或者对象的构造器创建出Bean实例;
2. applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);调用MergedBeanDefinitionPostProcessor的postProcessMergedBeanDefinition(mbd, beanType, beanName);
3. 【Bean属性赋值】populateBean(beanName, mbd, instanceWrapper);
① 拿到InstantiationAwareBeanPostProcessor后置处理器;postProcessAfterInstantiation();
② 拿到InstantiationAwareBeanPostProcessor后置处理器;postProcessPropertyValues();
③ 为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);
① 是否是InitializingBean接口的实现;执行接口规定的初始化;
② 是否自定义初始化方法;
4. 【执行后置处理器初始化之后】applyBeanPostProcessorsAfterInitialization 也就是BeanPostProcessor.postProcessAfterInitialization();
5. 注册Bean的销毁方法;registerDisposableBeanIfNecessary(beanName, bean, mbd);
4)将创建的Bean添加到缓存中singletonObjects;
(1) 初始化生命周期处理器(LifecycleProcessor),先从BeanFactory中按类型获取,如果没有就新建一个DefaultLifecycleProcessor,并注册进BeanFactory
(2) 获取上一步注册的生命周期处理器,回调其onRefresh方法
(3) 发布容器刷新事件,即ContextRefreshedEvent
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
每一个bean创建完成,都会使用各种后置处理器进行处理;来增强bean的功能;
AutowiredAnnotationBeanPostProcessor:处理自动注入
AnnotationAwareAspectJAutoProxyCreator:来做AOP功能;
....
增强的功能注解:
AsyncAnnotationBeanPostProcessor
....
4)、事件驱动模型
ApplicationListener;事件监听;
ApplicationEventMulticaster;事件派发: