大家好，又见面了，我是全栈君。

我为什么 看的不够远，因为高度不够！

学习和整理总结Spring容器的功能扩展，本文为学习笔记，其中有一些内容是自己的思考总结！

一、两种Spring中bean加载的方式

第一种

# 第一种使用 BeanFactory 以及它默认的实现类 XmlBeanFactory
BeanFactory bf = new XmlBeanFactory(new ClassPathResource("beanFactoryTest.xml"));

# 注：XmlBeanFactory这种方式已经在最新的Spring5中已经被标记为@Deprecated！

第二种

# 第二种使用 ApplicationContext 以及它的实现类 ClassPathXmlApplicationContext
 ApplicationContext context = new ClassPathXmlApplicationContext("beanFactoryTest.xml");

BeanFactory 和 ApplicationContext 都是用于加载Bean的，对比之下 ApplicationContext 包含了BeanFactory 所有的功能，并提供了更多的扩展。
下面是ApplicationContext的类图：

从类图上看， ApplicationContext是BeanFactory 的子类！子类继承了父类所有的功能，并在父类的基础上添加了一些功能，在大多数时候，ApplicationContext 就是你所需要的！

二、从 new ClassPathXmlApplicationContext(“beanFactoryTest.xml”)开启源码之旅

1、构造函数

/** * Create a new ClassPathXmlApplicationContext, loading the definitions * from the given XML file and automatically refreshing the context. * 创建一个新的ClassPathXmlApplicationContext，加载定义 * 从给定的XML文件中自动刷新上下文。 * @param configLocation resource location * @throws BeansException if context creation failed */
    public ClassPathXmlApplicationContext(String configLocation) throws BeansException {
        this(new String[] {configLocation}, true, null);
}
/** * 1.设置配置路径 * 2，refesh 扩展功能 */
public ClassPathXmlApplicationContext(
            String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)
            throws BeansException {

        super(parent);
        setConfigLocations(configLocations);
        if (refresh) {
            refresh();
        }
}

2 具体的setConfigLocations 和 refresh

2.1 设置配置路径

/** * Set the config locations for this application context. * 设置此应用程序上下文的配置位置。 * <p>If not set, the implementation may use a default as appropriate. * 如果没有设置，实现可以适当地使用默认值。 */
public void setConfigLocations(@Nullable String... locations) {
    if (locations != null) {
        Assert.noNullElements(locations, "Config locations must not be null");
        this.configLocations = new String[locations.length];
        for (int i = 0; i < locations.length; i++) {
            // 解析给定路径
            this.configLocations[i] = resolvePath(locations[i]).trim();
        }
    }
    else {
        this.configLocations = null;
    }
}

此函数主要是用于解析给定的路径数组，如果路径中包含特殊字符，如${bar}，那么resolvePath会搜寻匹配的系统变量并替换。

2.2 扩展功能

设置完路径后，就可以根据路径做配置文件的解析以及各种功能的实现了。refresh中包含了ApplicationContext中提供的全部功能。

