spring源码学习之容器的扩展（二）

六 BeanFactory的后处理
BeanFactory作为spring容器的基础，用于存放所有已经加载的bean，为了保证程序上的高扩展性，spring针对BeanFactory做了大量的扩展，比如我们熟知的PostProcessor.

6.1 激活注册的BeanFactoryPostProcessor
正式介绍之前，先了解一下BeanFactoryPostProcessor的用法
BeanFactoryPostProcessor接口跟BeanPostProcessor类似，可以对bean的定义（配置元数据）进行处理，也就是说，Spring IoC容器允许BeanFactoryPostProcessor
在容器实际实例化任何其他bean之前读取配置元数据，并有可能修改他。如果你愿意，你可以配置多个BeanFactoryPostProcessor。你还能通过“order”属性来控制
BeanFactoryPostProcessor的执行次序（仅当BeanFactoryPostProcessor实现了Ordered接口才可以设置此属性因此在实现BeanFactoryPostProcessor就应当考虑实现Ordered）
如果你想改变实际bean实例（假如从配置元数据创建的对象），那么你最好使用BeanPostProcessor，同样的，BeanFactoryPostProcessor的作用域范围是容器级的
他之和你使用的容器有关，如果你在容器中定义一个BeanFactoryPostProcessor，他仅仅对此容器中的bean进行后置管理，即使这两个容器在同一层次上，在spring中
存在于BeanFactoryPostProcessor的典型应用，比如PropertyPlaceholderConfigurer

1、BeanFactoryPostProcessor的典型应用PropertyPlaceholderConfigurer
有时候，阅读spring的bean的配置文件的时候，也许会遇到类似如下的一些配置：

<bean id="message" class="distConfig.HelloMessage">
　　<property name="mes">
　　　　<value>${bean.message}</value>
　　</property>
</bean>

其中出现了变量引用：${bean.message}。这就是spring的分散配置，可以在另外的配置中为bean.message指定值，如在bean.property配置如下定义：
bean.message=Hi,can you find me?
当访问名为message的bean时，mes属性就会被置为字符串"Hi,can you find me?"，但是spring是怎么知道存在这样的配置文件呢？这就要靠PropertyPlaceholderConfigurer
这个类了

<bean id="mesHandler" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
　　<property name="locations">
　　　　<list>
　　　　　　<value>config/bean.properties</value>
　　　　</list>
　　</property>
</bean>

在这个bean中指定了配置文件为config/bean.properties，这里似乎找到答案了，但是其实还有一个问题，这个“mesHandler”，只不过是框架管理的一个bean，并没有
被别的bean或者对象引用，spring的beanFactory是如何知道从这个bean中获取配置信息呢？
查看PropertyPlaceholderConfigurer的层级结构，可以看出这个类间接实现了BeanFactoryPostProcessor接口，这是一个很特别的接口，当spring加载任何实现了
该接口的bean的配置时，都会在bean工厂载入所有bean的配置之后执行postProcessBeanFactory方法，在PropertyResourceConfigurer类中实现了postProcessBeanFactory方法

org.springframework.beans.factory.config包下的PropertyResourceConfigurer类中的：

@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
    try {
        Properties mergedProps = mergeProperties();

        // Convert the merged properties, if necessary.
        convertProperties(mergedProps);

        // Let the subclass process the properties.
        processProperties(beanFactory, mergedProps);
    }
    catch (IOException ex) {
        throw new BeanInitializationException("Could not load properties", ex);
    }
}

这三个方法分别得到配置，将得到的配置装换为合适的类型，最后将配置告知BeanFactory
正是实现了BeanFactoryPostProcessor接口，BeanFactory会在实例化任何bean之前获得配置信息，从而能够正确解析bean中描述文件中变量引用

2、使用自定义BeanFactoryPostProcessor

// 配置文件beanFactory.xml
<beans>
    <bean id="bfpp" class="com.spring.ch04.ObscenityRemovingBeanFactoryProcessor">
        <property name="obscenities">
            <set>
                <value>bollocks</value>
                <value>winky</value>
                <value>bum</value>
                <value>microsoft</value>
            </set>
        </property>
    </bean>
    <bean id="simpleBean" class="com.spring.ch04.SimplePostProcessor">
        <property name="connectionString" value="bollocks"></property>
        <property name="password" value="imaginecup"></property>
        <property name="username" value="microsoft"></property>
    </bean>
</beans>

