spring容器的初始化
spring容器的refresh() 创建刷新
1.prepareRefresh() 刷新前的预处理
1.1 initPropertySources();初始化一些属性设置,该方法为空方法,让子类自定义个性化属性配置
1.2 getEnvironment().validateRequiredProperties(); 检验属性的合法性等
1.3 Set<ApplicationEvent> earlyApplicationEvents = new LinkedHashSet<>(); 保存容器中的一些早期事件
2.obtainFreshBeanFactory() 获取BeanFactory
2.1 refreshBeanFactory();刷新【创建】BeanFactory
2.1.1 在GenericApplicationContext构造方法中创建this.beanFactory = new DefaultListableBeanFactory();
2.1.2 设置序列化id
2.2 getBeanFactory();返回刚刚创建的BeanFactory对象。将创建的DefaultListableBeanFactory返回
3.prepareBeanFactory(beanFactory);BeanFactory的预准备工作(BeanFactory进行一些设置)
3.1 设置BeanFactory的类加载器、支持表达式解析器...
3.2 添加部分BeanPostProcessor【ApplicationContextAwareProcessor】
3.3 设置忽略的自动装配的接口EnvironmentAware、EmbeddedValueResolverAware等
3.4 注册可以解析的自动装配,我们能直接在任何组件中自动注入:
BeanFactory、ResourceLoader、ApplicationEventPublisher、ApplicationContext
3.5 添加BeanPostProcessor【ApplicationListenerDetector】 事件探测器
3.6 添加编译时的AspectJ
3.7 给BeanFactory中注册一些能用的组件
environment【ConfigurableEnvironment】
systemProperties【Map<String, Object>】
systemEnvironment【Map<String, Object>】
4.postProcessBeanFactory(beanFactory);BeanFactory准备工作完成之后进行的后置处理工作
空方法,子类通过重写这个方法来在BeanFactory创建并预准备完成以后做进一步的配置
5.invokeBeanFactoryPostProcessors(beanFactory);执行BeanFactoryPostProcessor
BeanFactoryPostProcessor:BeanFactory的后置处理器。在BeanFactory标准初始化之后执行的;
两个接口:BeanFactoryPostProcessor(后执行)、BeanDefinitionRegistryPostProcessor(先执行)
5.1 执行PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());方法
5.1.1 先执行BeanDefinitionRegistryPostProcessor
5.1.1.1 获取所有的BeanDefinitionRegistryPostProcessor
5.1.1.2 先执行实现了PriorityOrdered优先级接口的BeanDefinitionRegistryPostProcessor
遍历postProcessor调用postProcessor.postProcessBeanDefinitionRegistry(registry);
5.1.1.3 再执行实现了Ordered顺序接口的BeanDefinitionRegistryPostProcessor
遍历postProcessor调用postProcessor.postProcessBeanDefinitionRegistry(registry);
5.1.1.4 最后执行没有实现任何优先级或者顺序接口的BeanDefinitionRegistryPostProcessor
遍历postProcessor调用postProcessor.postProcessBeanDefinitionRegistry(registry);
5.1.2 再执行BeanFactoryPostProcessors
5.1.2.1 获取所有的BeanFactoryPostProcessor
5.1.2.2 First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
遍历BeanFactoryPostProcessor调用postProcessor.postProcessBeanFactory(beanFactory);
5.1.2.3 Next, invoke the BeanFactoryPostProcessors that implement Ordered.
遍历BeanFactoryPostProcessor调用postProcessor.postProcessBeanFactory(beanFactory);
5.1.2.4 Finally, invoke all other BeanFactoryPostProcessors.
遍历BeanFactoryPostProcessor调用postProcessor.postProcessBeanFactory(beanFactory);
6.registerBeanPostProcessors(beanFactory);注册BeanPostProcessor(bean的后置处理器)
不同接口类型的BeanPostFactory;在Bean创建前后的执行时机是不一样的
BeanPostProcessor
DestructionAwareBeanPostProcessor
InstantiationAwareBeanPostProcessor
SmartInstantiationAwareBeanPostProcessor
MergedBeanDefinitionPostProcessor
6.1 获取所有的BeanPostProcessor;后置处理器默认可以通过PriorityOrdered、Ordered接口来执行优先级
6.2 First, register the BeanPostProcessors that implement PriorityOrdered.
把每一个BeanPostProcessor,添加到BeanFactory中
beanFactory.addBeanPostProcessor(postProcessor);
6.3 Next, register the BeanPostProcessors that implement Ordered.
6.4 注册没有实现任何优先级接口的
6.5 注册internal BeanPostProcessors 【MergedBeanDefinitionPostProcessor】
6.6 最后注册一个ApplicationListenerDetector探测器,来在Bean创建完成后检查是否是ApplicationListener,如果是就注册
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
7.initMessageSource();初始化MessageSource组件(做国际化功能,消息绑定,消息解析)
7.1 获取BeanFactory
7.2 先检查容器中是否有messageSource的,类型是messageSource
如果有赋值给messageSource,如果没有就创建一个DelegatingMessageSource,赋值给messageSource
messageSource:取出国际化配置文件中的某一个key的值,能按照区域信息获取
String getMessage(String code, @Nullable Object[] args, @Nullable String defaultMessage, Locale locale);
7.3 把创建好的MessageSource注册在容器中,以后获取国际化配置的时候,可以自动注入MessageSource
beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
8.initApplicationEventMulticaster(); 初始化事件广播器
8.1 获取BeanFactory
8.2 从BeanFactory中获取applicationEventMulticaster
8.3 如果上一步没有配置,创建一个SimpleApplcationEventMulticaster
8.4 将创建好的ApplicationEventMulticaster添加到BeanFactory中,以后其他组件直接自己注入
9.onRefresh();
空实现,子类重写,在容器刷新的时候可以自定义逻辑
10.registerListeners();初始化事件派发器、监听器等,给容器中把所有项目里ApplicationListener注册进来
10.1 从容器中获取所有的ApplicationListener
10.2 将每个监听器添加到事件派发器中
getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
10.3 派发上面产生的事件
getApplicationEventMulticaster().multicastEvent(earlyEvent);
11.finishBeanFactoryInitialization(beanFactory); 初始化剩下的单实例Bean
11.1 beanFactory.preInstantiateSingletons(); 初始化所有剩下的单实例Bean
11.1.1 获取容器中所有的Bean,依次进行初始化和创建对象
11.1.2 获取Bean的定义信息,RootBeanDefinition
11.1.3 判断Bean不是抽象的 且 是单实例的 且 不是懒加载的
11.1.3.1 判断是否是FactoryBean,即是否是实现了FactoryBean接口的Bean
如果不是FactoryBean,则getBean(beanName);创建对象
11.1.3.1.0)getBean(beanName);
11.1.3.1.1)doGetBean(name, null, null, false);
11.1.3.1.2)先获取缓存中的Bean,如果能获取到说明这Bean之前被创建过(所有创建过的Bean都会被缓存起来)
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);保存容器中共的单实例Bean
11.1.3.1.3)缓存中获取不到,开始Bean的创建对象流程,获取BeanFactory
11.1.3.1.4)标记当前Bean已经在被创建(防止多线程同时创建)
11.1.3.1.5)获取Bean的定义信息 RootBeanDefinition
11.1.3.1.6)【获取当前Bean依赖的其他Bean,如果有getBean()把依赖的Bean创建出来】
11.1.3.1.7)启动单实例Bean的创建流程
11.1.3.1.7.1 createBean(beanName, mbd, args);
1)Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
InstantiationAwareBeanPostProcessors 提前执行
2)先依次触发所有BeanPostProcessor.postProcessBeforeInstantiation();
3)如果有返回值在依次触发BeanPostProcessor.postProcessAfterInitialization();
11.1.3.1.7.2 如果前面InstantiationAwareBeanPostProcessors没有返回代理对象,调用3)
11.1.3.1.7.3 doCreateBean(beanName, mbdToUse, args);创建Bean实例
1)创建Bean实例;createBeanInstance(beanName, mbd, args);
利用工厂方法或者对象的构造器创建出Bean实例
2)applyMergedBeanDefinitionPostProcessors();
调用MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition()
3)Bean属性赋值】populateBean(beanName, mbd, instanceWrapper);
赋值之前:
①拿到InstantiationAwareBeanPostProcessor后置处理器
postProcessAfterInstantiation()
②拿到InstantiationAwareBeanPostProcessor后置处理器
postProcessPropertyValues()
-------赋值之前---------
③应用Bean属性值:为属性利用setter方法等进行赋值
applyPropertyValues(beanName, mbd, bw, pvs);
4)【Bean初始化】initializeBean(beanName, exposedObject, mbd);
5)【注册Bean的销毁方法】registerDisposableBeanIfNecessary(beanName, bean, mbd);
11.1.3.1.7.4 将创建的Bean添加到缓存中singletonObjects:
ioc容器就是这些Map;很多的Map里面保存了单实例Bean,环境信息等....
所有的Bean都利用getBean创建完成之后
检查所有的Bean是否是SmartInitializingSingleton接口的实现类,如果是就执行smartSingleton.afterSingletonsInstantiated();
12.finishRefresh();完成BeanFactory的初始化创建工作;IOC容器创建完成;
12.1 initLifecycleProcessor();初始化与生命周期相关的后置处理器;LifecycleProcessor
默认从容器中找是否有lifecycleProcessor的组件,如果没有获取到,创建一个默认的 new DefaultLifecycleProcessor(); 加入到容器中
自定义LifecycleProcessor的是实现类,可以回调
void onRefresh();
void onClose();
12.2 getLifecycleProcessor().onRefresh();
拿到前面定义的生命周期处理器(BeanFactory);回调onRefresh();
12.3 publishEvent(new ContextRefreshedEvent(this));
发布容器刷新完成事件
12.4 LiveBeansView.registerApplicationContext(this);
------总结-------
1.spring容器在启动的时候,会先保存所有注册进来的Bean的定义信息
1.1 XML注册bean: <bean/>
1.2 注解注册Bean:@Service @Component @Bean ...
2.spring会找到合适的时机创建这些Bean
2.1 用到这个Bean的时候,利用getBean创建Bean;创建好之后保存在容器中
2.2 统一创建剩下所有的bean的时候,finishBeanFactoryInitialization()
3.后置处理器:BeanPostProcessor
3.1 每一个bean创建完成,都会使用各种后置处理器进行处理;来增强bean的功能;
AutowiredAnnotationBeanPostProcessor 处理自动注入
AnnotationAwareAspectJAutoProxyCreator 来做AOP功能
增强的功能注解:
AsyncAnnotationBeanPostProcessor
4.事件驱动模型
ApplicationListener 事件监听
ApplicationEventMulticaster 事件派发器
-------其他需要注意---------
1.如果类实现了InitializingBean 接口
1.1 Spring为bean提供了两种初始化bean的方式,实现InitializingBean接口,实现afterPropertiesSet方法,或者在配置文件中通过init-method指定,两种方式可以同时使用。
1.2实现InitializingBean接口是直接调用afterPropertiesSet方法,比通过反射调用init-method指定的方法效率要高一点,但是init-method方式消除了对spring的依赖。
1.3如果调用afterPropertiesSet方法时出错,则不调用init-method指定的方法。
1.4如果即实现了InitializingBean,又指定了init-method,就先调用afterPropertiesSet,再调用init-method
2.如果类实现了FactoryBean接口
可以让我们自定义Bean的创建过程
public interface FactoryBean<T> {
T getObject() throws Exception;
Class<?> getObjectType();
boolean isSingleton();
}
3.BeanFactory接口
BeanFactory是Spring容器中的一个基本类也是很重要的一个类,在BeanFactory中可以创建和管理Spring容器中的Bean,它对于Bean的创建有一个统一的流程。