public void refresh() throws BeansException, IllegalStateException {
    // `startupShutdownMonitor` 同步监视器用于“刷新”和“销毁”。
    synchronized (this.startupShutdownMonitor) {
        // Prepare this context for refreshing.
        // 准备刷新的上下文环境
        prepareRefresh();

        // Tell the subclass to refresh the internal bean factory.
        // 初始话beanFactory，并及逆行XML文件读取
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

        // Prepare the bean factory for use in this context.
        // 对BeanFactory 进行各种功能填充
        prepareBeanFactory(beanFactory);

        try {
            // Allows post-processing of the bean factory in context subclasses.
            // 子类覆盖方法的额外处理，默认实现为空
            postProcessBeanFactory(beanFactory);

            // Invoke factory processors registered as beans in the context.
            // 激活各种BeanFactory处理器
            invokeBeanFactoryPostProcessors(beanFactory);

            // Register bean processors that intercept bean creation.
            // 注册拦截Bean的创建的处理器，这里只是注册，真正调用是在getBean时候
            registerBeanPostProcessors(beanFactory);

            // Initialize message source for this context.
            // 为上下问初始化message源，既不同语言的消息体，国际化处理
            initMessageSource();

            // Initialize event multicaster for this context.
            // 初始化应用消息广播器
            initApplicationEventMulticaster();

            // Initialize other special beans in specific context subclasses.
            // 留给子类初始化其他的Bean，默认实现为空
            onRefresh();

            // Check for listener beans and register them.
            // 在所有注册的Bean中查找Listener bean，注册到消息广播器中
            registerListeners();

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

            // Last step: publish corresponding event.
            // 最后一步，完成刷新过程，通知生命周期处理器initLifecycleProcessor刷新过程，同时发出
            // ContextRefreshedEvent通知别人
            finishRefresh();
        }

        catch (BeansException ex) {
            if (logger.isWarnEnabled()) {
                logger.warn("Exception encountered during context initialization - " +
                        "cancelling refresh attempt: " + 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...
            //重置Spring核心中的常见内省缓存，因为我们
            //可能再也不需要单例bean的元数据了…
            resetCommonCaches();
        }
    }
}

上面这一段代码，真的是值得学习，每个功能抽离出一个单独的方法实现，思路清晰，让看代码的人也神清气爽！ 很多时候在开发项目中，一个业务功能的实现成百上千行，看着就头痛。

下面对refresh()中的过程进行简单概括：

1. 初始化的准备工作，例如对系统属性或者环境变量进行准备及验证。
2. 初始化BeanFactory ，并对XML文件读取。
3. 对BeanFactory 进行各种功能填充。如 @Qualifier 和@Autowired这两个注解正是在这一步骤增加的支持。
4. 子类覆盖方法做的额外处理。（这就是Spring强大的地方，除了功能强大，可扩展性也很强大。）
5. 激活各种 BeanFactory 处理器。
6. 注册拦截bean创建的bean处理器
7. 为上下文初始化message源
8. 初始化应用消息广播器
9. 留着子类初始化其他的bean
10. 在所有注册的bean中查找listener bean
11. 初始化剩下的单实例
12. 完成刷新过程。

2.2.1 环境准备 prepareRefresh()

初始化的准备工作，例如对系统属性或者环境变量进行准备及验证。

protected void prepareRefresh() {
    // startupDate 当此上下文启动时的 系统时间(以毫秒为单位)
    this.startupDate = System.currentTimeMillis();
    // closed 标志，指示此上下文是否已经关闭
    this.closed.set(false);
    // active 标志，指示此上下文当前是否活动。
    this.active.set(true);

    if (logger.isInfoEnabled()) {
        logger.info("Refreshing " + this);
    }

    // Initialize any placeholder property sources in the context environment
    // 在上下文环境中初始化任何占位符属性源,默认实现为空，留给子类覆盖(实现个性化的需求)
    initPropertySources();

    // 验证需要的属性文件是否都已经放入环境中
    getEnvironment().validateRequiredProperties();

    // Allow for the collection of early ApplicationEvents,
    // to be published once the multicaster is available...
    //允许收集早期应用程序事件，
    //一旦有了广播机，就可以发布……
    this.earlyApplicationEvents = new LinkedHashSet<>();
}

准备这个上下文刷新，设置它的启动日期和主动标志，以及执行任何属性源的初始化。

2.2.2 加载BeanFactory的 obtainFreshBeanFactory()

obtainFreshBeanFactory 方法代表获取 BeanFactory ！上面类图也可以看出ApplicationContext是BeanFactory的子类，经历过这个方法后，ApplicationContext 就拥有了 BeanFactory全部功能。

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
    // 初始化BeanFactory并进行XML的读取，并将得到的BeanFactory记录到当前的实体属性中
    refreshBeanFactory();
    // 返回当前实体的BeanFactory属性
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    if (logger.isDebugEnabled()) {
        logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
    }
    return beanFactory;
}
//# 核心方法为 refreshBeanFactory()
//# AbstractRefreshableApplicationContext.refreshBeanFactory()
protected final void refreshBeanFactory() throws BeansException {
    if (hasBeanFactory()) {
        destroyBeans();
        closeBeanFactory();
    }
    try {
        // 创建了 DefaultListableBeanFactory
        DefaultListableBeanFactory beanFactory = createBeanFactory();
        // 为了序列号指定ID，
        beanFactory.setSerializationId(getId());
        // 定制BeanFactory，设置相关属性
        customizeBeanFactory(beanFactory);
        // 初始化 DocumentReader ,并进行XML文件读取及解析
        loadBeanDefinitions(beanFactory);
        synchronized (this.beanFactoryMonitor) {
            this.beanFactory = beanFactory;
        }
    }
    catch (IOException ex) {
        throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
    }
}

简述上述过程：
1. 创建 DefaultListableBeanFactory,这个是BeanFactory的子类，它提供了XmlBeanDefinitionReader 类型的reader属性，也就是说 DefaultListableBeanFactory 是容器的基础。
2. 指定序列号ID。
3. 定制BeanFactory。
4. 加载BeanDefinition。
5. 使用全局变量记录BeanFactory类的实例。

1、 定制BeanFactory，customizeBeanFactory(beanFactory)

从这里开始对BeanFactory的扩展，在基本容器的基础上，增加了是否允许覆盖，是否允许扩展的设置。并提供了注解 @Qualifier 和 @Autowired的支持。

protected void customizeBeanFactory(DefaultListableBeanFactory beanFactory) {
    // 如果属性 allowBeanDefinitionOverriding 不为空，设置给 beanFactory 对象相应属性。
    // 此属性含义：是否允许覆盖同名称的不同定义的对象
    if (this.allowBeanDefinitionOverriding != null) {
        beanFactory.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
    }
    // 如果属性 allowBeanDefinitionOverriding 不为空，设置给 beanFactory 对象相应属性。
    // 此属性含义：是否允许bean之间存在循环依赖
    if (this.allowCircularReferences != null) {
        beanFactory.setAllowCircularReferences(this.allowCircularReferences);
    }
}

这里允许覆盖和允许依赖的设置只是判断了是否为空，其中setAllowBeanDefinitionOverriding()和 setAllowCircularReferences() 默认为 true! 子类可以通过覆盖方法修改默认值：
如下：

public class MyClassPathXmlApplicationContext extends ClassPathXmlApplicationContext { 
   

    @Override
    protected void customizeBeanFactory(DefaultListableBeanFactory beanFactory) {
        super.setAllowBeanDefinitionOverriding(false);
        super.setAllowCircularReferences(false);
        super.customizeBeanFactory(beanFactory);
    }
}

2、加载BeanDefintion ,loadBeanDefinitions(beanFactory)

/** * Loads the bean definitions via an XmlBeanDefinitionReader. * 加载 bean的定义 通过 XmlBeanDefinitionReader * @see org.springframework.beans.factory.xml.XmlBeanDefinitionReader * @see #initBeanDefinitionReader * @see #loadBeanDefinitions */
@Override
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
    // Create a new XmlBeanDefinitionReader for the given BeanFactory.
    // 为指定的BeanFactory 创建 一个 XmlBeanDefinitionReader
    XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);

    // Configure the bean definition reader with this context's
    // resource loading environment.
    // 对 beanDefinitionReader 进行 环境变量设置
    beanDefinitionReader.setEnvironment(this.getEnvironment());
    beanDefinitionReader.setResourceLoader(this);
    beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));

    // Allow a subclass to provide custom initialization of the reader,
    // then proceed with actually loading the bean definitions.
    // 对 beanDefinitionReader 进行设置，可以覆盖
    initBeanDefinitionReader(beanDefinitionReader);
    // 通过指定的 XmlBeanDefinitionReader 加载 bean定义
    loadBeanDefinitions(beanDefinitionReader);
}
// 加载bean的定义
protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
    Resource[] configResources = getConfigResources();
    if (configResources != null) {
        reader.loadBeanDefinitions(configResources);
    }
    String[] configLocations = getConfigLocations();
    if (configLocations != null) {
        reader.loadBeanDefinitions(configLocations);
    }
}