// ObscenityRemovingBeanFactoryProcessor.java文件
public class ObscenityRemovingBeanFactoryProcessor implements BeanFactoryPostProcessor{
    private Set<String> obscenities;
    
    public ObscenityRemovingBeanFactoryProcessor(){
        this.obscenities = new HashSet<String>();
    }
    
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        String[] beanNames = beanFactory.getBeanDefinitionName();
        for(String beanName:beanNames){
            BeanDefinition bd = beanFactory.getBeanDefinition(beanName);
            StringValueResolver valueResolver = new StringValueResolver(){
                public String resolverStringValue(String strVal){
                    if(isObscene(strVal)){
                        return "******";
                    }
                    return strVal;
                }
            };
            
            BeanDefinitionVisitor visitor = new BeanDefinitionVisitor(valueResolver);
            visitor.visitBeanDefinition(bd);
        }
    }
    
    public boolean isObscene(Object value){
        String potentialObscene = value.toString().toUpperCase();
        return this.obscenities.contains(potentialObscene);
    }
    
    public void setObscenities(Set<String> obscenities){
        this.obscenities.clear();
        for(String obscenity:obscenities){
            this.obscenities.add(obscenity);
        }
    }
    
    // 执行类
    public class PropertyConfigurerDerno{
        public static void main(String[] args){
            ConfigurableListableBeanFactory bf = new XrnlBeanFactory(new ClassPathResource("beanFactory.xml"));
            BeanFactoryPostProcessor bfpp = (BeanFactoryPostProcessor) bf.getBean("simpleBean");
            bfpp.postProcessBeanFactory(bf);
            System.out.println(bf.getBean("simpleBean"));
        }
    }
}

通过ObscenityRemovingBeanFactoryProcessor spring很好的实现了屏蔽obscenities定义的不应该展示的属性

3、激活BeanFactoryPostProcessor
了解BeanFactoryPostProcessor的用法后便可以深入研究BeanFactoryPostProcessor的调用过程了

org.springframework.context.support包下的AbstractApplicationContext类，中的refresh方法

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
    PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());

    // Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime
    // (e.g. through an @Bean method registered by ConfigurationClassPostProcessor)
    if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
        beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
        beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
    }
}

接下来继续执行PostProcessorRegistrationDelegate类中的invokeBeanFactoryPostProcessors方法
org.springframework.context.support包下的PostProcessorRegistrationDelegate类中的invokeBeanFactoryPostProcessors方法
看了一下spring5.0中的源码和作者的源码有很大的出入，做了许多优化，作者的spring源码绝对不是spring5.0的

