一、前言
在spring源码解读系列（五）中我们介绍了spring核心方法org.springframework.context.support.AbstractApplicationContext#refresh中的invokeBeanFactoryPostProcessors(beanFactory)方法，调用各种beanFactory处理器，并在spring源码解读系列（六）中详细介绍了最重要的beanFactory，即ConfigurationClassPostProcessor，今天我们接着介绍refresh中下面的方法，理解了整个refresh方法，就掌握了spring核心，让我们继续加油！
二、registerBeanPostProcessors(beanFactory)
我们跟从refresh中的registerBeanPostProcessors(beanFactory)方法，最终跳转至PostProcessorRegistrationDelegate.registerBeanPostProcessors方法，该方法的主要作用是：实例化并且注册所有的beanPostProcessor，注意，这里仅仅是注册，并没有调用，我们会在后续的实例化中看到调用过程。
这个方法并不复杂，注册过程和我们在spring源码解读系列（五）分析的调用BeanFactoryPostProcessors的过程非常相似，主要分为两个过程：
1.从beanFactory工厂中取出符合条件的BeanPostProcessor，并按照PriorityOrdered、MergedBeanDefinitionPostProcessor、Ordered、nonOrdered分为四类，存入对应的集合
2.四类集合分别排序、注册到AbstractBeanFactory类中的beanPostProcessors属性中
详见源码分析：
/**
* 注册beanPostProcessor
* @param beanFactory
* @param applicationContext
*/
public static void registerBeanPostProcessors(
ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
// 找到所有实现了BeanPostProcessor接口的类
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
// Register BeanPostProcessorChecker that logs an info message when
// a bean is created during BeanPostProcessor instantiation, i.e. when
// a bean is not eligible for getting processed by all BeanPostProcessors.
// 记录下BeanPostProcessor的目标计数
// 此处为什么要+1呢，原因非常简单，在此方法的最后会添加一个BeanPostProcessorChecker的类
int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
// 添加BeanPostProcessorChecker(主要用于记录信息)到beanFactory中
beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
// Separate between BeanPostProcessors that implement PriorityOrdered,
// Ordered, and the rest.
// 定义存放实现了PriorityOrdered接口的BeanPostProcessor集合
List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
// 定义存放spring内部的BeanPostProcessor
List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
// 定义存放实现了Ordered接口的BeanPostProcessor的name集合
List<String> orderedPostProcessorNames = new ArrayList<>();
// 定义存放普通的BeanPostProcessor的name集合
List<String> nonOrderedPostProcessorNames = new ArrayList<>();
// 遍历beanFactory中存在的BeanPostProcessor的集合postProcessorNames，
for (String ppName : postProcessorNames) {
// 如果ppName对应的BeanPostProcessor实例实现了PriorityOrdered接口，则获取到ppName对应的BeanPostProcessor的实例添加到priorityOrderedPostProcessors中
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
priorityOrderedPostProcessors.add(pp);
// 如果ppName对应的BeanPostProcessor实例也实现了MergedBeanDefinitionPostProcessor接口，那么则将ppName对应的bean实例添加到internalPostProcessors中
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
// 如果ppName对应的BeanPostProcessor实例没有实现PriorityOrdered接口，但是实现了Ordered接口，那么将ppName对应的bean实例添加到orderedPostProcessorNames中
else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
} else {
// 否则将ppName添加到nonOrderedPostProcessorNames中
nonOrderedPostProcessorNames.add(ppName);
}
}
// First, register the BeanPostProcessors that implement PriorityOrdered.
// 首先，对实现了PriorityOrdered接口的BeanPostProcessor实例进行排序操作
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
// 注册实现了PriorityOrdered接口的BeanPostProcessor实例添加到beanFactory中
registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
// Next, register the BeanPostProcessors that implement Ordered.
// 注册所有实现Ordered的beanPostProcessor
List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
for (String ppName : orderedPostProcessorNames) {
// 根据ppName找到对应的BeanPostProcessor实例对象
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
// 将实现了Ordered接口的BeanPostProcessor添加到orderedPostProcessors集合中
orderedPostProcessors.add(pp);
// 如果ppName对应的BeanPostProcessor实例也实现了MergedBeanDefinitionPostProcessor接口，那么则将ppName对应的bean实例添加到internalPostProcessors中
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
// 对实现了Ordered接口的BeanPostProcessor进行排序操作
sortPostProcessors(orderedPostProcessors, beanFactory);
// 注册实现了Ordered接口的BeanPostProcessor实例添加到beanFactory中
registerBeanPostProcessors(beanFactory, orderedPostProcessors);
// Now, register all regular BeanPostProcessors.
// 创建存放没有实现PriorityOrdered和Ordered接口的BeanPostProcessor的集合
List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
// 遍历集合
for (String ppName : nonOrderedPostProcessorNames) {
// 根据ppName找到对应的BeanPostProcessor实例对象
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
// 将没有实现PriorityOrdered和Ordered接口的BeanPostProcessor添加到nonOrderedPostProcessors集合中
nonOrderedPostProcessors.add(pp);
// 如果ppName对应的BeanPostProcessor实例也实现了MergedBeanDefinitionPostProcessor接口，那么则将ppName对应的bean实例添加到internalPostProcessors中
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
// 注册没有实现PriorityOrdered和Ordered的BeanPostProcessor实例添加到beanFactory中
registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
// Finally, re-register all internal BeanPostProcessors.
// 将所有实现了MergedBeanDefinitionPostProcessor类型的BeanPostProcessor进行排序操作
sortPostProcessors(internalPostProcessors, beanFactory);
// 注册所有实现了MergedBeanDefinitionPostProcessor类型的BeanPostProcessor到beanFactory中
registerBeanPostProcessors(beanFactory, internalPostProcessors);
// Re-register post-processor for detecting inner beans as ApplicationListeners,
// moving it to the end of the processor chain (for picking up proxies etc).
// 注册ApplicationListenerDetector到beanFactory中，此处执行，是为了保证放在最后的位置执行
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}
registerBeanPostProcessors的源码如下：
/**
* 注册给定的BeanPostProcessor类型Bean对象
*
* Register the given BeanPostProcessor beans.
*/
private static void registerBeanPostProcessors(
ConfigurableListableBeanFactory beanFactory, List<BeanPostProcessor> postProcessors) {
// 遍历postProcessors
for (BeanPostProcessor postProcessor : postProcessors) {
//将 postProcessor 添加到beanFactory,它将应用于该工厂创建的Bean。在工厂配置期间调用
beanFactory.addBeanPostProcessor(postProcessor);
}
}
registerBeanPostProcessors代码中调用的org.springframework.beans.factory.support.AbstractBeanFactory#addBeanPostProcessor方法如下：
@Override
public void addBeanPostProcessor(BeanPostProcessor beanPostProcessor) {
Assert.notNull(beanPostProcessor, "BeanPostProcessor must not be null");
// 后添加的BeanPostProcessor会覆盖之前的，先删除，然后在添加
// Remove from old position, if any
// 从老的位置移除此beanPostProcessor
this.beanPostProcessors.remove(beanPostProcessor);
// Track whether it is instantiation/destruction aware
// 此处是为了设置某些状态变量，这些状态变量会影响后续的执行流程，只需要判断是否是指定的类型，然后设置标志位即可
if (beanPostProcessor instanceof InstantiationAwareBeanPostProcessor) {
// 该变量表示beanfactory是否已注册过InstantiationAwareBeanPostProcessor
this.hasInstantiationAwareBeanPostProcessors = true;
}
if (beanPostProcessor instanceof DestructionAwareBeanPostProcessor) {
// 该变量表示beanfactory是否已注册过DestructionAwareBeanPostProcessor
this.hasDestructionAwareBeanPostProcessors = true;
}
// Add to end of list
// 将beanPostProcessor添加到beanPostProcessors缓存中
this.beanPostProcessors.add(beanPostProcessor);
}
完成注册，保存在AbstractBeanFactory的beanPostProcessors属性中
private final List<BeanPostProcessor> beanPostProcessors = new CopyOnWriteArrayList<>();
三、initMessageSource()
initMessageSource方法主要作用是：为上下文初始化message源，即不同语言的消息体。一般用以国际化处理，实际开发中极少用到，在springmvc中有具体的实现。这里大家可以参考下nginx的官网https://nginx.org/,英语和俄文的切换即是通过这里实现的
通过右边的按钮可以灵活选择网站的语言：英语或者俄语
我们看下代码分析：
protected void initMessageSource() {
// 获取bean工厂，一般是DefaultListableBeanFactory
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
// 首先判断是否已有xml文件定义了id为messageSource的bean对象
if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
// 如果有，则从BeanFactory中获取这个对象
this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
// Make MessageSource aware of parent MessageSource.
// 当父类bean工厂不为空，并且这个bean对象是HierarchicalMessageSource类型
if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {
// 类型强制转换，转换为HierarchicalMessageSource的类型
HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;
// 判断父类的messageSource是否为空，如果等于空，则设置父类的messageSource
if (hms.getParentMessageSource() == null) {
// Only set parent context as parent MessageSource if no parent MessageSource
// registered already.
hms.setParentMessageSource(getInternalParentMessageSource());
}
}
if (logger.isTraceEnabled()) {
logger.trace("Using MessageSource [" + this.messageSource + "]");
}
}
else {
// Use empty MessageSource to be able to accept getMessage calls.
// 如果没有xml文件定义信息源对象，新建DelegatingMessageSource类作为messageSource的bean
DelegatingMessageSource dms = new DelegatingMessageSource();
// 给这个DelegatingMessageSource添加父类消息源
dms.setParentMessageSource(getInternalParentMessageSource());
this.messageSource = dms;
// 将这个messageSource实例注册到bean工厂中
beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
if (logger.isTraceEnabled()) {
logger.trace("No '" + MESSAGE_SOURCE_BEAN_NAME + "' bean, using [" + this.messageSource + "]");
}
}
}
这里的实现其实很简单，spring从工厂中判断下有没有用户自定义的messageSource对象，如果有的话，就使用用户自定义的，如果没有，就自己创建一个DelegatingMessageSource，并注册到bean工厂中。