加载beanDefinition的核心就是创建一个XmlBeanDefinitionReader 然后对配置文件的加载以及注册。

2.2.3 对BeanFactory 进行各种功能填充 prepareBeanFactory(beanFactory)

在进入prepareBeanFactory前，Spring已经完成了对配置的解析，ApplicationContext的扩展从这里也真正的展开了。

/** * Configure the factory's standard context characteristics, * such as the context's ClassLoader and post-processors. * 配置工厂的标准上下文特性，例如上下文的类加载器和后处理器。 * @param beanFactory the BeanFactory to configure */
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
    // Tell the internal bean factory to use the context's class loader etc.
    // 设置 beanFactory 的 ClassLoader 为当前 context 的ClassLoader。
    beanFactory.setBeanClassLoader(getClassLoader());
    // 设置 beanFactory 的 表达式语言处理器
    beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
    // 为beanFacotry 增加一个默认的 PropertyEditor，主要是对bean的属性等设置管理的一个工具
    beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

    // Configure the bean factory with context callbacks.
    // 使用上下文回调配置bean工厂。增加了 BeanPostProcessor
    beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
    // 设置 了几个 忽略自动装配的接口
    beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
    beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
    beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
    beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
    beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
    beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);

    // BeanFactory interface not registered as resolvable type in a plain factory.
    // MessageSource registered (and found for autowiring) as a bean.
    // 在普通工厂中，BeanFactory接口未注册为可解析类型。
    // MessageSource注册(用于自动连接)为bean。
    beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
    beanFactory.registerResolvableDependency(ResourceLoader.class, this);
    beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
    beanFactory.registerResolvableDependency(ApplicationContext.class, this);

    // Register early post-processor for detecting inner beans as ApplicationListeners.
    // 注册早期后处理器，以检测内部bean作为应用程序监听器。
    beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

    // Detect a LoadTimeWeaver and prepare for weaving, if found.
    // 检测一个LoadTimeWeaver并准备编织，如果找到的话。增加对 AspectJ的支持
    if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
        beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
        // Set a temporary ClassLoader for type matching.
        // 为类型匹配设置临时类加载器。
        beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
    }

    // Register default environment beans.
    // 添的默认系统环境bean。
    if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
        beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
    }
    if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
        beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
    }
    if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
        beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
    }
}