public static void invokeBeanFactoryPostProcessors(
        ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {

    // Invoke BeanDefinitionRegistryPostProcessors first, if any.
    Set<String> processedBeans = new HashSet<>();

    // 对BeanDefinitionRegistry进行处理
    if (beanFactory instanceof BeanDefinitionRegistry) {
        BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
        List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
        List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();

        // 硬编码注册的后处理
        for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
            if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
                BeanDefinitionRegistryPostProcessor registryProcessor =
                        (BeanDefinitionRegistryPostProcessor) postProcessor;
                // 对于BeanDefinitionRegistryPostProcessor类型，在BeanFactoryPostProcessors的基础上还有自己定义的方法，需要先调用
                registryProcessor.postProcessBeanDefinitionRegistry(registry);
                registryProcessors.add(registryProcessor);
            }
            else {
                // 记录常规BeanFactoryPostProcessor
                regularPostProcessors.add(postProcessor);
            }
        }

        // Do not initialize FactoryBeans here: We need to leave all regular beans
        // uninitialized to let the bean factory post-processors apply to them!
        // Separate between BeanDefinitionRegistryPostProcessors that implement
        // PriorityOrdered, Ordered, and the rest.
        List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();

        // First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
        // 配置注册的后处理器 ，实现执行实现了PriorityOrdered接口的BeanDefinitionRegistryPostProcessors
        String[] postProcessorNames =
                beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
        for (String ppName : postProcessorNames) {
            if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
                currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                processedBeans.add(ppName);
            }
        }
        sortPostProcessors(currentRegistryProcessors, beanFactory);
        registryProcessors.addAll(currentRegistryProcessors);
        
        // BeanDefinitionRegistryPostProcessor的特殊处理
        invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
        currentRegistryProcessors.clear();

        // Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
        // 接下来执行实现了Ordered接口的BeanDefinitionRegistryPostProcessors
        postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
        for (String ppName : postProcessorNames) {
            if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
                currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                processedBeans.add(ppName);
            }
        }
        sortPostProcessors(currentRegistryProcessors, beanFactory);
        registryProcessors.addAll(currentRegistryProcessors);
        invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
        currentRegistryProcessors.clear();

        // Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
        // 最后执行剩余其他的BeanDefinitionRegistryPostProcessors
        boolean reiterate = true;
        while (reiterate) {
            reiterate = false;
            postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
            for (String ppName : postProcessorNames) {
                if (!processedBeans.contains(ppName)) {
                    currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                    processedBeans.add(ppName);
                    reiterate = true;
                }
            }
            sortPostProcessors(currentRegistryProcessors, beanFactory);
            registryProcessors.addAll(currentRegistryProcessors);
            invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
            currentRegistryProcessors.clear();
        }

        // Now, invoke the postProcessBeanFactory callback of all processors handled so far.
        // 调用到目前为止处理的所有处理器的postProcessBeanFactory回调
        invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
        invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
    }

    else {
        // Invoke factory processors registered with the context instance.
        // 调用在上下文实例中注册的工厂处理器。
        invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
    }

    // Do not initialize FactoryBeans here: We need to leave all regular beans
    // uninitialized to let the bean factory post-processors apply to them!
    // 不要在这里初始化FactoryBeans：我们需要保留所有常规bean未初始化让bean工厂的后处理器适用于他们！
    String[] postProcessorNames =
            beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

    // Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
    // Ordered, and the rest.
    // 实现PriorityOrdered，Ordered和其余的接口的BeanFactoryPostProcessors之间分开
    List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
    List<String> orderedPostProcessorNames = new ArrayList<>();
    List<String> nonOrderedPostProcessorNames = new ArrayList<>();
    for (String ppName : postProcessorNames) {
        if (processedBeans.contains(ppName)) {
            // skip - already processed in first phase above
        }
        else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
            priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
        }
        else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
            orderedPostProcessorNames.add(ppName);
        }
        else {
            nonOrderedPostProcessorNames.add(ppName);
        }
    }

    // First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
    sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
    invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

    // Next, invoke the BeanFactoryPostProcessors that implement Ordered.
    List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>();
    for (String postProcessorName : orderedPostProcessorNames) {
        orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
    }
    sortPostProcessors(orderedPostProcessors, beanFactory);
    invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

    // Finally, invoke all other BeanFactoryPostProcessors.
    List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
    for (String postProcessorName : nonOrderedPostProcessorNames) {
        nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
    }
    invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);

    // Clear cached merged bean definitions since the post-processors might have
    // modified the original metadata, e.g. replacing placeholders in values...
    // 清除缓存的合并bean定义，因为后处理器可能已经修改了原始元数据，例如， 替换值中的占位符...
    beanFactory.clearMetadataCache();
}

从上面的代码可以看出，对于BeanFactoryPostProcessor的处理主要分为两种。一种是对于BeanDefinitionRegistry类处理，另一种是对于普通的BeanFactoryPostProcessor
处理，面对这两种都需要考虑硬编码注入注册的后处理以及通过配置注入的后处理器

6.2 注册BeanPostProcessor
上面提到了BeanFactoryPostProcessor的调用，现在我们探索下BeanPostProcessor，但是这里并不是调用，而是注册。真正的调用实际上是在bean的实例化阶段进行的
这是一个很重要的步骤，也是很多功能BeanFactory不支持的重要原因。spring中的大部分功能都是通过后处理器的方式进行扩展的，这是spring框架的一个特性，但是在
BeanFactory中其实并没有实现后处理器的自动注册，所以在调用的时候如果没有进行手动注册其实是不能使用的，但是ApplicationContext中却添加了自动注册的功能
如定义一个这样的后处理器：

public class MyInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor{
    public Object postProcessorBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("====");
        return null;
    }
    ......
}

在配置文件中添加配置：
<bean class="processors.MyInstantiationAwareBeanPostProcessor" />
那么使用BeanFactory方式进行spring的bean的加载时是不会有任何变化的，但是使用ApplicationContext方式获取bean的时候会在获取每个bean的打印"==="，
而这个特性就是在registerBeanPostProcessor方法中进行的，接着看下这个方法registerBeanPostProcessor
org.springframework.context.support包下的AbstractApplicationContext类中refresh()方法中的该行代码：
// 注册拦截bean创建的bean处理器，这里只是注册，真正的调用是在getBean的时候
registerBeanPostProcessors(beanFactory);

