IOC容器创建
new AnnotationConfigApplicationContext(ExtConfig.class);
构造函数 AnnotationConfigApplicationContext(Class<?>... annotatedClasses)
1、无参构造器：this()
创建：
AnnotatedBeanDefinitionReader 注解Bean定义的读取器
ClassPathBeanDefinitionScanner 扫描Bean定义的扫描器
2、注册配置类：register(annotatedClasses)
AnnotatedBeanDefinitionReader.register(annotatedClasses)
3、刷新容器：AbstractApplicationContext.refresh()
1）prepareRefresh()：容器刷新前的预准备
设置启动时间，active标志及initPropertySources
i）initPropertySources：初始化属性资源=》子类自定义个性化的属性设置方法;
ii）validateRequiredProperties()：验证需要的属性合法性
iii）earlyApplicationEvents = new LinkedHashSet<>()：保存容器中早期事件集合
2）obtainFreshBeanFactory()：获取bean工厂，调用子类方法，刷新内部的bean工厂
i）GenericApplicationContext.refreshBeanFactory()：【创建】BeanFactory
- 创建beanfactory：public GenericApplicationContext() {this.beanFactory = new DefaultListableBeanFactory();}
- 设置序列化id：setSerializationId()
ii）GenericApplicationContext.getBeanFactory():获取创建的beanFactory对象
iii）返回beanFactory【DefaultListableBeanFactory】对象
3）prepareBeanFactory(beanFactory)：BeanFactory的预准备（设置BeanFactory）
i）设置类加载器：setBeanClassLoader
ii）设置支持表达式的解析器：setBeanExpressionResolver
iii）添加属性编辑注册器：addPropertyEditorRegistrar
iv）添加部分的BeanPostProcessor：addBeanPostProcessor(new ApplicationContextAwareProcessor(this))
v）设置忽略的自动装配的接口：EnvironmentAware、ApplicationContextAware等
vi）注册可以解析的自动装配，可以在容器中自动注入（通过autowire注入）
BeanFactory、ResourceLoader、ApplicationEventPublisher、ApplicationContext；
vii）添加后置处理器：ApplicationListenerDetector
viii）添加编译时的AspectJ；
ix）给BeanFactory中注册一些能用的组件；
- environment【ConfigurableEnvironment】
- systemProperties【Map<String, Object>】
- systemEnvironment【Map<String, Object>】
4）postProcessBeanFactory(beanFactory)：BeanFactory准备工作完成后进行的后置处理工作
- 子类通过重写这个方法来在BeanFactory创建并预准备完成以后做进一步的设置
***********************以上是BeanFactory的创建及预准备工作*******************
5）invokeBeanFactoryPostProcessors(beanFactory)：将BeanFactory的后置处理器注册到容器中
BeanFactoryPostProcessor：BeanFactory的后置处理器，在BeanFactory标准初始化之后执行的；
两个接口：BeanFactoryPostProcessor、BeanDefinitionRegistryPostProcessor
i）先执行BeanDefinitionRegistryPostProcessor
1.beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class)
先获取所有的BeanDefinitionRegistryPostProcessor
2.先执行实现PriorityOrdered.class的BeanDefinitionRegistryPostProcessor
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry)
postProcessor.postProcessBeanDefinitionRegistry(registry);
3.然后执行实现Ordered.class的BeanDefinitionRegistryPostProcessor
4.最后执行没有任何优先级或顺序的BeanDefinitionRegistryPostProcessor
ii）再执行BeanFactoryPostProcessor
1.beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class)
先获取所有的BeanFactoryPostProcessor
2.先执行实现PriorityOrdered.class的BeanFactoryPostProcessor
invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory)
postProcessor.postProcessBeanFactory(beanFactory)
3.然后执行实现Ordered.class的BeanFactoryPostProcessor
4.最后执行没有任何优先级或顺序的BeanFactoryPostProcessor
6）registerBeanPostProcessors(beanFactory)：注册Bean的后置处理器，拦截Bean的创建过程
不同接口类型的BeanPostProcessor，在Bean创建前后的执行时机是不一样的；
- BeanPostProcessor、
- DestructionAwareBeanPostProcessor、
- InstantiationAwareBeanPostProcessor、
- SmartInstantiationAwareBeanPostProcessor、
- MergedBeanDefinitionPostProcessor【internalPostProcessors】
i）获取所有的BeanPostProcessor（后置处理器都默认可以通过PriorityOrdered、Ordered接口来执行优先级）
ii）先注册实现PriorityOrdered.class接口的BeanPostProcessor
iii）再注册实现Ordered.class接口的BeanPostProcessor
iv）然后执行没有任何优先级或顺序的BeanPostProcessor
v）然后注册MergedBeanDefinitionPostProcessor（internalPostProcessors）
vi）最后注册一个ApplicationListenerDetector（用来在Bean创建完成后检查是否是ApplicationListener，
如果是applicationContext.addApplicationListener((ApplicationListener<?>) bean);
- postProcessAfterInitialization() 后置处理
- if (bean instanceof ApplicationListener) {applicationContext.addApplicationListener((ApplicationListener<?>) bean)}
7）initMessageSource()：初始化MessageSource组件（国际化功能；消息绑定，消息解析）
i）获取BeanFactory
ii）判断容器中有id=messageSource且类型为MessageSource.class的bean
MessageSource.class:取出国际化配置文件中的某个key的值；能按照区域信息获取；
- 有：赋值给messageSource
- 无：自己创建一个DelegatingMessageSource
iii）把创建好的messageSource注册到容器中，可以自动注入
beanFactory.registerSingleton("messageSource", this.messageSource)
8）initApplicationEventMulticaster()：初始化事件派发器
i）获取BeanFactory
ii）判断容器中是否有applicationEventMulticaster 且 ApplicationEventMulticaster.class 类型的bean
- 有：赋值给applicationEventMulticaster
- 无：创建一个SimpleApplicationEventMulticaster
iii）把创建的applicationEventMulticaster注册到容器中，可以自动注入
beanFactory.registerSingleton("applicationEventMulticaster", this.applicationEventMulticaster);
9）onRefresh()：留给子容器（子类），初始化其他指定的bean
i）子类重写这个方法，在容器刷新的时候自定义逻辑；
10）registerListeners()：给容器中将所有项目里面的ApplicationListener注册进来
i）获取所有ApplicationListener
getBeanNamesForType(ApplicationListener.class)
ii）将事件监听器添加到事件派发器中
getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
iii）派发之前步骤产生的事件
getApplicationEventMulticaster().multicastEvent(earlyApplicationEvents);
11）finishBeanFactoryInitialization(beanFactory)：初始化所有剩下的非懒加载的单例bean
i）初始化后剩下的单实例bean
beanFactory.preInstantiateSingletons()
1.获取容器中的所有bean，循环遍历依次进行初始化和创建对象
2.获取Bean的定义信息；RootBeanDefinition
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName)
3.Bean不是抽象的，是单实例的，是懒加载；if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit())
a）判断是FactoryBean（是否是实现FactoryBean接口的Bean）：调用FactoryBean.getObject()方法创建bean
b）不是FactoryBean：getBean(beanName);创建Bean
i）getBean(beanName);
ii）doGetBean(name, null, null, false);
iii）先获取缓存中的单实例bean，如果能获取说明bean已经被创建过（所有创建过的单实例Bean都会被缓存起来）
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
iv）缓存中获取不到，开始Bean的创建对象流程；
v）标记当前bean已经被创建，markBeanAsCreated(beanName)：放置多线程创建非单实例
vi）获取bean 的定义信息 RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName)
vii）获取当前Bean依赖的其他Bean;如果有按照getBean()把依赖的Bean先创建出来：String[] dependsOn = mbd.getDependsOn()
viii）启动单实例Bean的创建流程:createBean()
1-createBean()
2-先拦截返回代理对象:Object bean = resolveBeforeInstantiation(beanName, mbdToUse);让BeanPostProcessor
InstantiationAwareBeanPostProcessor:提前执行
先触发：postProcessBeforeInstantiation()
如果有返回值：触发postProcessAfterInitialization()
3-如果前面的InstantiationAwareBeanPostProcessor没有返回代理对象；继续；
4-创建bean：Object beanInstance = doCreateBean(beanName, mbdToUse, args);
> 创建Bean实例:createBeanInstance(beanName, mbd, args),利用工厂方法或者对象的构造器创建出Bean实例
> MergedBeanDefinitionPostProcessor后置处理:applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName),执行MergedBeanDefinitionPostProcessor的postProcessMergedBeanDefinition(mbd, beanType, beanName)
> Bean属性赋值:populateBean(beanName, mbd, instanceWrapper)
>> 获取InstantiationAwareBeanPostProcessor，调用postProcessAfterInstantiation()
>> 获取InstantiationAwareBeanPostProcessor，调用postProcessProperties()
>> 应用Bean属性的值,为属性利用setter方法等进行赋值,applyPropertyValues(beanName, mbd, bw, pvs);
> Bean初始化：initializeBean(beanName, exposedObject, mbd)
>> 执行Aware接口方法：invokeAwareMethods(beanName, bean) 【BeanNameAware、BeanClassLoaderAware、BeanFactoryAware】
>> 调用后置处理器初始化之前的方法：applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
BeanPostProcessor.postProcessBeforeInitialization()
>> 执行初始化方法：invokeInitMethods(beanName, wrappedBean, mbd)
>>> [是]InitializingBean：按照接口规定进行初始化
>>> [是]自定义初始化方法执行：invokeCustomInitMethod(beanName, bean, mbd)
>> 调用后置处理器初始化之后的方法：applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName)
BeanPostProcessor.postProcessAfterInitialization()
> 注册Bean的销毁方法:registerDisposableBeanIfNecessary(beanName, bean, mbd)
5-将创建的bean添加到缓存中（singletonObjects）：addSingleton(beanName, singletonObject);
IOC容器就是这些Map，很多Map中保存着单例Bean，环境信息等
4.所有bean通过getBean()创建完成后，遍历所有bean，检查是否SmartInitializingSingleton接口的；
- 是：执行SmartInitializingSingleton.afterSingletonsInstantiated()
12）finishRefresh()：完成BeanFactory的初始化创建工作,IOC容器就创建完成
1.clearResourceCaches()
2.初始化和生命周期有关的后置处理器：initLifecycleProcessor()-LifecycleProcessor
默认从容器中找是否有lifecycleProcessor的组件【LifecycleProcessor】
- 否：new DefaultLifecycleProcessor() 加入容器，可以自动注入；
3.拿到LifecycleProcessor，生命周期处理器（BeanFactory），回调onRefresh()：getLifecycleProcessor().onRefresh()；
4.发布容器刷新完成事件：publishEvent(new ContextRefreshedEvent(this))
5.Participate in LiveBeansView MBean, if active：liveBeansView.registerApplicationContext(this)
总结
- Spring容器启动过程中，会先将所有注册进来bean信息保存起来。
- xml 配置文件的方式：<bean>
- 注解的方式：@Component、@Repository、@Service、@Controller、@Bean 等
- Spring 容器在适当的时机创建这些Bean
- 通过getBean方法，先从缓存中尝试获取，如果获取不到则创建，创建完成，如果是单实例，则放入缓存，以便下次调用使用。
- 通过finishBeanFactoryInitialization() 方法统一创建剩下的所有Bean
- BeanPostProcessor ：后置处理器，充斥在Spring容器创建的过程中。
- 每一个Bean的创建过程中，会被多种后置处理器处理增强
- AutowiredAnnotationBeanPostProcessor:处理自动注入
- AnnotationAwareAspectJAutoProxyCreator:来做AOP功能；
- ...
- 每一个Bean的创建过程中，会被多种后置处理器处理增强
- 事件驱动模型
ApplicationListener 事件监听器
ApplicationEventMulticaster 事件派发器
扫一扫
1449
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