综合上面的代码，上面的函数主要进行了几个方面的扩展：

• 增加了SPEL语言的支持。支持 #{…}方式调用相关属性。
• 增加了对属性编辑器的支持。
• 设置了一些内置类信息的注入。
• 设置了依赖功能可以忽略的接口。
• 注册一些固定依赖的属性。
• 增加了 AspectJ的支持。
• 添加默认系统环境bean。如属性注册和单实例模式注册。

1.增加SPEL语言的支持

SPEL：Spring 表达式语法，Spring Expression Language。能够在运行时候构建复杂表达式、存取对象属性，对象方法调用等。Spel是单独的模块，依赖Spring的core，解析过程是在Spring的expression包内。
简单举例：

<bean id="testSpel" value="org.xxx.xxx" />
<bean>
    <property name="csdn" value="#{testSpel}">
</bean>

相当于：
<bean id="testSpel" value="org.xxx.xxx" />
<bean>
    <property name="csdn" ref="testSpel">
</bean>

2.增加对属性编辑器

通过源码的查看，这里面无非就是注册一些常用的属性编辑器，并且能够自定义一些属性编辑器。

演示代码：

public class UserManager {

    private Date dateValue;

    public Date getDateValue() {
        return dateValue;
    }

    public void setDateValue(Date dateValue) {
        this.dateValue = dateValue;
    }

