文章目录
- 一、容器的刷新
- 1. registerBeanPostProcessors(beanFactory)
- 2. initMessageSource()
- 3. initApplicationEventMulticaster()
- 4. onRefresh()
- 5. registerListeners()
- 6. finishBeanFactoryInitialization(beanFactory)
- 7. finishRefresh()
- 二、说明
https://blog.csdn.net/zxd1435513775/article/details/120886583?spm=1001.2014.3001.5501
Spring源码系列（三）——容器的刷新（上）
在上面这篇文章中，我们分析了到了refresh()方法中的invokeBeanFactoryPostProcessors(beanFactory)这个方法，那么下面接着来分析后面的方法。
我们知道，当程序执行完invokeBeanFactoryPostProcessors(beanFactory)这个方法是，Spring工厂的创建工作已经完成了。符合条件的类都已经转为为BeanDefinition了，但是呢，这些BeanDefinition都还没有创建，下面断点到此代码，看Spring工厂里面的具体情况。
再次强调一下这几个变量的意思：
beanDefinitionMap：存放Spring容器中的所有的BeanDefinition
beanDefinitionNames：存放Spring容器中的所有的beanName
singletonObjects：存放Spring容器中已经完成实例化的对象，这个集合里面存在的变量表示已经完成了实例化
一、容器的刷新下面来看一下这个名声在外的refresh()方法：
@Override
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// 准备工作，包括设置启动时间，是否激活标识位，初始化属性源(property source)配置
prepareRefresh();
// Tell the subclass to refresh the internal bean factory.
// 返回一个factory 为什么需要返回一个工厂？ 因为要对工厂进行初始化
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// Prepare the bean factory for use in this context.
// 准备工厂
prepareBeanFactory(beanFactory);
try {
// Allows post-processing of the bean factory in context subclasses.
// 这个方法在当前版本的spring是没用任何代码的，可能spring期待在后面的版本中去扩展吧
postProcessBeanFactory(beanFactory);
// Invoke factory processors registered as beans in the context.
// 调用BeanFactoryPostProcessors的后置处理器
invokeBeanFactoryPostProcessors(beanFactory);
//-------------------到此spring工厂完成创建工作--------------------------
// Register bean processors that intercept bean creation.
// 注册BeanPostProcessor后置处理器
registerBeanPostProcessors(beanFactory);
// Initialize message source for this context.
initMessageSource();
// Initialize event multicaster for this context.
// 初始化应用事件广播器
initApplicationEventMulticaster();
// Initialize other special beans in specific context subclasses.
onRefresh();
// Check for listener beans and register them.
registerListeners();
// Instantiate all remaining (non-lazy-init) singletons.
finishBeanFactoryInitialization(beanFactory);
// Last step: publish corresponding event.
finishRefresh();
} catch (BeansException 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();
}
}
}
此方法是向Spring容器中添加BeanPostProcessor，Spring容器中有一个集合用户存放这个BeanPostProcessor。下面看下断点调试图：
此方法执行前
此方法执行后：
下面来分析这个方法
此处提醒一下，在AnnotationConfigApplicationContext()构造方法中创建AnnotatedBeanDefinitionReader()读取器时，Spring自己往容器中添加了6个类，如下：
// 实现 BeanDefinitionRegistryPostProcessor,PriorityOrdered, ResourceLoaderAware, BeanClassLoaderAware, EnvironmentAware org.springframework.context.annotation.internalConfigurationAnnotationProcessor
// 继承 InstantiationAwareBeanPostProcessorAdapter(实现BeanPostProcessor) // 实现 BeanPostProcessor, MergedBeanDefinitionPostProcessor, PriorityOrdered, BeanFactoryAware org.springframework.context.annotation.internalAutowiredAnnotationProcessor
// 继承 InstantiationAwareBeanPostProcessorAdapter(实现BeanPostProcessor) // 实现 MergedBeanDefinitionPostProcessor, PriorityOrdered, BeanFactoryAware org.springframework.context.annotation.internalRequiredAnnotationProcessor
// 继承 InitDestroyAnnotationBeanPostProcessor // 实现 InstantiationAwareBeanPostProcessor, BeanFactoryAware, Serializable org.springframework.context.annotation.internalCommonAnnotationProcessor
// 实现 SmartInitializingSingleton, ApplicationContextAware org.springframework.context.event.internalEventListenerProcessor
// 实现 EventListenerFactory, Ordered org.springframework.context.event.internalEventListenerFactory
public static void registerBeanPostProcessors(
ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
// 从beanDefinitionNames集合中拿到所有类型是BeanPostProcessor名字
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
BeanPostProcessor集合中
// 新建一个BeanPostProcessorChecker，并放入到beanPostProcessor集合中
int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
// Separate between BeanPostProcessors that implement PriorityOrdered,
// Ordered, and the rest.
// 将实现prioritordered、Ordered和剩余的，BeanPostProcessors分开
List priorityOrderedPostProcessors = new ArrayList();
List internalPostProcessors = new ArrayList();
List orderedPostProcessorNames = new ArrayList();
List nonOrderedPostProcessorNames = new ArrayList();
for (String ppName : postProcessorNames) {
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
// 实现PriorityOrdered接口的BeanPostProcessor
// 根据名字去容器中拿对应的BeanPostProcessor
// 此处需要注意的是getBean()方法是从容器中拿，拿不到就创建
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
priorityOrderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
} else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
// 实现Ordered接口的BeanPostProcessor
orderedPostProcessorNames.add(ppName);
} else {
nonOrderedPostProcessorNames.add(ppName);
}
}
// First, register the BeanPostProcessors that implement PriorityOrdered.
// 排序
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
// 注册
registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
// Next, register the BeanPostProcessors that implement Ordered.
// 处理实现Ordered接口的BeanPostProcessor
List orderedPostProcessors = new ArrayList();
for (String ppName : orderedPostProcessorNames) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
orderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
sortPostProcessors(orderedPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, orderedPostProcessors);
// Now, register all regular BeanPostProcessors.
// 处理既没有实现PriorityOrdered接口也没有实现Ordered接口的BeanPostProcessor
List nonOrderedPostProcessors = new ArrayList();
for (String ppName : nonOrderedPostProcessorNames) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
nonOrderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
// Finally, re-register all internal BeanPostProcessors.
// internalPostProcessors里面存放的是实现MergedBeanDefinitionPostProcessor接口的类
sortPostProcessors(internalPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, internalPostProcessors);
// 在前面的方法prepareBeanFactory()中，已经添加过这个ApplicationListenerDetector后置处理器
// 所以此处不会再进行添加
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}
注意：
在getBean()方法去容器中拿BeanPostProcessor的时候，如果容器中没有，则就去创建，所以此处方法执行完所有的BeanPostProcessor都已经实例化了。
2. initMessageSource()初始化消息源
protected void initMessageSource() {
// 获取Spring工厂
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
//查找是否包含了名为messageSource的bean，如果没有，创建一个默认的
if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
//判断是否有父类且是一个分层级的messageSource，如果是将父容器的的messageSource设置到里边
if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {
HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;
if (hms.getParentMessageSource() == null) {
hms.setParentMessageSource(getInternalParentMessageSource());
}
}
} else {
// Use empty MessageSource to be able to accept getMessage calls.
DelegatingMessageSource dms = new DelegatingMessageSource();
dms.setParentMessageSource(getInternalParentMessageSource());
this.messageSource = dms;
beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
}
}
初始化应用事件广播器，忽略
4. onRefresh()此方法没有任何实现，留给需要扩展的子类，看注解
protected void onRefresh() throws BeansException {
// For subclasses: do nothing by default.
}
注册监听器，忽略
6. finishBeanFactoryInitialization(beanFactory)实例化所有剩余的(非懒加载)单例对象，非常重要！！！！此处要将扫描出来的并转化成BeanDefinition的类进行实例化，单独成篇。
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
// 为Spring容器初始化转换服务。
if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
beanFactory.setConversionService(
beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
}
if (!beanFactory.hasEmbeddedValueResolver()) {
beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
}
String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
for (String weaverAwareName : weaverAwareNames) {
getBean(weaverAwareName);
}
beanFactory.setTempClassLoader(null);
beanFactory.freezeConfiguration();
// 上面的方法都不重要，下面这行很重要，在此处实例化所有的单例非懒加载对象
// BeanDefinition的实例化
beanFactory.preInstantiateSingletons();
}
下面来看下这个preInstantiateSingletons()方法源码
public void preInstantiateSingletons() throws BeansException {
// beanDefinitionNames集合存放的是所有bean的名字
List beanNames = new ArrayList(this.beanDefinitionNames);
// 循环集合
// 触发所有非延迟加载单例bean的初始化，主要步骤为调用getBean()
for (String beanName : beanNames) {
// 合并父BeanDefinition，为什么需要合并呢？想想在xml配置的时候，是不是有个parent属性？
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
// 如果BeanDefinition不是抽象的，不是懒加载的，是单列的
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
// 如果是FactoryBean
if (isFactoryBean(beanName)) {
// 如果是FactoryBean则加上&
Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
if (bean instanceof FactoryBean) {
FactoryBean factory = (FactoryBean) bean;
boolean isEagerInit;
if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
// 权限校验
isEagerInit = AccessController.doPrivileged(
(PrivilegedAction) ((SmartFactoryBean) factory)::isEagerInit,
getAccessControlContext());
} else {
isEagerInit = (factory instanceof SmartFactoryBean &&
((SmartFactoryBean) factory).isEagerInit());
}
if (isEagerInit) {
getBean(beanName);
}
}
} else {
// 很重要，初始化！！！
getBean(beanName);
}
}
}
for (String beanName : beanNames) {
Object singletonInstance = getSingleton(beanName);
if (singletonInstance instanceof SmartInitializingSingleton) {
SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction) () -> {
smartSingleton.afterSingletonsInstantiated();
return null;
}, getAccessControlContext());
} else {
smartSingleton.afterSingletonsInstantiated();
}
}
}
}
这地方又分析到了getBean()这个方法，所有Bean的实例化就是在这个方法中完成的，下面重点来分析一下。
完成此上下文的刷新，略
二、说明此部分的核心就是第六小点的方法，finishBeanFactoryInitialization(beanFactory)此方法是完成Bean的创建，非常复杂。