// 进入到方法中：同一个类中
protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
    PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
}

// org.springframework.context.support包下的PostProcessorRegistrationDelegate类中的registerBeanPostProcessors方法：
public static void registerBeanPostProcessors(
        ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {

    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.
    /**
     * BeanPostProcessorChecker是一个普通的信息打印 可能会有些情况
     * 当spring的配置中的后处理器还没有被注册就已经开始了bean的初始化时
     * 便会打印BeanPostProcessorChecker中设定的信息
     */
    int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
    beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

    // Separate between BeanPostProcessors that implement PriorityOrdered,
    // Ordered, and the rest.
    // 使用PriorityOrdered保证顺序
    List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
    List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
    // 使用Ordered保证顺序
    List<String> orderedPostProcessorNames = new ArrayList<>();
    // 无序BeanPostProcessor
    List<String> nonOrderedPostProcessorNames = new ArrayList<>();
    for (String ppName : postProcessorNames) {
        if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
            BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
            priorityOrderedPostProcessors.add(pp);
            if (pp instanceof MergedBeanDefinitionPostProcessor) {
                internalPostProcessors.add(pp);
            }
        }
        else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
            orderedPostProcessorNames.add(ppName);
        }
        else {
            nonOrderedPostProcessorNames.add(ppName);
        }
    }

    // First, register the BeanPostProcessors that implement PriorityOrdered.
    // 首先，注册所有的实现了PriorityOrdered的BeanPostProcessors
    sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
    registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

    // Next, register the BeanPostProcessors that implement Ordered.
    // 接下来。注册所有实现了Ordered接口的BeanPostProcessors
    List<BeanPostProcessor> 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.
    // 然后，注册所有无序的BeanPostProcessors
    List<BeanPostProcessor> 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.
    // 最后，注册所有的MergedBeanDefinitionPostProcessor类型的BeanPostProcessor，并非重复注册
    // 在beanFactory.addBeanPostProcessor中会先移除已经存在的BeanPostProcessor
    sortPostProcessors(internalPostProcessors, 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).
    // 添加ApplicationListeners注册器
    beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}

6.3 初始化消息资源

spring中定义了访问国际化信息的MessageSource接口，并提供了几个易用的实现类。MessageSource分别被HierarchicalMessageSource和ApplicationContext接口
扩展，HierarchicalMessageSource接口最重要的两个实现类ReloadableResourceBundleMessageSource和ResourceBundleMessageSource，他们基于java的ResourceBundle
基础类实现允许仅通过资源名加载国际化资源，ReloadableResourceBundleMessageSource提供了定时刷新功能，允许在不重启系统的情况下，更新资源信息，
StaticMessageSource主要用于程序测试，他允许通过编程的方式提供国际化信息。DelegatingMessageSource是为方便操作父MessageSource而提供的代理类
仅仅举例ResourceBundleMessageSource的实现方式：

（1）定义资源文件
message.properties(默认英文)
test=test
message_zh_CN.properties(简体中文)
test=测试

（2）定义配置文件
<bean id="messageResource" class="org.springframework.context.support.ResourceBundleMessageSource">
    <property name="beanName">
        <list>
            <value>test/message</value>
        </list>
    </property>
</bean>
这个bean的id必须配置成messageResource，否则会报错

（3）使用ApplicationContext访问国际化信息
String[] configs = {"application.xml"};
ApplicationContext ctx = new ClassPathXmlApplicationContext(configs);
Object params = {"", new GregorianCalendar().getTime()};

String str1 = ctx.getMessage("test",params,Locale.US);
String str2 = ctx.getMessage("test",params,Locale.CHINA);

System.out.println(str1);
System.out.println(str2);

org.springframework.context.support包下的AbstractApplicationContext类中refresh方法中的国际化处理的代码
// 为上下文初始化Message源，即不同语言的消息体，即国际化处理
initMessageSource();

initMessageSource方法中，主要功能是提取配置中定义的MessageSource，并将其记录到spring容器中，也就是AbstractApplicationContext中，当然，如果用户
未设置资源文件的话，spring中也提供了默认的配置DelegatingMessageSource
在initMessageSource中获取自定义的资源文件的方式为beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);这里spring使用了硬编码方式硬性
规定了资源文件必须为message，否则获取不到资源

org.springframework.context.support包下的AbstractApplicationContext类中