    @Override
    public String toString() {
        return "UserManager{" + "dateValue=" + dateValue + '}';
    }
}
<bean id="userManager" class="org.learn.beans.customerPropertyEditor.UserManager">
    <property name="dateValue">
        <value>2018-08-01</value>
    </property>
</bean>

public static void main(String[] args) {
    ApplicationContext context = new ClassPathXmlApplicationContext("beanFactoryTest.xml");
    UserManager userManager = (UserManager) context.getBean("userManager");

    System.out.println(userManager);
}
// 报错
Caused by: org.springframework.beans.ConversionNotSupportedException: Failed to convert property value of type 'java.lang.String' to required type 'java.util.Date' for property 'dateValue'; 
nested exception is java.lang.IllegalStateException: Cannot convert value of type 
'java.lang.String' to required type 'java.util.Date' for property 'dateValue': no matching editors or conversion strategy found

解决方法1：

// 继承 PropertyEditorSupport ，重写 setAsText方法
public class DatePropertyEditor extends PropertyEditorSupport { 
   

    private String format = "yyyy-MM-dd";

    public void setFormat(String format) {
        this.format = format;
    }

    @Override
    public void setAsText(String text) throws IllegalArgumentException {
        System.out.println("text : " + text);
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        try {
            Date d = sdf.parse(text);
            this.setValue(d);
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }
}
<bean class="org.springframework.beans.factory.config.CustomEditorConfigurer">
   <property name="customEditors">
       <map>
           <entry key="java.util.Date"
                  value="org.learn.beans.customerPropertyEditor.DatePropertyEditor" />
       </map>
   </property>
</bean>

// 注意：上面这个是SPring 4之后的配置，Spring4之前配置如下，不同版本使用不同配置，否则允许会报错！

<bean class="org.springframework.beans.factory.config.CustomEditorConfigurer">
   <property name="customEditors">
       <map>
           <entry key="java.util.Date">
               <bean class="org.learn.beans.customerPropertyEditor.DatePropertyEditor">
                   <property name="format" value="yyyy-MM-dd"/>
               </bean>
           </entry>
       </map>
   </property>
</bean>

解决方法2：
实现Spring自带的属性编辑器 CustomerDateEditor

public class MyDatePropertyEditorRegistrar implements PropertyEditorRegistrar { 
   