protected void initMessageSource() {
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
        
        // 获取用户自定义的资源文件
        this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
        // Make MessageSource aware of parent MessageSource.
        if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {
            HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;
            if (hms.getParentMessageSource() == null) {
                // Only set parent context as parent MessageSource if no parent MessageSource
                // registered already.
                hms.setParentMessageSource(getInternalParentMessageSource());
            }
        }
        if (logger.isDebugEnabled()) {
            logger.debug("Using MessageSource [" + this.messageSource + "]");
        }
    }
    else {
        // Use empty MessageSource to be able to accept getMessage calls.
        // 用户未定义则用默认的DelegatingMessageSource
        DelegatingMessageSource dms = new DelegatingMessageSource();
        dms.setParentMessageSource(getInternalParentMessageSource());
        this.messageSource = dms;
        beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
        if (logger.isDebugEnabled()) {
            logger.debug("Unable to locate MessageSource with name '" + MESSAGE_SOURCE_BEAN_NAME +
                    "': using default [" + this.messageSource + "]");
        }
    }
}

org.springframework.context.support包下的AbstractApplicationContext类中实现了三种获取资源文件的方法
@Override
public String getMessage(String code, @Nullable Object[] args, @Nullable String defaultMessage, Locale locale) {
    return getMessageSource().getMessage(code, args, defaultMessage, locale);
}

@Override
public String getMessage(String code, @Nullable Object[] args, Locale locale) throws NoSuchMessageException {
    return getMessageSource().getMessage(code, args, locale);
}

@Override
public String getMessage(MessageSourceResolvable resolvable, Locale locale) throws NoSuchMessageException {
    return getMessageSource().getMessage(resolvable, locale);
}

getMessageSource方法是获取之前定义的自定义资源配置
private MessageSource getMessageSource() throws IllegalStateException {
    if (this.messageSource == null) {
        throw new IllegalStateException("MessageSource not initialized - " +
                "call 'refresh' before accessing messages via the context: " + this);
    }
    return this.messageSource;
}

6.4 初始化ApplicationEventMulticaster
org.springframework.context.support包下的AbstractApplicationContext类中refresh方法中的初始化应用消息广播器的代码
// 初始化应用消息广播器，并放入"applicationEventMulticaster"bean中
initApplicationEventMulticaster();

先看一下spring中事件监听的简单用法

（1）定义监听事件
public class TestEvent extends ApplicationEvent{

    public String message;
    
    public TestEvent(Object source){
        super(source);
    }
    
    public TestEvent(Object source, String msg){
        super(source);
        this.msg = msg;
    }
    
    public void print(){
        System.out.println(message);
    }
}

（2）定义监听器
public TestListener implements ApplicationListeners{
    
    public void onApplicationEvent(ApplicationEvent event){
        if(event instanceof TestEvent){
            TestEvent testEvent = (TestEvent) event;
            testEvent.print();
        }
    }
}

（3）添加配置文件
<bean id="testListener" class="com.test.event.TestListener" />

（4）测试
public class Test{
    public static void main(String[] args){
        ApplicationContext context = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
        TestEvent event = new TestEvent("hello","msg");
        context.publishEvent(event);
    }
}

当程序运行时，spring会将发出的TestEvent事件转给我们自定义的TestListener进行进一步处理

这个和设计模式中观察者模式有点类似，看源码中ApplicationEventMulticaster如何被初始化的，以确保功能的正常运行
initApplicationEventMulticaster的方式比较简单，无非考虑两种情况：
如果用户自定义了事件广播器，那么使用用户自定义的时间广播器
如果用户没有自定义事件广播器，那么使用默认的ApplicationEventMulticaster

protected void initApplicationEventMulticaster() {
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
        this.applicationEventMulticaster =
                beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
        if (logger.isDebugEnabled()) {
            logger.debug("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
        }
    }
    else {
        this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
        beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
        if (logger.isDebugEnabled()) {
            logger.debug("Unable to locate ApplicationEventMulticaster with name '" +
                    APPLICATION_EVENT_MULTICASTER_BEAN_NAME +
                    "': using default [" + this.applicationEventMulticaster + "]");
        }
    }
}

按照之前的介绍顺序及逻辑，我们推断，作为广播器，一定是存放监听器并在合适的时候调用监听器，看看默认的广播器实现SimpleApplicationEventMulticaster的源码
org.springframework.context.support包下的AbstractApplicationContext类中refresh中的代码
// 在所有注册的bean中查找Listener bean，注册到消息广播器中
registerListeners();