    public void registerCustomEditors(PropertyEditorRegistry registry) {

        registry.registerCustomEditor(Date.class,
                new CustomDateEditor(new SimpleDateFormat("yyyy-MM-dd"),true));
    }
}
//配置
<bean class="org.springframework.beans.factory.config.CustomEditorConfigurer"> <property name="propertyEditorRegistrars"> <list> <bean class="org.learn.beans.customerPropertyEditor.MyDatePropertyEditorRegistrar"/> </list> </property> </bean>

3.添加 ApplicationContextAwareProcessor 处理器

这一步主要的目的是注册一个 BeanPostProcessor,真正的逻辑还在 new ApplicationContextAwareProcessor中。
class ApplicationContextAwareProcessor implements BeanPostProcessor 。在实例化Bean的时候，也就是Spring激活bean的 init-method的前后，会有BeanPostProcessor的postProcessBeforeInitialization 和 postProcessAfterInitialization方法。

所以在 ApplicationContextAwareProcessor 处理器中我们也关注这两个方法。

public Object postProcessBeforeInitialization(final Object bean, String beanName) throws BeansException {
    AccessControlContext acc = null;

    if (System.getSecurityManager() != null &&
            (bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware ||
                    bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware ||
                    bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware)) {
        acc = this.applicationContext.getBeanFactory().getAccessControlContext();
    }

    if (acc != null) {
        // 使用了Aware接口的bean在被初始化后，可以获得一些对应的资源。
        AccessController.doPrivileged((PrivilegedAction<Object>) () -> { invokeAwareInterfaces(bean); return null; }, acc); } else { invokeAwareInterfaces(bean); } return bean; } private void invokeAwareInterfaces(Object bean) { if (bean instanceof Aware) { if (bean instanceof EnvironmentAware) { ((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment()); } if (bean instanceof EmbeddedValueResolverAware) { ((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver); } if (bean instanceof ResourceLoaderAware) { ((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext); } if (bean instanceof ApplicationEventPublisherAware) { ((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext); } if (bean instanceof MessageSourceAware) { ((MessageSourceAware) bean).setMessageSource(this.applicationContext); } if (bean instanceof ApplicationContextAware) { ((ApplicationContextAware) bean).setApplicationContext(this.applicationContext); } } } /** * 这个方法没有做什么逻辑处理 * @param bean the new bean instance * @param beanName the name of the bean * @return */ @Override public Object postProcessAfterInitialization(Object bean, String beanName) { return bean; }

4.设置忽略依赖

因为在上面postProcess操作中，实现了Awar接口的bean已经不是普通的bean了，如ResourceLoaderAware等，那么需要在SPring做bean的依赖注入的时候忽略它们。

5.注册依赖

2.2.4 对BeanFactory 的后处理

BeanFactory作为Spring中容器功能的基础，用于存放所有已经加载的bean，为了保证程序的高可扩展性，Spring针对BeanFactory做了大量的扩展，如PostProcessor等。

2.2.5 激活注册的BeanFactoryPostProcessor

下面是Spring 5 中的BeanFactoryPostProcessor源码，函数式接口

@FunctionalInterface
public interface BeanFactoryPostProcessor { 
   

    /** * Modify the application context's internal bean factory after its standard * initialization. All bean definitions will have been loaded, but no beans * will have been instantiated yet. This allows for overriding or adding * properties even to eager-initializing beans. * 在标准初始化之后修改应用程序上下文的内部bean工厂。 * 将加载所有bean定义，但尚未实例化任何bean。 这允许覆盖或添加属性，甚至是初始化bean。 * * @param beanFactory the bean factory used by the application context * @throws org.springframework.beans.BeansException in case of errors */
    void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;

}

BeanFactoryPostProcessor和 BeanPostProcessor可以对bean的定义（配置元数据）进行处理，也就是说，Spring Ioc 容器允许 BeanFactoryPostProcessor 在容器实际 实例化任何 其他的bean 之前 读取配置元数据，并有可能修改它。

需要强调的一点，就是如果你想改变实际bean的实例，那么你最好是用 BeanPostProcessor ! 因为 BeanFactoryPostProcessor 的作用域范围是容器级的，只和你所使用的容器相关。
BeanFactoryPostProcessor不会对另一个容器的bean进行后置处理。即使这两个容器都是在同一个层次上，Spring中存在对于BeanFactoryPostProcessor的典型应用。比如 PropertyPlaceholderConfigurer.

(1) BeanFactoryPostProcessor的典型应用PropertyPlaceholderConfigurer
在spring配置的xml中，如配置datasource的时候可能会配置如下：

<property name="driverClassName" value="${DBCP.DataSource.driver}" />
<property name="url" value="${DBCP.DataSource.url}" />
<property name="username" value="${DBCP.DataSource.username}" />
<property name="password" value="${DBCP.DataSource.dbpassword}" />

这个配置里面使用了变量引用：${DBCP.DataSource.url}等，这就是spring分散配置，可以在另外的配置文件中为${DBCP.DataSource.url}等指定值。比如我在db.properties中指定：

DBCP.DataSource.driver=com.mysql.jdbc.Driver

Spring 框架是怎么知道存在这样的配置文件呢？
这就要靠 PropertyPlaceholderConfigurer 这个类的bean。

<bean id="dbProperties" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
    <property name="location">
        <value>classpath:db.properties</value>
    </property>
</bean>

BeanFacotryPostProcessor接口间接继承了BeanFacotryPostProcessor接口，这是一个特别的接口，当Spring加载任何实现了这个接口的bean的配置时，都会在bean工厂载入所有bean的配置之后执行postProcessBeanFactroy方法。

在BeanFacotryPostProcessor类中，实现了postProcessBeanFactory方法。如下：

@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);
    }
}

通过 mergeProperties 、 convertProperties 、 processProperties 这三个方法，分别得到配置，将得到的配置转换为合适的类型，最后将配置内容告诉 BeanFactory。

(2) 使用自定义的 BeanFactoryPostProcessor

实现该接口，可以在spring的bean创建之前，修改bean的定义属性。也就是说，Spring允许BeanFactoryPostProcessor在容器实例化任何其它bean之前读取配置元数据，并可以根据需要进行修改，例如可以把bean的scope从singleton改为prototype，也可以把property的值给修改掉。可以同时配置多个BeanFactoryPostProcessor，并通过设置’order’属性来控制各个BeanFactoryPostProcessor的执行次序。
注意：BeanFactoryPostProcessor是在spring容器加载了bean的定义文件之后，在bean实例化之前执行的。接口方法的入参是ConfigurrableListableBeanFactory，使用该参数，可以获取到相关bean的定义信息。

// 测试的类
public class MyTestBean {

    private String name;
    private String desc;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getDesc() {
        return desc;
    }

    public void setDesc(String desc) {
        this.desc = desc;
    }

    @Override
    public String toString() {
        return "MyTestBean{" + "name='" + name + '\'' + ", desc='" + desc + '\'' + '}';
    }
}
// 自定义实现 postProcessBeanFactory
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor{

    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {

        System.out.println("调用MyBeanFactoryPostProcessor的postProcessBeanFactory");
        BeanDefinition bd = beanFactory.getBeanDefinition("myTestBean");
        System.out.println("属性值============" + bd.getPropertyValues().toString());
        MutablePropertyValues pv =  bd.getPropertyValues();
        if (pv.contains("desc")) {
            pv.addPropertyValue("desc", "best!");
        }
    }
}
// xml配置
<bean id="myTestBean" class="org.learn.beans.MyTestBean">
     <property name="name" value="spring"/>
     <property name="desc" value="good"/>
 </bean>


 <bean id="myBeanFactoryPostProcessor" class="org.learn.beans.customerPropertyEditor.MyBeanFactoryPostProcessor" />
// 运行结果
ApplicationContext context = new ClassPathXmlApplicationContext("beanFactoryTest.xml");
MyTestBean testBean = (MyTestBean) context.getBean("myTestBean");

System.out.println(testBean);

调用MyBeanFactoryPostProcessor的postProcessBeanFactory
属性值============PropertyValues: length=2; bean property 'name'; bean property 'desc'
MyTestBean{name='spring', desc='best!'}

2.2.6 注册的BeanPostProcessor

Spring中大部分功能都是通过后处理器的方式进行扩展的，这是Spring框架的一个特性。这里探索一个BeanPostProcessor的注册，真正的调用是在bean实例化阶段进行的。在Spring的BeanFactory中并没有自动注册后处理器，所以在调用的时候没有注册是不能使用的。

对比分析总结 BeanFactoryPostProcessor和 BeanPostProcessor：
BeanFactoryPostProcessor在bean实例化之前执行，之后实例化bean（调用构造函数，并调用set方法注入属性值），然后在调用BeanPostProcessor的两个初始化方法前后！

2.2.7 初始化消息资源- initMessageSource();

Spring国际化的相关功能，读取并将自定义的资源文件配置记录到容器中，在获取资源文件的时候直接使用。

2.2.8 初始化ApplicationEventMulticaster – initApplicationEventMulticaster

在讲解Spring的事件传播之前，先了解一下事件监听的简单用法。
1.定义监听事件

public class MyEvent extends ApplicationEvent { 
   

    private String msg;
    /** * Create a new ApplicationEvent. * @param source the object on which the event initially occurred (never {@code null}) */
    public MyEvent(Object source) {
        super(source);
    }

    public MyEvent(Object source, String msg) {
        super(source);
        this.msg = msg;
    }

    public void show(){
        System.out.println(msg);
    }
}

2.定义监听器

public class MyListener implements ApplicationListener<MyEvent> { 
   

    public void onApplicationEvent(MyEvent event) {

        event.show();
    }
}

3.配置监听器

 <bean id="myListener" class="org.learn.beans.event.MyListener"/>

4.测试

ApplicationContext context = new ClassPathXmlApplicationContext("beanFactoryTest.xml");
MyEvent event = new MyEvent("hello", "world");
context.publishEvent(event);

当程序运行Spring会将发出的Event事件转给我们自定义的Listener进行处理。这里其实是用了 设计模式中 观察者模式。

2.2.9注册监听器 registerListeners();

在所有注册的Bean中查找Listener bean，注册到消息广播器中。

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!
    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);
        }
    }
}