通过这个方法来看一下
org.springframework.context.support包下的AbstractApplicationContext类中

protected void registerListeners() {
    // Register statically specified listeners first.
    for (ApplicationListener<?> listener : getApplicationListeners()) {
        getApplicationEventMulticaster().addApplicationListener(listener);
    }

    // Do not initialize FactoryBeans here: We need to leave all regular beans
    // uninitialized to let post-processors apply to them!
    // 不要在这里初始化FactoryBeans：我们需要保留所有常规bean未初始化让后处理器适用于他们！
    String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
    for (String listenerBeanName : listenerBeanNames) {
        getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
    }

    // Publish early application events now that we finally have a multicaster...
    // 现在我们终于有了一个多播器，发布早期的应用程序事件...
    Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
    this.earlyApplicationEvents = null;
    if (earlyEventsToProcess != null) {
        for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
            getApplicationEventMulticaster().multicastEvent(earlyEvent);
        }
    }
}

当产生spring事件的时候默认使用SimpleApplicationEventMulticaster的multicastEvent来广播事件，遍历所有的监听器，并使用监听器中onApplicationEvent方法
进行监听器的处理，而对于每个监听器来说其实都可以获取到产生的事件但是是否处理则由时间监听器决定

@Override
public void multicastEvent(ApplicationEvent event) {
    multicastEvent(event, resolveDefaultEventType(event));
}

@Override
public void multicastEvent(final ApplicationEvent event, @Nullable ResolvableType eventType) {
    ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));
    for (final ApplicationListener<?> listener : getApplicationListeners(event, type)) {
        Executor executor = getTaskExecutor();
        if (executor != null) {
            executor.execute(() -> invokeListener(listener, event));
        }
        else {
            invokeListener(listener, event);
        }
    }
}

6.5 注册监听器
看源码spring注册监听器的时候做了什么处理：
org.springframework.context.support包下的AbstractApplicationContext类中refresh中的代码
// 在所有注册的bean中查找Listener bean，注册到消息广播器中
registerListeners();

protected void registerListeners() {
    // Register statically specified listeners first.
    for (ApplicationListener<?> listener : getApplicationListeners()) {
        getApplicationEventMulticaster().addApplicationListener(listener);
    }

    // Do not initialize FactoryBeans here: We need to leave all regular beans
    // uninitialized to let post-processors apply to them!
    // 不要在这里初始化FactoryBeans：我们需要保留所有常规bean未初始化让后处理器适用于他们！
    String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
    for (String listenerBeanName : listenerBeanNames) {
        getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
    }

    // Publish early application events now that we finally have a multicaster...
    // 现在我们终于有了一个多播器，发布早期的应用程序事件...
    Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
    this.earlyApplicationEvents = null;
    if (earlyEventsToProcess != null) {
        for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
            getApplicationEventMulticaster().multicastEvent(earlyEvent);
        }
    }
}

上面那写到了multicastEvent方法的实现具体的代码，这里不详细贴出来了

七 初始化非延迟加载单例
完成BeanFactory的初始化工作，其中包括ConversionService的设置，配置冻结以及非延迟加载的bean的初始化工作

org.springframework.context.support包下的AbstractApplicationContext类中refresh中的代码

// 初始化剩下的单实例（非惰性的）
finishBeanFactoryInitialization(beanFactory);

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
    // Initialize conversion service for this context.
    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));
    }

    // Register a default embedded value resolver if no bean post-processor
    // (such as a PropertyPlaceholderConfigurer bean) registered any before:
    // at this point, primarily for resolution in annotation attribute values.
    // 如果没有bean后处理器，则注册默认的嵌入值解析器
    //（例如PropertyPlaceholderConfigurer bean）之前注册的任何一个：此时，主要用于注释属性值的解析
    if (!beanFactory.hasEmbeddedValueResolver()) {
        beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
    }

    // Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
    // 尽早初始化LoadTimeWeaverAware bean以允许尽早注册其变换器。
    String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
    for (String weaverAwareName : weaverAwareNames) {
        getBean(weaverAwareName);
    }

    // Stop using the temporary ClassLoader for type matching.
    // 停止使用临时ClassLoader进行类型匹配。
    beanFactory.setTempClassLoader(null);

    // Allow for caching all bean definition metadata, not expecting further changes.
    // 冻结所有bean定义，说明注册的bean定义将不被修改或任何进一步的处理
    beanFactory.freezeConfiguration();

    // Instantiate all remaining (non-lazy-init) singletons.
    // 初始化剩下的单实例（非惰性的）
    beanFactory.preInstantiateSingletons();
}

1、ConversionService设置
之前提到过使用自定义类型转换器从String转换到Date的方式，那么，在spring中，还提供了另一种转换方式：使用Converter，同样来看一下如何使用：

（1）定义转换器
public class String2DateConverter implements Converter<String, Date>{
    public Date convert(String args){
        try{
            return DateUtils.parseDate(arg0, new String[]{"yyyy-MM-dd HH:mm:ss"});
        }catch(ParseException e){
            return null;
        }
    }
}
（2）注册
<bean id="conversionService" class="org.springframework.context.support.ConversionServiceFactoryBean">
    <property name="converters">
        <list>
            <bean class="String2DateConverter" />
        </list>
    </property>
</bean>
（3）测试
public void testStringToDateConvert(){
    DefaultConversionService conversionService = new DefaultConversionService();
    conversionservice.addConverter(new String2DateConverter());
    String dateStr = "2019-07-26 15:35:28";
    Date date = conversionService.convert(dateStr);
}

2、冻结配置
冻结所有的bean定义，说明注册的bean定义将不被修改或进行任何进一步的处理
org.springframework.beans.factory.support包下的AbstractApplicationContext类中

@Override
public void freezeConfiguration() {
    this.configurationFrozen = true;
    this.frozenBeanDefinitionNames = StringUtils.toStringArray(this.beanDefinitionNames);
}

3、初始化非延迟加载
ApplicationContext实现默认的行为就是在启动时将所有单例bean提前进行实例化，提前实例化意味着作为初始化过程的一部分，ApplicationContext实例会创建并
配置所有的单例bean。通常情况下这是一件好事，因为这样在配置中的任何错误就会即刻被发现，而这个实例化过程就是在preInstantiateSingletons中完成的
org.springframework.beans.factory.support包下的DefaultListableBeanFactory类

@Override
public void preInstantiateSingletons() throws BeansException {
    if (logger.isDebugEnabled()) {
        logger.debug("Pre-instantiating singletons in " + this);
    }

    // Iterate over a copy to allow for init methods which in turn register new bean definitions.
    // While this may not be part of the regular factory bootstrap, it does otherwise work fine.
    // 迭代一个副本以允许init方法，这些方法又注册新的bean定义。
    // 虽然这可能不是常规工厂引导程序的一部分，但它确实可以正常工作。
    List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

    // Trigger initialization of all non-lazy singleton beans...
    // 触发所有非惰性单例bean的初始化...
    for (String beanName : beanNames) {
        RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
        if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
            if (isFactoryBean(beanName)) {
                Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
                if (bean instanceof FactoryBean) {
                    final FactoryBean<?> factory = (FactoryBean<?>) bean;
                    boolean isEagerInit;
                    if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                        isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
                                        ((SmartFactoryBean<?>) factory)::isEagerInit,
                                getAccessControlContext());
                    }
                    else {
                        isEagerInit = (factory instanceof SmartFactoryBean &&
                                ((SmartFactoryBean<?>) factory).isEagerInit());
                    }
                    if (isEagerInit) {
                        getBean(beanName);
                    }
                }
            }
            else {
                getBean(beanName);
            }
        }
    }

    // Trigger post-initialization callback for all applicable beans...
    // 触发所有适用bean的后初始化回调...
    for (String beanName : beanNames) {
        Object singletonInstance = getSingleton(beanName);
        if (singletonInstance instanceof SmartInitializingSingleton) {
            final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
            if (System.getSecurityManager() != null) {
                AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
                    smartSingleton.afterSingletonsInstantiated();
                    return null;
                }, getAccessControlContext());
            }
            else {
                smartSingleton.afterSingletonsInstantiated();
            }
        }
    }
}

八 finishRefresh
org.springframework.context.support包下的AbstractApplicationContext类中refresh中的代码
// 完成刷新过程，通知生命周期处理器lifecycleProcessor刷新过程，同时发出ContextRefreshEvent通知别人
finishRefresh();