2.2.10 初始化非延迟加载单例 – finishBeanFactoryInitialization(beanFactory);

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

/** * Finish the initialization of this context's bean factory, * initializing all remaining singleton beans. * 完成此上下文的bean工厂的初始化， * 初始化所有剩余的单例bean */
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.
    if (!beanFactory.hasEmbeddedValueResolver()) {
        beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
    }

    // Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
    String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
    for (String weaverAwareName : weaverAwareNames) {
        getBean(weaverAwareName);
    }

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

    // Allow for caching all bean definition metadata, not expecting further changes.
    // 允许缓存所有bean定义元数据，而不期望进一步的更改。
    beanFactory.freezeConfiguration();

    // Instantiate all remaining (non-lazy-init) singletons.
    // 实例化所有剩余的(非惰性初始化)单例。
    beanFactory.preInstantiateSingletons();
}

主要是ConversionService的设置，它能够提供一个转换器，我们可以自定义转换器。然后冻结配置，最后就是加载所有非延迟的bean。
ApplicationContext实现的默认行为就是启动时将所有单例bean提前进行实例化。提前的好处就是更早的发现配置中的错误。

2.2.11 finishRefresh();

最后一步，完成刷新过程，通知生命周期处理器initLifecycleProcessor刷新过程，同时发出 ContextRefreshedEvent通知别人。
Spring 提供了Lifecylce接口，LifeCycle中包含start/stop 方法，实现此接口后Spring会保证在启动的时候调用其start方法开始生命周期，并在Spring关闭的时候调用stop方法结束生命周期。
““
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.
//首先将refresh传播到生命周期处理器。
getLifecycleProcessor().onRefresh();

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

// Participate in LiveBeansView MBean, if active.
// 参与LiveBeansView MBean，如果激活。
LiveBeansView.registerApplicationContext(this);

}
“`

1.initLifecycleProcessor();
当ApplicationContext启动或者停止的时候，它会通过LifeCycleProcessor来所有申明的bean的周期做状态更新。所有需要对LifecyceleProcessor进行初始化。
2.onRefresh，启动所有实现LifeCycle接口的bean。
3.publishEvent，当完成ApplicationContext初始化的时候，要通过Spring中的事件发布机制来发出ContextRefreshedEvent事件，保证对应的监听器做进一步的逻辑处理。

容器的扩展搞完了，懵懵懂懂！Spring挺复杂的，看完也是一个大概的了解，对于里面的具体代码实现，还不是很清楚。本篇是学习笔记，参考《Spring源码深度解析》！