// 同一个类中：
protected void finishRefresh() {
    // Clear context-level resource caches (such as ASM metadata from scanning).
    // 清除上下文级资源缓存（例如来自扫描的ASM元数据）。
    clearResourceCaches();

    // Initialize lifecycle processor for this context.
    // 为此上下文初始化生命周期处理器。
    initLifecycleProcessor();

    // Propagate refresh to lifecycle processor first.
    // 首先将刷新传播到生命周期处理器。
    getLifecycleProcessor().onRefresh();

    // Publish the final event.
    // 发布最终的event
    publishEvent(new ContextRefreshedEvent(this));

    // Participate in LiveBeansView MBean, if active.
    // 如果处于活动状态，请参考LiveBeansView MBean。
    LiveBeansView.registerApplicationContext(this);
}

1、initLifecycleProcessor
当ApplicationContext启动或者停止的时候，他会通过LifecycleProcessor来与所有声明的bean的周期做状态更新，而在LifecycleProcessor的使用前需要初始化

protected void initLifecycleProcessor() {
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    if (beanFactory.containsLocalBean(LIFECYCLE_PROCESSOR_BEAN_NAME)) {
        this.lifecycleProcessor =
                beanFactory.getBean(LIFECYCLE_PROCESSOR_BEAN_NAME, LifecycleProcessor.class);
        if (logger.isDebugEnabled()) {
            logger.debug("Using LifecycleProcessor [" + this.lifecycleProcessor + "]");
        }
    }
    else {
        DefaultLifecycleProcessor defaultProcessor = new DefaultLifecycleProcessor();
        defaultProcessor.setBeanFactory(beanFactory);
        this.lifecycleProcessor = defaultProcessor;
        beanFactory.registerSingleton(LIFECYCLE_PROCESSOR_BEAN_NAME, this.lifecycleProcessor);
        if (logger.isDebugEnabled()) {
            logger.debug("Unable to locate LifecycleProcessor with name '" +
                    LIFECYCLE_PROCESSOR_BEAN_NAME +
                    "': using default [" + this.lifecycleProcessor + "]");
        }
    }
}

2、onRefresh
org.springframework.context.support包下的DefaultLifecycleProcessor类

@Override
public void onRefresh() {
    startBeans(true);
    this.running = true;
}

private void startBeans(boolean autoStartupOnly) {
    Map<String, Lifecycle> lifecycleBeans = getLifecycleBeans();
    Map<Integer, LifecycleGroup> phases = new HashMap<>();
    lifecycleBeans.forEach((beanName, bean) -> {
        if (!autoStartupOnly || (bean instanceof SmartLifecycle && ((SmartLifecycle) bean).isAutoStartup())) {
            int phase = getPhase(bean);
            LifecycleGroup group = phases.get(phase);
            if (group == null) {
                group = new LifecycleGroup(phase, this.timeoutPerShutdownPhase, lifecycleBeans, autoStartupOnly);
                phases.put(phase, group);
            }
            group.add(beanName, bean);
        }
    });
    if (!phases.isEmpty()) {
        List<Integer> keys = new ArrayList<>(phases.keySet());
        Collections.sort(keys);
        for (Integer key : keys) {
            phases.get(key).start();
        }
    }
}

3、publishEvent
当完成ApplicationContext初始化的时候，要通过spring中事件发布机制来发出ContextRefreshedEvent事件，以保证对应的监听器可以做进一步的逻辑吃力

// 同一个类中：
protected void publishEvent(Object event, @Nullable ResolvableType eventType) {
    Assert.notNull(event, "Event must not be null");
    if (logger.isTraceEnabled()) {
        logger.trace("Publishing event in " + getDisplayName() + ": " + event);
    }

    // Decorate event as an ApplicationEvent if necessary
    // 如有必要，将事件装饰为ApplicationEvent
    ApplicationEvent applicationEvent;
    if (event instanceof ApplicationEvent) {
        applicationEvent = (ApplicationEvent) event;
    }
    else {
        applicationEvent = new PayloadApplicationEvent<>(this, event);
        if (eventType == null) {
            eventType = ((PayloadApplicationEvent<?>) applicationEvent).getResolvableType();
        }
    }

    // Multicast right now if possible - or lazily once the multicaster is initialized
    // 如果可能的话现在就进行组播 - 或者在初始化多播器后懒洋洋地进行组播
    if (this.earlyApplicationEvents != null) {
        this.earlyApplicationEvents.add(applicationEvent);
    }
    else {
        getApplicationEventMulticaster().multicastEvent(applicationEvent, eventType);
    }

    // Publish event via parent context as well...
    if (this.parent != null) {
        if (this.parent instanceof AbstractApplicationContext) {
            ((AbstractApplicationContext) this.parent).publishEvent(event, eventType);
        }
        else {
            this.parent.publishEvent(event);
        }
    }
}