Spring IoC容器初始化源码(5)—prepareBeanFactory准备Bean工厂、回调BeanFactoryPostProcessor、注册BeanPostProcessor【两万字】

基于最新Spring 5.x，详细介绍了prepareBeanFactory配置BeanFactory、invokeBeanFactoryPostProcessors回调BeanFactoryPostProcessor扩展点、registerBeanPostProcessors注册BeanPostProcessor扩展点。

上一篇文章：Spring IoC容器初始化源码(4)—＜context:component-scan/＞标签解析、spring.components扩展点、自定义Spring命名空间扩展点中，我们主要讲解了自定义命名空间和Spring5的spring.components这两个容器扩展点，以及< context:component-scan/>扩展标签的解析。
现在我们继续向下学习refresh()方法，到此obtainFreshBeanFactory方法的大概内容算是结束了，我继续向下走，本篇文章的内容主要就是prepareBeanFactory配置BeanFactory、postProcessBeanFactory扩展BeanFactory、invokeBeanFactoryPostProcessors回调BeanFactoryPostProcessor扩展点、registerBeanPostProcessors注册BeanPostProcessor扩展点，以及MessageSource和Listener相关初始化。

Spring IoC容器初始化源码系列文章

Spring IoC容器初始化源码(1)—setConfigLocations设置容器配置信息

Spring IoC容器初始化源码(2)—prepareRefresh准备刷新、obtainFreshBeanFactory加载XML资源、解析＜beans/＞标签

Spring IoC容器初始化源码(3)—parseDefaultElement、parseCustomElement解析默认、扩展标签，registerBeanDefinition注册Bean定义

Spring IoC容器初始化源码(4)—＜context:component-scan/＞标签解析、spring.components扩展点、自定义Spring命名空间扩展点

Spring IoC容器初始化源码(5)—prepareBeanFactory、invokeBeanFactoryPostProcessors、registerBeanPostProcessors方法

Spring IoC容器初始化源码(6)—finishBeanFactoryInitialization实例化Bean的整体流程以及某些扩展点

Spring IoC容器初始化源码(7)—createBean实例化Bean的整体流程以及构造器自动注入

Spring IoC容器初始化源码(8)—populateBean、initializeBean实例化Bean以及其他依赖注入

＜ context:property-placeholder/＞标签以及PropertySourcesPlaceholderConfigurer占位符解析器源码深度解析

三万字的ConfigurationClassPostProcessor配置类后处理器源码深度解析

基于JavaConfig的AnnotationConfigApplicationContext IoC容器初始化源码分析

文章目录

Spring IoC容器初始化源码系列文章
1 prepareBeanFactory配置BeanFactory
- 1.1 BeanPostProcessor后置处理器扩展点
- - 1.1.1 使用案例
  - 1.1.2 ApplicationContextAwareProcessor
- 1.2 忽略setter自动注入扩展点
- - 1.2.1 ignoreDependencyType
  - 1.2.2 ignoreDependencyInterface
- 1.3 指定自动注入实例扩展点
- - 1.3.1 预定义的自动注入实例
  - 1.3.2 自定义的自动注入实例
- 1.4 手动注册单例bean扩展点
2 postProcessBeanFactory扩展BeanFactory
3 invokeBeanFactoryPostProcessors回调BeanFactoryPostProcessor
- 3.1 BeanFactoryPostProcessor扩展点
- 3.2 BeanDefinitionRegistryPostProcessor扩展点
- 3.3 invokeBeanFactoryPostProcessors回调BeanFactoryPostProcessor
- 3.3.1 getBeanFactoryPostProcessors获取上下文中的beanFactoryPostProcessors
- - 3.3.2 invokeBeanFactoryPostProcessors回调BeanFactoryPostProcessor
  - - 3.3.2.1 sortPostProcessors优先级排序
    - - 3.3.2.1.1 OrderComparator比较器
4 registerBeanPostProcessors注册BeanPostProcessor
- 4.1 registerBeanPostProcessors注册BeanPostProcessor
5 initMessageSource初始化MessageSource
6 initApplicationEventMulticaster初始化ApplicationEventMulticaster
7 onRefresh扩展点
8 registerListeners注册Listener
9 小结

1 prepareBeanFactory配置BeanFactory

在obtainFreshBeanFactory方法获取到新的BeanFactory之后，随即调用prepareBeanFactory方法对新获取的BeanFactory进行一系列配置。这也是applicationContext功能的扩展。
配置的信息包括：

设置BeanFactory的类加载器，用于后面创建bean的实例。
设置SPEL表达式的解析器实例StandardBeanExpressionResolver，用于后面解析SPEL表达式。在后面的doCreateBean方法中我们会再次见到。
添加一个默认属性编辑器注册表实例ResourceEditorRegistrar，主要目的是后面调用其内部的registerCustomEditors方法注册一批常用的PropertyEditor，比如ResourceEditor。
添加一个BeanPostProcessor实例ApplicationContextAwareProcessor，主要目的是用于忽略一批Aware接口的setter方法的自动装配。由ApplicationContextAwareProcessor的后置处理方法中手动调用注入代替这些接口的setter自动注入。在后面的doCreateBean方法中我们会再次见到。
注册一批可以免配置默认自动注入的类型到resolvableDependencies缓存map中，可以直接获取该对应类型的属性的实例。包括BeanFactory、ResourceLoader、ApplicationEventPublisher、ApplicationContext。在后面的doCreateBean方法中我们会再次见到。
添加一个早期的后置处理器实例 ApplicationListenerDetector，专门用来探测监听器，并进行绑定。在后面的doCreateBean方法中我们会再次见到。
如果工厂中具有名为loadTimeWeaver名称的bean，则会注册一个LoadTimeWeaverAwareProcessor后置处理器到容器中。用于类加载期织入AspectJ用的。
手动注册一系列系统和JVM环境bean以及实例，environment、systemProperties、systemEnvironment。这就是所谓的手动注入。

//------AbstractApplicationContext的相关属性 /** * 类加载器，用于后面根据className创建bean的实例(如有必要) */ @Nullable private ClassLoader beanClassLoader = ClassUtils.getDefaultClassLoader(); /** * bean定义中SPEL表达式的解析器 */ @Nullable private BeanExpressionResolver beanExpressionResolver; /** * 自定义的属性编辑器注册表 */ private final Set<PropertyEditorRegistrar> propertyEditorRegistrars = new LinkedHashSet<>(4); /** * 按添加顺序先后排列的要使用BeanPostProcessor列表 */ private final List<BeanPostProcessor> beanPostProcessors = new CopyOnWriteArrayList<>(); /** * 要忽略自动注入的类型的列表 */ private final Set<Class<?>> ignoredDependencyInterfaces = new HashSet<>(); /** * 从依赖项类型映射到相应的自动注入的实例的map */ private final Map<Class<?>, Object> resolvableDependencies = new ConcurrentHashMap<>(16); //---------ConfigurableApplicationContext接口的相关常量属性 /** * 工厂中的 LoadTimeWeaver bean的名称。 */ String LOAD_TIME_WEAVER_BEAN_NAME = "loadTimeWeaver"; /** * 工厂中的 environment bean的名称。 * * @since 3.1 */ String ENVIRONMENT_BEAN_NAME = "environment"; /** * 工厂中的 systemProperties bean的名称。 * java.lang.System#getProperties()可以获取 */ String SYSTEM_PROPERTIES_BEAN_NAME = "systemProperties"; /** * 工厂中的 systemEnvironment bean的名称。 * java.lang.System#getenv()可以获取 */ String SYSTEM_ENVIRONMENT_BEAN_NAME = "systemEnvironment"; /** * AbstractApplicationContext的方法 *

* 配置工厂的标准上下文特征，例如上下文的 ClassLoader、一些BeanPostProcessor后处理器、手动注册一些的bean等等。 * 这些特征都可以算作applicationContext功能的扩展 * * @param beanFactory 要配置的BeanFactory */ protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) { /* * 1 设置BeanFactory的类加载器，用于后面创建bean的实例 * 直接使用上下文容器的类加载器，默认就是 Launcher$AppClassLoader 类加载器实例 */ beanFactory.setBeanClassLoader(getClassLoader()); /* * 2 设置SPEL表达式的解析器实例StandardBeanExpressionResolver * 我们此前学习SPEL表达式的时候就说过，Spring默认使用StandardBeanExpressionResolver解析SPEL表达式#{} */ beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader())); /* * 3 添加一个默认属性编辑器注册表实例ResourceEditorRegistrar * 主要目的是调用其内部的registerCustomEditors方法注册一批常用的PropertyEditor，比如ResourceEditor * * PropertyEditor（属性编辑器）用于bean的属性注入时的类型自动转换，比如value字符串转换为各种集合，Resource资源类型等等 * 我们可以实现PropertyEditorSupport接口自定义属性编辑器 */ beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment())); /* * 4 添加一个BeanPostProcessor实例ApplicationContextAwareProcessor * BeanPostProcessor也是一个扩展回调接口，它的postProcessBeforeInitialization方法在bean的init-method执行之前执行 * 它的postProcessAfterInitialization方法在bean的init-method执行之后执行 * * ApplicationContextAwareProcessor的目的很简单，如果我们的bean实现了Aware标志性接口下的 * EnvironmentAware、EmbeddedValueResolverAware、ResourceLoaderAware、ApplicationEventPublisherAware、MessageSourceAware、ApplicationContextAware六个接口 * 那么在bean被初始化之后，init-method执行，将会由ApplicationContextAwareProcessor帮助我们调用相关接口的setter方法注入applicationContext或者embeddedValueResolver属性 */ beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this)); /* * 5 忽略一批Aware接口的setter方法的自动装配 * * 这一批接口就上面ApplicationContextAwareProcessor处理的手动装配的接口，由于上面的手动配装，因此不需要自动注入功能 * 在此前的createBeanFactory方法中，就已经忽略了BeanNameAware、BeanFactoryAware、BeanClassLoaderAware接口的setter方法自动装配 */ beanFactory.ignoreDependencyInterface(EnvironmentAware.class); beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class); beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class); beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class); beanFactory.ignoreDependencyInterface(MessageSourceAware.class); beanFactory.ignoreDependencyInterface(ApplicationContextAware.class); /* * 6 注册一批指定类型接口的默认自动注入实例 * * 什么意思呢？一般我们的自动装配，都需要相关的注解、或者XML的配置自动注入 * * 如果一个接口有多个实现，那么使用自动注入可能会报错 * 使用该方法指定某个类型的接口，如果外部要注入该类型接口的对象，则会直接注入我们指定的对象 * * BeanFactory、 -> 实际注入的是DefaultListableBeanFactory实例 * ResourceLoader、ApplicationEventPublisher、ApplicationContext ->实际注入的是当前上下文容器实例 */ beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory); beanFactory.registerResolvableDependency(ResourceLoader.class, this); beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this); beanFactory.registerResolvableDependency(ApplicationContext.class, this); /* * 7 添加一个早期的后置处理器实例 ApplicationListenerDetector * * ApplicationListenerDetector是一个监听器探测器，专门用来探测监听器 * 在bean实例化和依赖注入完毕之后，用于检测当前bean是不是ApplicationListener监听器的实现，是的话将它注册到应用的事件多播器上。 */ beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this)); /* * 8 如果工厂中具有名为loadTimeWeaver名称的bean，则会注册一个LoadTimeWeaverAwareProcessor后置处理器到容器中 * * 说实话没研究过，看文章是啥类加载期织入AspectJ用的 */ if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) { beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory)); // Set a temporary ClassLoader for type matching. //指定用于类型匹配的临时类加载器。默认值为无，只需使用标准 bean 类加载器即可。 beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader())); } /* * 9 手动注册一系列系统和JVM环境bean以及实例： * environment -> 容器环境变量对象，内部包含了systemEnvironment和systemProperties * systemProperties -> JVM环境变量对象，最开始的setConfigLocations部分我们就见过了 * systemEnvironment -> 系统环境变量对象，最开始的setConfigLocations方法部分我们就见过了 * * 调用registerSingleton，就是所谓的手动注册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()); } }

1.1 BeanPostProcessor后置处理器扩展点

BeanPostProcessor是Spring提供的一个扩展接口，Spring中大部分功能都是通过后处理器的方式进行扩展的。这也是ApplicationContext容器相比于BeanFactory的改进，使用BeanFactory时，BeanPostProcessor需要手动调用方法注册，而使用ApplicationContext时，BeanPostProcessor可以通过< bean/>标签自动注册。

它提供了两个方法，Spring5之后由抽象方法改为默认方法：

postProcessBeforeInitialization：bean实例化以及依赖注入完毕之后，initMethod方法调用完毕之前调用。
postProcessAfterInitialization：bean实例化以及依赖注入完毕之后，initMethod方法调用完毕之后调用。
注意，BeanPostProcessor仅仅是一个超级接口，我们后面还会看到更多的后置处理器的子接口和实现，它们还拥有其他自己方法，它们也可能会在其他阶段被调用，而不仅仅是上面的两个方法和阶段。

/**
 * Spring提供的扩展接口
 */
public interface BeanPostProcessor {

    /**
     * bean实例化以及依赖注入完毕之后，initMethod方法调用完毕之前调用
     *
     * @param bean     初始化的bean实例
     * @param beanName beanName
     * @return 后续要使用的 bean 实例，如果为null，则不会调用后续的后置处理器对应的方法，一般还是返回bean
     */
    @Nullable
    default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        //默认返回bean
        return bean;
    }

    /**
     *bean实例化以及依赖注入完毕之后，initMethod方法啊调用完毕之后调用
     *
     * @param bean     初始化的bean实例
     * @param beanName beanName
     * @return 后续要使用的 bean 实例，如果为null，则不会调用后续的后置处理器对应的方法，一般还是返回bean
     */
    @Nullable
    default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        //默认返回bean
        return bean;
    }

}

1.1.1 使用案例

我们只需要实现BeanPostProcessor接口然后将其当作普通bean注册到Spring容器中，在bean实例化的过程中就会自动顺序调用所有BeanPostProcessor实例的相关回调方法。如果要指定顺序，那么增加实现org.springframework.core.Ordered接口即可。

测试类：

public class BeanPostProcessorTest {
    private String string;

    public BeanPostProcessorTest() {
        System.out.println("无参构造器调用");
    }

    public BeanPostProcessorTest(String string) {
        System.out.println("带参构造器调用");
        this.string = string;
    }

    public void setString(String string) {
        System.out.println("setter调用");
        this.string = string;
    }

    public void init(){
        System.out.println("+++++++++++++++ init-method +++++++++++++++++++");
    }

    @Override
    public String toString() {
        return "BeanPostProcessorTest{" +
                "string='" + string + '\'' +
                '}';
    }
}

自定义的后置处理器：

public class MyBeanPostProcessor {
    public static class MyBeanPostProcessor1 implements BeanPostProcessor, Ordered {
        
        @Override
        public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
            System.out.println("-------------postProcessBeforeInitialization1 start-------------");
            System.out.println("bean: " + bean);
            System.out.println("beanName: " + beanName);
            //如果返回null，则不会调用后续的后置处理器对应的方法
            System.out.println("-------------postProcessBeforeInitialization1 end-------------");

            return bean;
        }

        @Override
        public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
            System.out.println("-------------postProcessAfterInitialization1 start-------------");
            System.out.println("bean: " + bean);
            System.out.println("beanName: " + beanName);
            System.out.println("-------------postProcessAfterInitialization1 end-------------");
            return bean;
        }

        /**
         * @return 返回值越小，执行优先级越高
         */
        @Override
        public int getOrder() {
            return 0;
        }
    }

    public static class MyBeanPostProcessor2 implements BeanPostProcessor, Ordered {

        @Override
        public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
            System.out.println("-------------postProcessBeforeInitialization2 start-------------");
            System.out.println("bean: " + bean);
            System.out.println("beanName: " + beanName);
            System.out.println("-------------postProcessBeforeInitialization2 end-------------");
            return bean;
        }

        @Override
        public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
            System.out.println("-------------postProcessAfterInitialization2 start-------------");
            System.out.println("bean: " + bean);
            System.out.println("beanName: " + beanName);
            System.out.println("-------------postProcessAfterInitialization2 end-------------");
            return bean;
        }

        /**
         * @return 返回值越小，执行优先级越高
         */
        @Override
        public int getOrder() {
            return 2;
        }
    }
}

配置文件：


<bean class="com.spring.source.MyBeanPostProcessor.MyBeanPostProcessor1" id="myBeanPostProcessor1"/>
<bean class="com.spring.source.MyBeanPostProcessor.MyBeanPostProcessor2" id="myBeanPostProcessor2"/>


<bean class="com.spring.source.BeanPostProcessorTest" id="beanPostProcessorTest" init-method="init">
    <property name="string" value="str1"/>
bean>

测试：

@Test
public void beanPostProcessorTest() {
    ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("spring-config-test.xml");
    //手动注入，不会触发BeanPostProcessor回调
    ac.getBeanFactory().registerSingleton("beanPostProcessorTest2", new BeanPostProcessorTest("registerSingleton"));
}

结果如下：

无参构造器调用
setter调用
-------------postProcessBeforeInitialization1 start-------------
bean: BeanPostProcessorTest{string='str1'}
beanName: beanPostProcessorTest
-------------postProcessBeforeInitialization1 end-------------
-------------postProcessBeforeInitialization2 start-------------
bean: BeanPostProcessorTest{string='str1'}
beanName: beanPostProcessorTest
-------------postProcessBeforeInitialization2 end-------------
+++++++++++++++ init-method +++++++++++++++++++
-------------postProcessAfterInitialization1 start-------------
bean: BeanPostProcessorTest{string='str1'}
beanName: beanPostProcessorTest
-------------postProcessAfterInitialization1 end-------------
-------------postProcessAfterInitialization2 start-------------
bean: BeanPostProcessorTest{string='str1'}
beanName: beanPostProcessorTest
-------------postProcessAfterInitialization2 end-------------
带参构造器调用

单纯的使用的话，还是比较简单的！

1.1.2 ApplicationContextAwareProcessor

ApplicationContextAwareProcessor实现了BeanPostProcessor后置处理器接口，是Spring自带的后置处理器。用于向实现了Aware接口的子接口EnvironmentAware、EmbeddedValueResolverAware、ResourceLoaderAware、ApplicationEventPublisherAware、MessageSourceAware、ApplicationContextAwarebean的bean中注入相应的属性。
这里的注入就是：先判断属于某个类型，然后转换换为该类型，并调用相关方法。

/**
 * Spring提供的后置处理器接口的实现
 * 
 * 用于向实现了Aware接口的子接口EnvironmentAware、EmbeddedValueResolverAware、ResourceLoaderAware、
 * ApplicationEventPublisherAware、MessageSourceAware、ApplicationContextAwarebean的bean中注入相应的属性。
 */
class ApplicationContextAwareProcessor implements BeanPostProcessor {

    private final ConfigurableApplicationContext applicationContext;

    private final StringValueResolver embeddedValueResolver;


    /**
     * Create a new ApplicationContextAwareProcessor for the given context.
     */
    public ApplicationContextAwareProcessor(ConfigurableApplicationContext applicationContext) {
        this.applicationContext = applicationContext;
        this.embeddedValueResolver = new EmbeddedValueResolver(applicationContext.getBeanFactory());
    }

    /**
     * 主要看postProcessBeforeInitialization方法
     */
    @Override
    @Nullable
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        /*如果bean不属于这几个接口的实例，那么返回bean，相当于什么都不做*/
        if (!(bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware ||
                bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware ||
                bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware)) {
            return bean;
        }

        /*否则，注入相关属性*/

        AccessControlContext acc = null;

        if (System.getSecurityManager() != null) {
            acc = this.applicationContext.getBeanFactory().getAccessControlContext();
        }

        if (acc != null) {
            AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
                invokeAwareInterfaces(bean);
                return null;
            }, acc);
        } else {
            //主要看invokeAwareInterfaces方法
            invokeAwareInterfaces(bean);
        }

        return bean;
    }

    /**
     * 根据属性类型，然后将之转型，并调用相关方法将属性注入进去，还是比较简单的
     *
     * @param bean 拦截到的bean
     */
    private void invokeAwareInterfaces(Object bean) {
        //属于某个类型
        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);
        }
    }

}

1.2 忽略setter自动注入扩展点

1.2.1 ignoreDependencyType

beanFactory的ignoreDependencyType方法用于忽略该类型及其子类作为参数的setter自动注入设置（byName或者byType），不能忽略constructor的自动注入。相比于ignoreDependencyInterface方法，ignoreDependencyType方法范围更广。在后面的doCreateBean方法中我们就会见到这两个扩展点！

我们添加一个测试类，该类具有同名方法，但是没有实现Ignore接口：

/**
 * @author lx
 */
public class IgnoreOther {

    private PoJoA poJoA;
    private PoJoB poJoB;

    public void setPoJoA(PoJoA poJoA) {
        this.poJoA = poJoA;
    }

    public void setPoJoB(PoJoB poJoB) {
        this.poJoB = poJoB;
    }

    public IgnoreOther(PoJoA poJoA, PoJoB poJoB) {
        this.poJoA = poJoA;
        this.poJoB = poJoB;
    }

    public IgnoreOther() {
    }

    @Override
    public String toString() {
        return "IgnoreOther{" +
                "poJoA=" + poJoA +
                ", poJoB=" + poJoB +
                '}';
    }
}

添加配置：

<bean class="com.spring.source.ingoreInterface.IgnoreOther" 
id="IgnoreOtherByType" autowire="byType"/>
<bean class="com.spring.source.ingoreInterface.IgnoreOther" id="IgnoreOtherByName" autowire="byName"/>
<bean class="com.spring.source.ingoreInterface.IgnoreOther" id="IgnoreOtherByConstructor" autowire="constructor"/>

开启beanFactory.ignoreDependencyInterface(Ignore.class)，测试：

IgnoreImpl{poJoA=null, poJoB=null}
IgnoreImpl{poJoA=null, poJoB=null}
IgnoreImpl{poJoA=com.spring.source.ingoreInterface.IgnoreImpl$PoJoA@25bbf683, poJoB=com.spring.source.ingoreInterface.IgnoreImpl$PoJoB@6ec8211c}
---------------
IgnoreOther{poJoA=com.spring.source.ingoreInterface.IgnoreImpl$PoJoA@25bbf683, poJoB=com.spring.source.ingoreInterface.IgnoreImpl$PoJoB@6ec8211c}
IgnoreOther{poJoA=com.spring.source.ingoreInterface.IgnoreImpl$PoJoA@25bbf683, poJoB=com.spring.source.ingoreInterface.IgnoreImpl$PoJoB@6ec8211c}
IgnoreOther{poJoA=com.spring.source.ingoreInterface.IgnoreImpl$PoJoA@25bbf683, poJoB=com.spring.source.ingoreInterface.IgnoreImpl$PoJoB@6ec8211c}

可以发现，由于IgnoreOther不属于Ignore体系，因此它的自动注入不受影响。
我们换成ignoreDependencyType方法：

/**
 * beanFactory的后置处理器
 */
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
    //开启这段代码时，即使设置了byName或者byType自动注入并且满足条件
    //也不会调用Ignore接口及其实现类中的定义的setter方法进行自动注入
    //beanFactory.ignoreDependencyInterface(Ignore.class);
    //这样也行
    //beanFactory.ignoreDependencyInterface(IgnoreImpl.class);

    //忽略该类型及其子类作为参数的setter自动注入设置（byName或者byType），不能忽略constructor的自动注入。
    beanFactory.ignoreDependencyType(IgnoreImpl.PoJoA.class);
    beanFactory.ignoreDependencyType(IgnoreImpl.PoJoB.class);
}

继续测试，结果如下：

IgnoreImpl{poJoA=null, poJoB=null}
IgnoreImpl{poJoA=null, poJoB=null}
IgnoreImpl{poJoA=com.spring.source.ingoreInterface.IgnoreImpl$PoJoA@543c6f6d, poJoB=com.spring.source.ingoreInterface.IgnoreImpl$PoJoB@13eb8acf}
---------------
IgnoreOther{poJoA=null, poJoB=null}
IgnoreOther{poJoA=null, poJoB=null}
IgnoreOther{poJoA=com.spring.source.ingoreInterface.IgnoreImpl$PoJoA@543c6f6d, poJoB=com.spring.source.ingoreInterface.IgnoreImpl$PoJoB@13eb8acf}

可以发现IgnoreOther的setter自动注入也配忽略了。

1.2.2 ignoreDependencyInterface

beanFactory的ignoreDependencyInterface方法用于忽略该类型及其子类的相关方法的setter自动注入设置（byName或者byType），不能忽略constructor的自动注入。
测试类：

/**
 * @author lx
 */
public interface Ignore {

    void setPoJoA(IgnoreImpl.PoJoA poJoA);

    void setPoJoB(IgnoreImpl.PoJoB poJoB);
}

//--------------------------

/**
 * @author lx
 */
public class IgnoreImpl implements Ignore {

    private PoJoA poJoA;
    private PoJoB poJoB;

    @Override
    public void setPoJoA(PoJoA poJoA) {
        this.poJoA = poJoA;
    }
    @Override
    public void setPoJoB(PoJoB poJoB) {
        this.poJoB = poJoB;
    }

    public IgnoreImpl(PoJoA poJoA, PoJoB poJoB) {
        this.poJoA = poJoA;
        this.poJoB = poJoB;
    }

    public IgnoreImpl() {
    }

    @Override
    public String toString() {
        return "IgnoreImpl{" +
                "poJoA=" + poJoA +
                ", poJoB=" + poJoB +
                '}';
    }

    public static class PoJoA{

    }
    public static class PoJoB{

    }
}

自定义beanFactory的后置处理器（后面马上会讲）：

/**
 * 测试Ignore
 *
 * @author lx
 */
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {

    /**
     * beanFactory的后置处理器
     */
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        //开启这段代码时，即使设置了byName或者byType自动注入并且满足条件
        //也不会调用Ignore接口及其实现类中的定义的setter方法进行自动注入
        beanFactory.ignoreDependencyInterface(Ignore.class);
        //这样也行
        //beanFactory.ignoreDependencyInterface(IgnoreImpl.class);
    }
}

配置文件：


<bean class="com.spring.source.ingoreInterface.MyBeanFactoryPostProcessor" id="beanFactoryPostProcessor"/>


<bean class="com.spring.source.ingoreInterface.IgnoreImpl.PoJoA" id="poJoA"/>
<bean class="com.spring.source.ingoreInterface.IgnoreImpl.PoJoB" id="poJoB"/>

<bean class="com.spring.source.ingoreInterface.IgnoreImpl" id="ignoreByType" autowire="byType"/>
<bean class="com.spring.source.ingoreInterface.IgnoreImpl" id="ignoreByName" autowire="byName"/>
<bean class="com.spring.source.ingoreInterface.IgnoreImpl" id="ignoreByConstructor" autowire="constructor"/>

测试：

@Test
public void ignoreDependencyInterface() {
    ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("spring-config-test.xml");
    System.out.println(ac.getBean("ignoreByName"));
    System.out.println(ac.getBean("ignoreByType"));
    System.out.println(ac.getBean("ignoreByConstructor"));
}

结果如下：

IgnoreImpl{poJoA=null, poJoB=null}
IgnoreImpl{poJoA=null, poJoB=null}
IgnoreImpl{poJoA=com.spring.source.ingoreInterface.IgnoreImpl$PoJoA@4e718207, poJoB=com.spring.source.ingoreInterface.IgnoreImpl$PoJoB@1d371b2d}

当注释掉ignoreDependencyInterface代码时，结果如下：

IgnoreImpl{poJoA=com.spring.source.ingoreInterface.IgnoreImpl$PoJoA@1990a65e, poJoB=com.spring.source.ingoreInterface.IgnoreImpl$PoJoB@64485a47}
IgnoreImpl{poJoA=com.spring.source.ingoreInterface.IgnoreImpl$PoJoA@1990a65e, poJoB=com.spring.source.ingoreInterface.IgnoreImpl$PoJoB@64485a47}
IgnoreImpl{poJoA=com.spring.source.ingoreInterface.IgnoreImpl$PoJoA@1990a65e, poJoB=com.spring.source.ingoreInterface.IgnoreImpl$PoJoB@64485a47}

1.3 指定自动注入实例扩展点

当使用byType自动注入或者使用@Autowired注解自动注入时，如果同一个类型的bean在Spring中存在多个，由于Spring可能不知道使用那一个bean实例，因此可能会抛出异常。
beanFactory的registerResolvableDependency方法的主要作用就是在容器启动阶段指定某个类型及其某个实现，如果运行时外部要注入该类型的对象，并且无法找到最合适的依赖，则会注入我们指定的对象实例，指定的类型和对应的实例将被缓存在resolvableDependencies缓存中！
在后面的doCreateBean方法中我们会再次见到这个扩展点，到时后我们会讲解具体的匹配规则！

1.3.1 预定义的自动注入实例

在prepareBeanFactory中我们知道可以Spring预定义的注册了一批自动注入的对象直,包括BeanFactory、ResourceLoader、ApplicationEventPublisher、ApplicationContext这几个类型。首先我们来测试预定义的自动注入实例：

public class AutoRegister {
    private BeanFactory beanFactory;
    private ResourceLoader resourceLoader;
    private ApplicationEventPublisher applicationEventPublisher;
    private ApplicationContext applicationContext;

    public void setBeanFactory(BeanFactory beanFactory) {
        this.beanFactory = beanFactory;
    }

    public void setResourceLoader(ResourceLoader resourceLoader) {
        this.resourceLoader = resourceLoader;
    }

    public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
        this.applicationEventPublisher = applicationEventPublisher;
    }

    public void setApplicationContext(ApplicationContext applicationContext) {
        this.applicationContext = applicationContext;
    }

    @Override
    public String toString() {
        return "AutoRegister{" +
                "beanFactory=" + beanFactory +
                ", resourceLoader=" + resourceLoader +
                ", applicationEventPublisher=" + applicationEventPublisher +
                ", applicationContext=" + applicationContext +
                '}';
    }
}

配置，注意自动注入类型需要选择byType：


<bean class="com.spring.source.registerResolvable.AutoRegister" id="autoRegister" autowire="byType"/>

测试：

@Test
public void registerResolvable() {
    ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("spring-config-test.xml");
    System.out.println(ac.getBean("autoRegister"));
}

结果如下，成功的注入了值，虽然我们并没有将这几个对象实例亲自交给IoC容器，但还是从容器中成功获取到了对象，这实际上就是Spring在这一步帮我们做的。

AutoRegister{beanFactory=org.springframework.beans.factory.support.DefaultListableBeanFactory@55d56113: defining beans [autoRegister,myRDBeanFactoryPostProcessor,rdImplA,rdImplB,rd]; root of factory hierarchy, 
resourceLoader=org.springframework.context.support.ClassPathXmlApplicationContext@2a098129, started on Sun Sep 27 14:40:34 CST 2020, 
applicationEventPublisher=org.springframework.context.support.ClassPathXmlApplicationContext@2a098129, started on Sun Sep 27 14:40:34 CST 2020, 
applicationContext=org.springframework.context.support.ClassPathXmlApplicationContext@2a098129, started on Sun Sep 27 14:40:34 CST 2020}

1.3.2 自定义的自动注入实例

想要自定义自动注入实例，很简单，同样只需要实现BeanFactoryPostProcessor接口重写postProcessBeanFactory方法就行了。

测试类：

public interface ResolvableDependency {}

//------------------

public class RDImpl {

    /**
     * 尝试自动注入该属性
     */
    private ResolvableDependency resolvableDependency;

    public void setResolvableDependency(ResolvableDependency resolvableDependency) {
        this.resolvableDependency = resolvableDependency;
    }

    @Override
    public String toString() {
        return "RDImpl{" +
                "resolvableDependency=" + resolvableDependency +
                '}';
    }

    public static class RDImplA implements ResolvableDependency {}


    public static class RDImplB implements ResolvableDependency {}
}

自定义beanFactory后置处理器：

/**
 * 测试ResolvableDependency
 *
 * @author lx
 */
public class MyRDBeanFactoryPostProcessor implements BeanFactoryPostProcessor {

    /**
     * beanFactory的后置处理器
     */
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        RDImpl.RDImplA rdImplA= new RDImpl.RDImplA();
        System.out.println(rdImplA);
        beanFactory.registerResolvableDependency(ResolvableDependency.class,rdImplA);
    }
}

配置文件：


<bean class="com.spring.source.registerResolvable.MyRDBeanFactoryPostProcessor" id="myRDBeanFactoryPostProcessor"/>

<bean class="com.spring.source.registerResolvable.RDImpl.RDImplA" id="rdImplA"/>
<bean class="com.spring.source.registerResolvable.RDImpl.RDImplB" id="rdImplB"/>
<bean class="com.spring.source.registerResolvable.RDImpl" id="rd" autowire="byType"/>

测试：

@Test
public void myRegisterResolvable() {
    ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("spring-config-test.xml");

    System.out.println(ac.getBean("rd"));
    System.out.println(ac.getBean("rdImplA"));
    System.out.println(ac.getBean("rdImplB"));
}

结果如下，成功的自动注入，并且注入的是我们指定的对象：

com.spring.source.registerResolvable.RDImpl$RDImplA@4f063c0a
RDImpl{resolvableDependency=com.spring.source.registerResolvable.RDImpl$RDImplA@4f063c0a}
com.spring.source.registerResolvable.RDImpl$RDImplA@1d371b2d
com.spring.source.registerResolvable.RDImpl$RDImplB@543c6f6d

如果去掉registerResolvableDependency的代码，那么就是熟悉的异常了，因为有两个同类型的依赖并且无法选择最合适的一个：

expected single matching bean but found 2: rdImplA,rdImplB

当然，这个扩展点现在很少被使用，因为有其他很多方法能够指定使用某个实例，比如primary属性、autowire-candidate属性或者其他注解，比如@Qualifier！

1.4 手动注册单例bean扩展点

在prepareBeanFactory方法中，会手动注册三个单例bean的实例：environment、systemProperties、systemEnvironment，主要是将它们的实例注册到DefaultSingletonBeanRegistry注册表的缓存中，而这个注册表专门用于管理单例bean实例的缓存。
我们自己也能调用这个方法注册单例bean，手动注册的单例bean不受其他回调方法的影响。

/**
 * DefaultListableBeanFactory的方法
 * 
 * 手动注册bean及其实例
 *
 * @param beanName        beanName
 * @param singletonObject 单例的bean实例
 */
@Override
public void registerSingleton(String beanName, Object singletonObject) throws IllegalStateException {
    //调用父类的方法DefaultSingletonBeanRegistry注册到父类的相应的bean实例缓存中
    super.registerSingleton(beanName, singletonObject);
    //更新DefaultListableBeanFactory工厂内部的手动注册的单例bean的名字缓存manualSingletonNames
    //如果不包含给定beanName，那么添加beanName
    updateManualSingletonNames(set -> set.add(beanName), set -> !this.beanDefinitionMap.containsKey(beanName));
    //删除有关按类型映射的任何缓存，即清空allBeanNamesByType和singletonBeanNamesByType属性集合
    clearByTypeCache();
}


//-------父类DefaultSingletonBeanRegistry的一些属性------


/**
 * bean name 到 bean instance 的单例bean的缓存map(单例bean)
 */
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);


/**
 * bean name 到 ObjectFactory 的单例bean的缓存map(单例工厂)
 */
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);

/**
 * bean name 到 bean instance 的早期单例bean的缓存map(早期单例bean)
 * 用于解决循环依赖
 */
private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);

/**
 * 已注册的单例实例按注册顺序设置的beanName。
 */
private final Set<String> registeredSingletons = new LinkedHashSet<>(256);

/**
 * 父类DefaultSingletonBeanRegistry的方法
 *
 * @param beanName        beanName
 * @param singletonObject 单例的bean实例
 */
@Override
public void registerSingleton(String beanName, Object singletonObject) throws IllegalStateException {
    //非空断言，不符合就抛出异常
    Assert.notNull(beanName, "Bean name must not be null");
    Assert.notNull(singletonObject, "Singleton object must not be null");
    //加锁
    synchronized (this.singletonObjects) {
        //从缓存中获取尝试获取该名字单例bean实例
        Object oldObject = this.singletonObjects.get(beanName);
        //如果不为null，说明重复注册，抛出异常
        if (oldObject != null) {
            throw new IllegalStateException("Could not register object [" + singletonObject +
                    "] under bean name '" + beanName + "': there is already object [" + oldObject + "] bound");
        }
        //注册
        addSingleton(beanName, singletonObject);
    }
}


/**
 * 父类DefaultSingletonBeanRegistry的方法
 * 
 * 将给定的单例对象添加到此工厂的单例缓存中。
 *
 * @param beanName        beanName
 * @param singletonObject 单例对象
 */
protected void addSingleton(String beanName, Object singletonObject) {
    //加锁
    synchronized (this.singletonObjects) {
        //注册到singletonObjects缓存
        this.singletonObjects.put(beanName, singletonObject);
        //上面的缓存中注册了，那么其他单例缓存中就不应该出现
        //singletonFactories和earlySingletonObjects移除
        this.singletonFactories.remove(beanName);
        this.earlySingletonObjects.remove(beanName);
        //注册到beanName缓存
        this.registeredSingletons.add(beanName);
    }
}

2 postProcessBeanFactory扩展BeanFactory

prepareBeanFactory方法是对BeanFactory的一些默认配置，prepareBeanFactory方法执行完毕之后，此时所有 bean 定义都已被加载，但尚未实例化任何 bean。
此时将继续执行postProcessBeanFactory方法。postProcessBeanFactory方法默认是一个空的实现，这是留给BeanFactory的自定义子类实现的方法，用于对于BeanFactory做出自定义的修改，比如前面将的注册一些BeanPostProcessors、忽略setter自动注入扩展点、指定自动注入实例等等功能。
后面我们会讲到BeanFactoryPostProcessor扩展接口，它具有同样的功能，并且更加灵活，因此这里的这个扩展点很少被使用的（因为这需要自定义容器的子类）。

/**
 * AbstractApplicationContext的方法
 * 
 * 在应用程序上下文的标准初始化后用于修改其内部的 beanFactory。
 * 所有 bean 定义都将已加载，但尚未实例化任何 bean。这允许在某些应用程序上下文实现中注册特殊的 BeanPost 处理器等。
 *
 * @param beanFactory 当前应用程序上下文使用的 bean 工厂
 */
protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
    //空实现
}

如果子类容器要定义自己的BeanFactory逻辑，那么重写该方法就行了：

/**
 * @author lx
 */
public class MyPostProcessClassPathXmlApplicationContext extends ClassPathXmlApplicationContext {
    public MyPostProcessClassPathXmlApplicationContext(String... s) {
        super(s);
    }


    /**
     * 重写该方法就行了
     *
     * @param beanFactory postProcess
     */
    @Override
    protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        super.postProcessBeanFactory(beanFactory);
        //---------自己的逻辑------------
    }
}

3 invokeBeanFactoryPostProcessors回调BeanFactoryPostProcessor

3.1 BeanFactoryPostProcessor扩展点

BeanFactoryPostProcessor同样作为Spring对外提供的最重要的扩展点之一。它的postProcessBeanFactory回调方法用于在应用程序上下文的标准初始化后修改其内部 bean 工厂。此时所有 bean 定义都将已加载，但尚未实例化任何 bean。也就是说，这允许我们重写beandefinition或添加beandefinition，修改beanFactory中的beandefinition的任何可以修改的地方。
而前面学习的BeanPostProcessor扩展接口则用于管理已经被实例化之后的bean实例。因此，BeanFactoryPostProcessor的回调比BeanPostProcessor要早。它属于一个比较早期的扩展点。

@FunctionalInterface
public interface BeanFactoryPostProcessor {

    /**
     * 在应用程序上下文的标准初始化后修改其内部 bean 工厂。所有 bean 定义都将已加载，但尚未实例化任何 bean。
     * 这允许重写或添加属性，修改 bean 定义任何可以修改的地方。
     *
     * @param beanFactory 应用程序上下文容器使用的bean工厂
     */
    void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;

}

3.2 BeanDefinitionRegistryPostProcessor扩展点

BeanDefinitionRegistryPostProcessor继承了BeanFactoryPostProcessor，同时具有自己的新方法。BeanDefinitionRegistryPostProcessor的回调比BeanFactoryPostProcessor还要早。
它的postProcessBeanDefinitionRegistry回调方法用于在应用程序上下文的标准初始化后修改其内部 bean 定义注册表。此时所有常规 bean 定义都将已加载，但尚未实例化任何 bean。也就是说，这允许我们在下一个BeanFactoryPostProcessor后处理阶段开始之前添加更多的 bean 定义。
BeanDefinitionRegistryPostProcessor后处理器用于我们自定义的添加更多的beandefinition。它非常的有用，比如dubbo自己的service扫描，就是用了一个ServiceAnnotationBeanPostProcessor后处理器，将指定路径下具有Dubbo的@service注解的类添加到bean定义中，又比如mybatis的basePackage扫描，就是使用MapperScannerConfigurer后处理器，将指定目录下的mapper接口添加到bean定义中。
最著名的ConfigurationClassPostProcessor后处理器也是该类型的实现，它的postProcessBeanDefinitionRegistry用于解析配置类以及各种配置注解@Configuration 、@Component、@ComponentScan、@Import、@ImportResource……，@Bean注解也是在这里解析的，解析的bean定义会被注册到注册表中！

public interface BeanDefinitionRegistryPostProcessor extends 
BeanFactoryPostProcessor {

    /**
     * 在应用程序上下文的标准初始化后修改其内部 bean 定义注册表。所有常规 bean 定义都将已加载，但尚未实例化任何 bean。
     * 这允许在下一个后处理阶段开始之前添加更多的 bean 定义。
     *
     * @param registry 应用程序上下文容器使用的 bean 定义注册表
     * @throws org.springframework.beans.BeansException in case of errors
     */
    void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException;

}

3.3 invokeBeanFactoryPostProcessors回调BeanFactoryPostProcessor

invokeBeanFactoryPostProcessors方法就是用于实例化并调用所有注册的BeanDefinitionRegistryPostProcessor和BeanFactoryPostProcessor，如果给出显式顺序，则遵守显式顺序。内部的postProcessBeanDefinitionRegistry方法和postProcessBeanFactory方法必须在普通单例bean实例化之前调用。
由于此时bean还没有开始实例化，因此在扩展的BeanDefinitionRegistryPostProcessor和BeanFactoryPostProcessor中不应该调用实例bean的相关方法或者那些会触发bean实例化的方法。
invokeBeanFactoryPostProcessors方法的内部实际上主要调用代理类PostProcessorRegistrationDelegate的静态方法invokeBeanFactoryPostProcessors，传入beanFactory 以及上下文容器中的beanFactoryPostProcessors集合来完成回调BeanFactory后处理器的功能的。

/**
 * AbstractApplicationContext的方法
 * 
 * 实例化并调用所有注册的BeanDefinitionRegistryPostProcessor和BeanFactoryPostProcessor
 * 具有先后顺序，如果给出显式顺序，则遵守显式顺序。
 */
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
    /*
     * 调用代理类PostProcessorRegistrationDelegate的静态方法invokeBeanFactoryPostProcessors
     * 传入beanFactory 以及 上下文容器中的beanFactoryPostProcessors集合
     */
    PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());

    // 检测LoadTimeWeaver，并为织入做准备
    if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
        beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
        beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
    }
}

3.3.1 getBeanFactoryPostProcessors获取上下文中的beanFactoryPostProcessors

beanFactoryPostProcessors是一个集合，当我们自己调用上下文容器的addBeanFactoryPostProcessor方法手动注册beanFactoryPostProcessor时，添加的beanFactoryPostProcessor就被放入该集合中。我们也可以通过bean定义的方法注册BeanFactoryPostProcessor。这是两个不同的数据来源！
在后续回调方法被调用的时候，beanFactoryPostProcessors集合中的beanFactoryPostProcessor的相关方法将会被最先回调。

/**
 * AbstractApplicationContext的beanFactoryPostProcessors集合
 * 
 * 当调用上下文容器的addBeanFactoryPostProcessor方法手动注册beanFactoryPostProcessor时
 * 添加的BeanFactoryPostProcessor就放入该集合中
 */
private final List<BeanFactoryPostProcessor> beanFactoryPostProcessors = new ArrayList<>();

/**
 1. AbstractApplicationContext的方法
 2. 
 3. 从上下文容器中返回beanFactoryPostProcessors。
 */
public List<BeanFactoryPostProcessor> getBeanFactoryPostProcessors() {
    return this.beanFactoryPostProcessors;
}

通常情况下，beanFactoryPostProcessors是一个空集合，那么这个addBeanFactoryPostProcessor方法我们自己如何调用呢？
基于非web和web容器都有自己的调用方式，Spring Boot也有自己的调用方式。这里我们就讲非web容器的调用方式。
在最开始我们讲过一个扩展方法initPropertySources，在那个方法中就可以调用addBeanFactoryPostProcessor方法添加我们自定义的beanFactoryPostProcessor到beanFactoryPostProcessors集合中，而在上面的prepareBeanFactory扩展方法中也能调用addBeanFactoryPostProcessor方法。不过通常我们自定义的beanFactoryPostProcessor也是通过bean定义的方式加载的。

3.3.2 invokeBeanFactoryPostProcessors回调BeanFactoryPostProcessor

BeanFactoryPostProcessor有两个总的来源，一个是通过普通bean定义的方式注册到beanFactory的缓存中，在回调时会将它们筛选出来并且进行初始化；另一个就是通过调用上下文容器的addBeanFactoryPostProcessor方法手动注册的beanFactoryPostProcessor实例，它们被放入AbstractApplicationContext的beanFactoryPostProcessors集合中。
invokeBeanFactoryPostProcessors方法对于上面两个来源的beanFactoryPostProcessor的回调是有先后顺序的，回调顺序如下：

对于beanFactoryPostProcessors集合中的BeanDefinitionRegistryPostProcessor类型的对象，按照集合元素的遍历顺序从前向后回调postProcessBeanDefinitionRegistry方法（并没有排序）。
对于beanFactory中实现了PriorityOrdered接口的BeanDefinitionRegistryPostProcessor类型的bean定义进行实例化，并且进行排序，随后按照排序顺序从前向后回调postProcessBeanDefinitionRegistry方法。
对于beanFactory中实现了Ordered接口的BeanDefinitionRegistryPostProcessor类型的bean定义进行实例化（排除上一步已回调过的处理器），并且进行排序，随后按照排序顺序从前向后回调postProcessBeanDefinitionRegistry方法。
对于beanFactory中，所有剩余的普通的BeanDefinitionRegistryPostProcessor类型的bean定义进行实例化，随后对这一批BeanDefinitionRegistryPostProcessor实例进行排序，最后按照排序顺序从前向后回调postProcessBeanDefinitionRegistry方法
1. 这一步将会一直循环重试，直到beanFactory的bean定义缓存中不再出现新的BeanDefinitionRegistryPostProcessors，因为在上面执行的postProcessBeanDefinitionRegistry回调方法中可能又新增了BeanDefinitionRegistryPostProcessor类型的bean定义。因此它们不一定没有实现Ordered或者PriorityOrdered接口，所以这里的排序也还是有必要的。
对于beanFactoryPostProcessors集合和beanFactory中的全部BeanDefinitionRegistryPostProcessor实例从前向后回调postProcessBeanFactory方法。
对于beanFactoryPostProcessors集合中的全部BeanFactoryPostProcessor实例从前向后回调postProcessBeanFactory方法。
1. 到这一步，还剩下beanFactory中的全部BeanFactoryPostProcessor还没有完成postProcessBeanFactory方法的回调，下面的步骤就是完成这个工作。
对于beanFactory中，所有实现了PriorityOrdered接口的BeanFactoryPostProcessor类型的bean定义进行实例化，并且进行排序，随后按照排序顺序从前向后回调postProcessBeanFactory方法。
对于beanFactory中，所有实现了Ordered接口的BeanFactoryPostProcessor类型的bean定义进行实例化并且进行排序（排除上一步已回调过的处理器），随后按照排序顺序从前向后回调postProcessBeanFactory方法。
最后，对于beanFactory中，普通的BeanFactoryPostProcessor类型的bean定义进行实例化。不需要进行排序了，因为没有实现Ordered接口和PriorityOrdered接口，随后按照遍历顺序从前向后回调postProcessBeanFactory方法。

流程图如下：

源码解析如下，代码比较多，一定要分块解析。关于排序的规则，在sortPostProcessors源码解析部分。

/** * PostProcessorRegistrationDelegate的方法 *

* 实例化并调用所有注册的BeanFactoryPostProcessor（包括BeanDefinitionRegistryPostProcessor），如果给出显式顺序，则遵守显式顺序。 * * @param beanFactory bean工厂，BeanFactoryPostProcessor的来源之一，通过bean定义 * @param beanFactoryPostProcessors 上下文容器中的beanFactoryPostProcessors集合，BeanFactoryPostProcessor的来源之二，通过手动注册 */ public static void invokeBeanFactoryPostProcessors( ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) { //要执行回调方法和已执行回调方法的beanName集合，用于防止重复回调 Set<String> processedBeans = new HashSet<>(); /*beanFactory是否属于BeanDefinitionRegistry，一般都是，所有都会走这一个逻辑*/ if (beanFactory instanceof BeanDefinitionRegistry) { //beanFactory强转为BeanDefinitionRegistry类型 BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory; //这个集合保存BeanFactoryPostProcessor类型的后置处理器实例（用于最后执行postProcessBeanFactory回调方法） List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>(); //这个集合保存BeanDefinitionRegistryPostProcessor类型的后置处理器实例（用于最后执行postProcessBeanFactory回调方法） List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>(); /* * 1 首先遍历、处理beanFactoryPostProcessors集合 * 对于BeanDefinitionRegistryPostProcessor类型的对象回调postProcessBeanDefinitionRegistry方法 * 并加入registryProcessors集合中，非这个类型的BeanFactoryPostProcessor加入regularPostProcessors集合中 */ for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) { /*1.1 如果属于BeanDefinitionRegistryPostProcessor类型*/ if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) { //postProcessor强转为BeanDefinitionRegistryPostProcessor类型 BeanDefinitionRegistryPostProcessor registryProcessor = (BeanDefinitionRegistryPostProcessor) postProcessor; /*1.1.1 按照遍历顺序，回调postProcessBeanDefinitionRegistry方法*/ registryProcessor.postProcessBeanDefinitionRegistry(registry); //1.1.2 加入到registryProcessors集合中(用于最后执行postProcessBeanFactory回调方法) registryProcessors.add(registryProcessor); } /*1.2 如果不属于BeanDefinitionRegistryPostProcessor类型*/ else { //1.2.1 加入到regularPostProcessors集合中 regularPostProcessors.add(postProcessor); } } //这个集合临时保存当前准备创建并执行回调的BeanDefinitionRegistryPostProcessor类型的后置处理器实例，毁掉完毕即清理 List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>(); /* * 2 对于beanFactory中，所有实现了PriorityOrdered接口的BeanDefinitionRegistryPostProcessor类型的bean定义进行实例化 * 随后对这一批BeanDefinitionRegistryPostProcessor实例进行排序，最后按照排序顺序从前向后回调postProcessBeanDefinitionRegistry方法 */ // 从beanFactory中获取所有BeanDefinitionRegistryPostProcessor类型的bean定义的名称数组 String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false); //遍历beanFactory中的BeanDefinitionRegistryPostProcessor类型的bean定义的名称数组 for (String ppName : postProcessorNames) { //如果该名称的bean定义还实现了PriorityOrdered接口 if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) { //当前beanName的BeanDefinitionRegistryPostProcessor实例加入到currentRegistryProcessors集合 //这个getBean方法实际上已经将bean实例创建出来了 currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class)); //加入到processedBeans集合 processedBeans.add(ppName); } } //到这一步currentRegistryProcessors集合的元素都是实现了PriorityOrdered接口的类型实例 //这里对currentRegistryProcessors集合的元素根据Ordered顺序进行排序 sortPostProcessors(currentRegistryProcessors, beanFactory); //currentRegistryProcessors整体加入到registryProcessors集合中(用于最后执行postProcessBeanFactory回调方法) registryProcessors.addAll(currentRegistryProcessors); //对于currentRegistryProcessors集合中的已排序的BeanDefinitionRegistryPostProcessor按照顺序从前向后回调postProcessBeanDefinitionRegistry方法 invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry); //回调完毕之后清空currentRegistryProcessors集合 currentRegistryProcessors.clear(); /* * 3 对于beanFactory中，所有实现了Ordered接口的BeanDefinitionRegistryPostProcessor类型的bean定义进行实例化（排除上一步调用过的处理器） * 随后对这一批BeanDefinitionRegistryPostProcessor实例进行排序，最后按照排序顺序从前向后回调postProcessBeanDefinitionRegistry方法 */ //重新从beanFactory中获取所有BeanDefinitionRegistryPostProcessor类型的bean定义的名称数组 //因为此时可能有新增的BeanDefinitionRegistryPostProcessor定义，比如在上面执行的回调方法中又新增了BeanDefinitionRegistryPostProcessor定义 postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false); //遍历beanFactory中的BeanDefinitionRegistryPostProcessor类型的bean定义的名称数组 for (String ppName : postProcessorNames) { //如果processedBeans集合不包含该名称（防止重复回调），并且该名称的bean定义还实现了PriorityOrdered接口 if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) { //当前beanName的BeanDefinitionRegistryPostProcessor实例加入到currentRegistryProcessors集合 //这个getBean方法实际上已经将bean实例创建出来了 currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class)); //加入到processedBeans集合 processedBeans.add(ppName); } } //到这一步currentRegistryProcessors集合的元素都是实现了Ordered接口的类型实例 //这里对currentRegistryProcessors集合的元素根据Ordered顺序进行排序 sortPostProcessors(currentRegistryProcessors, beanFactory); //currentRegistryProcessors整体加入到registryProcessors集合中(用于最后执行postProcessBeanFactory回调方法) registryProcessors.addAll(currentRegistryProcessors); //对于currentRegistryProcessors集合中的已排序的BeanDefinitionRegistryPostProcessor按照顺序从前向后回调postProcessBeanDefinitionRegistry方法 invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry); //回调完毕之后清空currentRegistryProcessors集合 currentRegistryProcessors.clear(); /* * 4 对于beanFactory中，所有剩余的普通的BeanDefinitionRegistryPostProcessor类型的bean定义进行实例化 * 随后对这一批BeanDefinitionRegistryPostProcessor实例进行排序，最后按照排序顺序从前向后回调postProcessBeanDefinitionRegistry方法 * * 这一步将会一直循环重试，直到bean定义中不再出现新的BeanDefinitionRegistryPostProcessors， * 因为在上面执行的postProcessBeanDefinitionRegistry回调方法中可能又新增了BeanDefinitionRegistryPostProcessor类型的bean定义 */ //重试标志 boolean reiterate = true; while (reiterate) { //重试标志改为false reiterate = false; //重新从beanFactory中获取所有BeanDefinitionRegistryPostProcessor类型的bean定义的名称数组 //因为此时可能有新增的BeanDefinitionRegistryPostProcessor定义，比如在上面执行的回调方法中又新增了BeanDefinitionRegistryPostProcessor定义 postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false); //遍历beanFactory中的BeanDefinitionRegistryPostProcessor类型的bean定义的名称数组 for (String ppName : postProcessorNames) { //如果processedBeans集合不包含该名称（防止重复回调） if (!processedBeans.contains(ppName)) { //当前beanName的BeanDefinitionRegistryPostProcessor实例加入到currentRegistryProcessors集合 //这个getBean方法实际上已经将bean实例创建出来了 currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class)); //加入到processedBeans集合 processedBeans.add(ppName); //重试标志改为true，这表示将会重试 //因为上面的有新加入的BeanDefinitionRegistryPostProcessor定义，而调用它们的回调方法时，可能在回调方法中又新增了BeanDefinitionRegistryPostProcessor定义 //因此，只要如果processedBeans集合不包含某些beanName，那么就会进入下一次回调 reiterate = true; } } //到这一步currentRegistryProcessors集合的元素都是剩下的实例，它们即没有实现Ordered接口也没有实现PriorityOrdered接口 //或者是在回调方法中新增的BeanDefinitionRegistryPostProcessor定义（它们有可能实现Ordered接口或者PriorityOrdered接口），因此还是需要排序 //这里对currentRegistryProcessors集合的元素根据Ordered顺序进行排序 sortPostProcessors(currentRegistryProcessors, beanFactory); //currentRegistryProcessors整体加入到registryProcessors集合中(用于最后执行postProcessBeanFactory回调方法) registryProcessors.addAll(currentRegistryProcessors); //对于currentRegistryProcessors集合中的已排序的BeanDefinitionRegistryPostProcessor按照顺序从前向后回调postProcessBeanDefinitionRegistry方法 invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry); //回调完毕之后清空currentRegistryProcessors集合 currentRegistryProcessors.clear(); } //到这一步，出了循环，所有的BeanDefinitionRegistryPostProcessor类型的bean定义已被实例化完毕 //并且它们的postProcessBeanDefinitionRegistry方法已完成回调 /* * 此时registryProcessors集合中包含beanFactoryPostProcessors和beanFactory中的全部BeanDefinitionRegistryPostProcessor * 此时regularPostProcessors集合中包含beanFactoryPostProcessors中的全部BeanFactoryPostProcessor * * 5 最后，对于registryProcessors中的全部BeanDefinitionRegistryPostProcessor从前向后回调postProcessBeanFactory方法 * 对于regularPostProcessors中的全部BeanFactoryPostProcessor从前向后回调postProcessBeanFactory方法 */ invokeBeanFactoryPostProcessors(registryProcessors, beanFactory); invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory); } /*否则，直接对于beanFactoryPostProcessors集合中的全部实例从前向后回调postProcessBeanFactory方法*/ else { // Invoke factory processors registered with the context instance. invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory); } /* * 到这一步，beanFactoryPostProcessors和beanFactory中的全部BeanDefinitionRegistryPostProcessor已完成postProcessBeanDefinitionRegistry方法和postProcessBeanFactory方法的回调 * 到这一步，beanFactoryPostProcessors中的全部BeanFactoryPostProcessor已完成postProcessBeanFactory方法的回调 * * 到这一步，还剩下beanFactory中的全部BeanFactoryPostProcessor还没有完成postProcessBeanFactory方法的回调，下面的代码就是完成这个工作 */ // 从beanFactory中获取所有BeanFactoryPostProcessor类型的bean定义的名称数组 String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false); // Separate between BeanFactoryPostProcessors that implement PriorityOrdered, // Ordered, and the rest. //这个集合保存实现了PriorityOrdered接口的BeanFactoryPostProcessor实例 List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>(); //这个集合保存实现了Ordered接口的BeanFactoryPostProcessor的beanName List<String> orderedPostProcessorNames = new ArrayList<>(); //这个集合保存普通的BeanFactoryPostProcessor的beanName List<String> nonOrderedPostProcessorNames = new ArrayList<>(); //遍历postProcessorNames数组，填充数据 for (String ppName : postProcessorNames) { /*如果processedBeans集合包含该名称*/ if (processedBeans.contains(ppName)) { //什么都不做，防止重复回调 // skip - already processed in first phase above } /*否则，如果该名称的bean定义还实现了PriorityOrdered接口*/ else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) { //当前beanName的BeanFactoryPostProcessor实例加入到priorityOrderedPostProcessors集合 //这个getBean方法实际上已经将bean实例创建出来了 priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class)); } /*否则，如果该名称的bean定义还实现了Ordered接口*/ else if (beanFactory.isTypeMatch(ppName, Ordered.class)) { //当前beanName加入到orderedPostProcessorNames集合 orderedPostProcessorNames.add(ppName); } /*否则，当前beanName加入到nonOrderedPostProcessorNames集合*/ else { nonOrderedPostProcessorNames.add(ppName); } } /* * 6 对于beanFactory中，所有实现了PriorityOrdered接口的BeanFactoryPostProcessor实例进行排序 * 随后按照排序顺序从前向后回调postProcessBeanFactory方法 */ // First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered. //这里对priorityOrderedPostProcessors集合的元素根据Ordered顺序进行排序 sortPostProcessors(priorityOrderedPostProcessors, beanFactory); //对于priorityOrderedPostProcessors集合中的已排序的BeanFactoryPostProcessor按照顺序从前向后回调postProcessBeanFactory方法 invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory); /* * 7 对于beanFactory中，所有实现了Ordered接口的BeanFactoryPostProcessor的bean定义进行实例化并且进行排序 * 随后按照排序顺序从前向后回调postProcessBeanFactory方法 */ // Next, invoke the BeanFactoryPostProcessors that implement Ordered. //这个集合保存实现了Ordered接口的BeanFactoryPostProcessor实例 List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size()); //遍历orderedPostProcessorNames数组，填充数据 for (String postProcessorName : orderedPostProcessorNames) { //当前beanName的BeanFactoryPostProcessor实例加入到priorityOrderedPostProcessors集合 //这个getBean方法实际上已经将bean实例创建出来了 orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class)); } //这里对orderedPostProcessors集合的元素根据Ordered顺序进行排序 sortPostProcessors(orderedPostProcessors, beanFactory); //对于orderedPostProcessors集合中的已排序的BeanFactoryPostProcessor按照顺序从前向后回调postProcessBeanFactory方法 invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory); /* * 8 最后，对于beanFactory中，普通的BeanFactoryPostProcessor的bean定义进行实例化 * 不需要进行排序了，因为没有实现Ordered接口和PriorityOrdered接口，随后按照遍历顺序从前向后回调postProcessBeanFactory方法 */ // Finally, invoke all other BeanFactoryPostProcessors. //这个集合保存普通的BeanFactoryPostProcessor实例 List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size()); //遍历nonOrderedPostProcessorNames数组，填充数据 for (String postProcessorName : nonOrderedPostProcessorNames) { //当前beanName的BeanFactoryPostProcessor实例加入到nonOrderedPostProcessors集合 //这个getBean方法实际上已经将bean实例创建出来了 nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class)); } //对于nonOrderedPostProcessors集合中的BeanFactoryPostProcessor按照顺序从前向后回调postProcessBeanFactory方法 invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory); /* * 9 清除元数据缓存（mergedBeanDefinitions、allBeanNamesByType、singletonBeanNamesByType）， * 因为后处理器可能修改了原始元数据，例如，替换值中的占位符... */ beanFactory.clearMetadataCache(); } /** * 调用给定的BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry回调方法 */ private static void invokeBeanDefinitionRegistryPostProcessors( Collection<? extends BeanDefinitionRegistryPostProcessor> postProcessors, BeanDefinitionRegistry registry) { //循环调用postProcessBeanDefinitionRegistry方法 for (BeanDefinitionRegistryPostProcessor postProcessor : postProcessors) { postProcessor.postProcessBeanDefinitionRegistry(registry); } } /** * 调用给定的BeanFactoryPostProcessor的postProcessBeanFactory回调方法 */ private static void invokeBeanFactoryPostProcessors( Collection<? extends BeanFactoryPostProcessor> postProcessors, ConfigurableListableBeanFactory beanFactory) { //循环调用postProcessBeanFactory方法 for (BeanFactoryPostProcessor postProcessor : postProcessors) { postProcessor.postProcessBeanFactory(beanFactory); } }

3.3.2.1 sortPostProcessors优先级排序

sortPostProcessors方法用于对后处理器进行排序。默认比较器为OrderComparator，但是如果开启了注解支持，那么默认设置为AnnotationAwareOrderComparator，前一篇文章的registerAnnotationConfigProcessors方法部分讲过了。AnnotationAwareOrderComparator比较器可以支持PriorityOrdered接口、Ordered接口、@Ordered注解、@Priority注解的排序，比较优先级为PriorityOrdered>Ordered>@Ordered>@Priority，这里学习的OrderComparator 比较器只支持PriorityOrdered、Ordered接口的排序，比较优先级为PriorityOrdered>Ordered。如果最终没找到设置的排序值，那么返回Integer.MAX_VALUE，即最低优先级。

/**
 1. PostProcessorRegistrationDelegate的方法
 2. 
 3. 对后处理器集合进行排序方法
 4.  5. @param postProcessors 需要排序的后处理器集合
 6. @param beanFactory    bean工厂
 */
private static void sortPostProcessors(List<?> postProcessors, ConfigurableListableBeanFactory beanFactory) {
    // Nothing to sort?
    if (postProcessors.size() <= 1) {
        return;
    }
    Comparator<Object> comparatorToUse = null;
    //如果beanFactory属于DefaultListableBeanFactory
    if (beanFactory instanceof DefaultListableBeanFactory) {
        //那么首先获取设置的比较器，默认为null
        //如果开启了注解支持那么默认设置为AnnotationAwareOrderComparator，前面的registerAnnotationConfigProcessors部分讲过了
        //AnnotationAwareOrderComparator具有支持@Order注解和@Priority注解的排序设置的功能
        comparatorToUse = ((DefaultListableBeanFactory) beanFactory).getDependencyComparator();
    }
    //如果设置的比较器为null
    if (comparatorToUse == null) {
        //那么默认使用OrderComparator比较器
        comparatorToUse = OrderComparator.INSTANCE;
    }
    //该集合使用比较器排序
    postProcessors.sort(comparatorToUse);
}

3.3.2.1.1 OrderComparator比较器

Ordered接口和PriorityOrdered接口都是用来指定元素的顺序的接口，PriorityOrdered接口继承了Order接口。
比如现在讲的BeanFactory后处理器，如果我们想要指定某些后处理器的回调方法执行的先后顺序，那么就可以让它们实现Ordered或者PriorityOrdered接口，并通过getOrder方法返回Order顺序值。除此之外，很多地方都可以进行排序，比如AOP中指定切面中通知的回调顺序，比如注入某个类型全部实例是指定集合元素的顺序，比如Bean后处理器的回调顺序。当然我们也可以直接使用@Order注解。
在Spring中，某种一类型的多个回调对象是存放在一个集合中的，在进行回调时，会按照集合顺序从前向后依次回调。在排序时，就是通过OrderComparator比较器来对集合元素进行排序的，因此我们只有知道具体的排序规则，才能实现我们想要的结果。
OrderComparator比较器实现了Comparator接口，比较排序规则为：

如果比较的二者中有一个实现了PriorityOrdered接口，那么实现了PriorityOrdered接口的对象排序在前；
如果比较的二者中都实现或者都没有实现PriorityOrdered接口，那么继续比较：
1. 分别获取二者的order顺序值。如果实现了Order接口，那么使用该对象的getOrder方法的返回值，否则order值使用Ordered.LOWEST_PRECEDENCE，即Integer.MAX_VALUE。
2. 比较二者的order顺序值，order值越小的对象，则排序越前；相同的order值的两个对象，排序顺序是不能保证的。

/**
 * OrderComparator比较器类，实现了Comparator接口
 * 
 * 用于对集合元素进行排序，PriorityOrdered接口继承了Ordered接口
 * 

 * 1 如果比较的二者中有一个实现了PriorityOrdered接口，那么实现了PriorityOrdered接口的对象排序在前
 * 2 如果比较的二者中都实现或者都没有实现PriorityOrdered接口，那么继续比较：
 * 3 分别获取两个对象的order顺序值。如果实现了Order接口，那么使用该对象的getOrder方法的返回值
 * 否则order值使用Ordered.LOWEST_PRECEDENCE，即Integer.MAX_VALUE
 * 4 order值越小的对象，则排序越前；相同的order值的两个对象，排序顺序是不能保证的
 */
public class OrderComparator implements Comparator<Object> {

    /**
     * 默认的共享的比较器实例
     * 单例模式
     */
    public static final OrderComparator INSTANCE = new OrderComparator();


    /**
     * 比较的方法，从小到大的排序
     *
     * @return 0 等于 负整数 小于  正整数 大于
     */
    @Override
    public int compare(@Nullable Object o1, @Nullable Object o2) {
        //sourceProvider参数为null
        return doCompare(o1, o2, null);
    }

    /**
     * 进行比较的方法
     */
    private int doCompare(@Nullable Object o1, @Nullable Object o2, @Nullable OrderSourceProvider sourceProvider) {
        //o1是否属于PriorityOrdered接口的实现
        boolean p1 = (o1 instanceof PriorityOrdered);
        //o2是否属于PriorityOrdered接口的实现
        boolean p2 = (o2 instanceof PriorityOrdered);
        /*如果o1是PriorityOrdered接口的实现，并且o2不是PriorityOrdered接口的实现*/
        if (p1 && !p2) {
            //那么返回-1，即o1在前o2在后
            return -1;
        }
        /*如果o2是PriorityOrdered接口的实现，并且o1不是PriorityOrdered接口的实现*/
        else if (p2 && !p1) {
            //那么返回1，即o1在后o2在前
            return 1;
        }
        //到这里还没有返回，可能是两者都属于或者都不属于PriorityOrdered接口的实现，那么需要进一步比较

        //获取o1的order顺序值，如果o1没有实现Ordered接口，那么返回Ordered.LOWEST_PRECEDENCE，即Integer.MAX_VALUE
        int i1 = getOrder(o1, sourceProvider);
        //获取o2的order顺序值，如果o2没有实现Ordered接口，那么返回Ordered.LOWEST_PRECEDENCE，即Integer.MAX_VALUE
        int i2 = getOrder(o2, sourceProvider);
        //返回二者的order顺序值的比较结果，order顺序值越小，那么在集合中的排序靠前
        return Integer.compare(i1, i2);
    }

    /**
     * 确定给定对象的order顺序值。
     * 使用getOrder方法的返回值进行比较
     *
     * @param obj 要检查的对象
     * @return 对象的order值，如果对象没有实现Ordered接口，那么返回Ordered.LOWEST_PRECEDENCE
     */
    private int getOrder(@Nullable Object obj, @Nullable OrderSourceProvider sourceProvider) {
        Integer order = null;
        //sourceProvider为null，不会进入if语句
        if (obj != null && sourceProvider != null) {
            Object orderSource = sourceProvider.getOrderSource(obj);
            if (orderSource != null) {
                if (orderSource.getClass().isArray()) {
                    Object[] sources = ObjectUtils.toObjectArray(orderSource);
                    for (Object source : sources) {
                        order = findOrder(source);
                        if (order != null) {
                            break;
                        }
                    }
                } else {
                    order = findOrder(orderSource);
                }
            }
        }
        //直接到这一步
        return (order != null ? order : getOrder(obj));
    }

    /**
     * 确定给定对象的order顺序值。
     *
     * @param obj 要检查的对象
     * @return 对象的order顺序值，如果对象没有实现Ordered接口，那么返回Ordered.LOWEST_PRECEDENCE
     */
    protected int getOrder(@Nullable Object obj) {
        //如果对象不为null
        if (obj != null) {
            //调用findOrder方法获取order顺序值
            Integer order = findOrder(obj);
            //如果结果不为null，那么返回获取到的结果
            if (order != null) {
                return order;
            }
        }
        //如果obj对象为null或者获取的order值为null
        //那么直接返回Ordered.LOWEST_PRECEDENCE，即Integer.MAX_VALUE
        return Ordered.LOWEST_PRECEDENCE;
    }

    /**
     * 查找给定对象指示的order顺序值。
     * 
     * 如果对象的类没有实现Ordered接口，那么返回null，否则返回getOrder方法的返回值
     *
     * @param obj the 要检查的对象
     * @return 对象的order顺序值，如果对象的类没有实现Ordered接口，那么返回null
     */
    @Nullable
    protected Integer findOrder(Object obj) {
        //如果对象的类没有实现Ordered接口，那么返回null，否则返回getOrder方法的返回值
        return (obj instanceof Ordered ? ((Ordered) obj).getOrder() : null);
    }
}

OrderComparator实际上还有一个子类AnnotationAwareOrderComparator，当我们配置了annotation-config开启了注解支持时，Spring就会使用AnnotationAwareOrderComparator来进行排序，AnnotationAwareOrderComparator可以支持PriorityOrdered接口、Ordered接口、@Ordered注解、@Priority注解的排序，比较优先级为PriorityOrdered>Ordered>@Ordered>@Priority，而OrderComparator只支持PriorityOrdered、Ordered接口的排序，比较优先级为PriorityOrdered>Ordered，如果最终没找到设置的排序值，那么返回Integer.MAX_VALUE，即最低优先级。@Priority注解属于javax.annotation-api的依赖。


<dependency>
    <groupId>javax.annotationgroupId>
    <artifactId>javax.annotation-apiartifactId>
    <version>1.3.2version>
dependency>

4 registerBeanPostProcessors注册BeanPostProcessor

我们此前就讲过，BeanPostProcessor同样作为Spring提供的扩展点。在bean实例化和依赖注入之后，在执行初始化方法前会调用所有BeanPostProcessor 的 postProcessBeforeInitialization 方法，执行初始化方法后会调用所有 BeanPostProcessor 的 postProcessAfterInitialization 方法。当然BeanPostProcessor还有很多不同的实现和扩展，它们的方法也在会在其他地方被回调。
这一步registerBeanPostProcessors方法的目的就是将所有的bean定义中BeanPostProcessor进行实例化和注册，如果给出显式顺序，则按照顺序注册，后续回调的时候也会按照顺序回调。注意这一步并不会回调BeanPostProcessor的方法。如果我们使用BeanFactory作为容器，就不能实现BeanPostProcessor的自动注册，这也是ApplicationContext容器的优点之一。
没有类似addBeanFactoryPostProcessor方法可供我们自定义注册BeanPostProcessor实例。这里的排序的原理和上面的invokeBeanFactoryPostProcessors方法是一样的。

/**
 * AbstractApplicationContext的方法
 * 
 * 实例化和注册所有的BeanPostProcessor，如果给出显式顺序，则按照顺序注册。
 * 必须在任何应用程序 bean 实例化之前调用
 */
protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
    //委托给PostProcessorRegistrationDelegate的静态方法registerBeanPostProcessors执行
    //传递beanFactory以及当前容器
    PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
}


/**
 * PostProcessorRegistrationDelegate的静态方法
 * 
 * 实例化和注册所有的BeanPostProcessor，如果给出显式顺序，则按照顺序注册。
 *
 * @param beanFactory        bean工厂
 * @param applicationContext 上下文容器
 */
public static void registerBeanPostProcessors(
        ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
    // 从beanFactory中获取所有BeanPostProcessor类型的bean定义的名称数组
    String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);


    //beanProcessor的目标计数器
    int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
    //注册一个BeanPostProcessorChecker处理器用
    //会在Bean创建完后检查可在当前Bean上起作用的BeanPostProcessor个数与总的BeanPostProcessor个数，如果起作用的个数少于总数，则输出日志信息。
    beanFactory.addBeanPostProcessor(new PostProcessorRegistrationDelegate.BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

    //这个集合保存实现了PriorityOrdered接口的BeanPostProcessor实例
    List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
    //这个集合保存Spring内部的BeanPostProcessor实例
    List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
    //这个集合保存实现了Ordered接口的BeanPostProcessor的beanName
    List<String> orderedPostProcessorNames = new ArrayList<>();
    //这个集合保存普通的BeanPostProcessor的beanName
    List<String> nonOrderedPostProcessorNames = new ArrayList<>();
    //遍历postProcessorNames数组
    for (String ppName : postProcessorNames) {
        /*如果该名称的bean定义还实现了PriorityOrdered接口，那么初始化*/
        if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
            //获取该名称的bean定义的实例，这一步创建了BeanPostProcessor实例
            BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
            //该实例加入到priorityOrderedPostProcessors集合
            priorityOrderedPostProcessors.add(pp);
            //如果该实例还实现了MergedBeanDefinitionPostProcessor接口
            if (pp instanceof MergedBeanDefinitionPostProcessor) {
                //该实例加入到internalPostProcessors集合
                internalPostProcessors.add(pp);
            }
        }
        /*否则，如果该名称的bean定义还实现了Ordered接口*/
        else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
            //beanName加入到orderedPostProcessorNames集合
            orderedPostProcessorNames.add(ppName);
        }
        /*否则，如果该名称的bean定义即没有实现PriorityOrdered接口也没有实现Ordered接口*/
        else {
            //beanName加入到nonOrderedPostProcessorNames集合
            nonOrderedPostProcessorNames.add(ppName);
        }
    }
    /*
     * 对实现了PriorityOrdered接口的BeanPostProcessor实例进行排序，随后按照排序顺序从前向后注册BeanPostProcessor实例
     */
    //这里对currentRegistryProcessors集合的元素根据Ordered顺序进行排序
    sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
    //注册给定的BeanPostProcessor
    registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);


    //这个集合保存实现了Ordered接口的BeanPostProcessor实例
    List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
    //遍历orderedPostProcessorNames数组
    for (String ppName : orderedPostProcessorNames) {
        //获取该名称的bean定义的实例，这一步创建了BeanPostProcessor实例
        BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
        //该实例加入到orderedPostProcessors集合
        orderedPostProcessors.add(pp);
        //如果该实例还实现了MergedBeanDefinitionPostProcessor接口
        if (pp instanceof MergedBeanDefinitionPostProcessor) {
            //该实例加入到internalPostProcessors集合
            internalPostProcessors.add(pp);
        }
    }

    /*
     * 对实现了Ordered接口的BeanPostProcessor实例进行排序，随后按照排序顺序从前向后注册BeanPostProcessor实例
     */
    //这里对orderedPostProcessors集合的元素根据Ordered顺序进行排序
    sortPostProcessors(orderedPostProcessors, beanFactory);
    //注册给定的BeanPostProcessor
    registerBeanPostProcessors(beanFactory, orderedPostProcessors);


    //这个集合保存普通的BeanPostProcessor实例
    List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
    //遍历nonOrderedPostProcessorNames数组
    for (String ppName : nonOrderedPostProcessorNames) {
        //获取该名称的bean定义的实例，这一步创建了BeanPostProcessor实例
        BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
        //该实例加入到nonOrderedPostProcessors集合
        nonOrderedPostProcessors.add(pp);
        //如果该实例还实现了MergedBeanDefinitionPostProcessor接口
        if (pp instanceof MergedBeanDefinitionPostProcessor) {
            //该实例加入到internalPostProcessors集合
            internalPostProcessors.add(pp);
        }
    }
    //注册给定的BeanPostProcessor，不需要排序
    registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);


    /*
     * 对实现了MergedBeanDefinitionPostProcessor接口的Spring内部的BeanPostProcessor实例进行排序，随后按照排序顺序从前向后注册BeanPostProcessor实例
     */
    //这里对internalPostProcessors集合的元素根据Ordered顺序进行排序
    sortPostProcessors(internalPostProcessors, beanFactory);
    //注册给定的BeanPostProcessor，相当于内部的BeanPostProcessor会被移动到处理器集合的尾部
    registerBeanPostProcessors(beanFactory, internalPostProcessors);

    /*
     * 重新注册ApplicationListenerDetector，会被移到处理器集合的末尾
     */
    beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}

4.1 registerBeanPostProcessors注册BeanPostProcessor

registerBeanPostProcessors方法用于将BeanPostProcessor实例按照排序顺序注册到容器中的对应的缓存中去，方便后续的回调操作。

/**
 * PostProcessorRegistrationDelegate的方法
 * 
 * 注册给定的BeanPostProcessor
 */
private static void registerBeanPostProcessors(
        ConfigurableListableBeanFactory beanFactory, List<BeanPostProcessor> postProcessors) {
    //循环调用addBeanPostProcessor方法
    for (BeanPostProcessor postProcessor : postProcessors) {
        beanFactory.addBeanPostProcessor(postProcessor);
    }
}

//------AbstractBeanFactory的相关属性

/**
 * BeanPostProcessor的缓存集合
 */
private final List<BeanPostProcessor> beanPostProcessors = new CopyOnWriteArrayList<>();

/**
 * 指示是否注册了任何InstantiationAwareBeanPostProcessors
 * 后面创建bean实例时会用到
 */
private volatile boolean hasInstantiationAwareBeanPostProcessors;

/**
 * 指示是否注册了任何DestructionAwareBeanPostProcessors
 * 后面创建bean实例时会用到
 */
private volatile boolean hasDestructionAwareBeanPostProcessors;

/**
 * AbstractBeanFactory的方法
 * 
 * 注册beanPostProcessor到AbstractBeanFactory内部的缓存中
 *
 * @param beanPostProcessor bean后处理器实例
 */
@Override
public void addBeanPostProcessor(BeanPostProcessor beanPostProcessor) {
    Assert.notNull(beanPostProcessor, "BeanPostProcessor must not be null");
    // 移除旧的beanPostProcessor（如果存在），主要是为了保证顺序
    this.beanPostProcessors.remove(beanPostProcessor);
    // Track whether it is instantiation/destruction aware
    //如果当前beanPostProcessor实例还实现了InstantiationAwareBeanPostProcessor接口
    if (beanPostProcessor instanceof InstantiationAwareBeanPostProcessor) {
        //那么hasInstantiationAwareBeanPostProcessors属性置为true
        this.hasInstantiationAwareBeanPostProcessors = true;
    }
    //如果当前beanPostProcessor实例还实现了DestructionAwareBeanPostProcessor接口
    if (beanPostProcessor instanceof DestructionAwareBeanPostProcessor) {
        //那么hasDestructionAwareBeanPostProcessors属性置为true
        this.hasDestructionAwareBeanPostProcessors = true;
    }
    //添加到beanPostProcessors集合缓存末尾
    this.beanPostProcessors.add(beanPostProcessor);
}

5 initMessageSource初始化MessageSource

initMessageSource用于初始化消息资源 MessageSource，用于语言国际化处理，如果没有配置自定义的MessageSource，那么默认使用DelegatingMessageSource实例。
国际化是什么意思？就是说如果我们需要开发一个支持多国语言的应用程序，要求系统能够根据客户端的系统的语言类型返回对应的界面，此时就需要用到i18n国际化操作，它可以根据不同地方的语言环境自动返回不同语言的页面。
一般来说用的本地公司比较少，可能对于有跨国业务的公司或者大公司来说这一项功能用的比较多，后续有时间有机会再单独讲解。

//-----AbstractApplicationContext的相关属性

/**
 * 
 * 硬编码的指定工厂中的MessageSource bean 的名称
 */
public static final String MESSAGE_SOURCE_BEAN_NAME = "messageSource";

/**
 * 消息源
 */
@Nullable
private MessageSource messageSource;

/**
 * 父上下文容器
 */
@Nullable
private ApplicationContext parent;

/**
 * AbstractApplicationContext的方法
 * 
 * 初始化消息资源 MessageSource，用于语言国际化处理
 * 如果没有配置自定义的MessageSource，那么默认使用DelegatingMessageSource实例
 */
protected void initMessageSource() {
    //获取beanFactory
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    //本地工厂(忽略父工厂)如果包含名为"messageSource"的bean定义
    if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
        //如果已经配置了messageSource的bean定义，那么将messageSource初始化并且赋给messageSource属性
        this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
        //如果父上下文容器不为null并且当前消息源实现了HierarchicalMessageSource接口，一般不会走到这一步，一般父容器都为null
        if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {
            HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;
            if (hms.getParentMessageSource() == null) {
                //那么设置当前消息源的父消息源
                hms.setParentMessageSource(getInternalParentMessageSource());
            }
        }
        if (logger.isTraceEnabled()) {
            logger.trace("Using MessageSource [" + this.messageSource + "]");
        }
    }
    /*否则，使用DelegatingMessageSource实例作为消息资源*/
    else {
        //新建一个DelegatingMessageSource实例
        DelegatingMessageSource dms = new DelegatingMessageSource();
        //设置当前消息源的父消息源
        dms.setParentMessageSource(getInternalParentMessageSource());
        //将messageSource实例赋给messageSource属性
        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 + "]");
        }
    }
}


/**
 * 如果父上下文也是抽象应用程序上下文(AbstractApplicationContext)，则返回其内部的消息源，否则，返回父上下文本身。
 */
@Nullable
protected MessageSource getInternalParentMessageSource() {
    return (getParent() instanceof AbstractApplicationContext ?
            ((AbstractApplicationContext) getParent()).messageSource : getParent());
}

6 initApplicationEventMulticaster初始化ApplicationEventMulticaster

initApplicationEventMulticaster用于初始化ApplicationEventMulticaster，即应用事件广播器。和MessageSource的初始化过程一样，如果用户自定义了应用事件广播器，那么使用用户自定义的，否则默认使用SimpleApplicationEventMulticaster作为应用事件广播器。
应用事件广播器的功能也很直白，就是进行ApplicationContext事件广播。当产生某一个ApplicationContext事件的时候，会将该事件委托广播器调用multicastEvent方法，就像一个广播一样通知广播器内部保存的所有监听器，遍历并对每一个监听器调用listener.onApplicationEvent方法传递该事件，而后续的事件处理则是由每一个监听器自己的内部逻辑决定的。

/*AbstractApplicationContext的属性*/

/**
 * 硬编码指定的beanFactory中的自定义ApplicationEventMulticaster 的beanName
 * 如果未提供自定义的广播器，则使用默认的SimpleApplicationEventMulticaster
 */
public static final String APPLICATION_EVENT_MULTICASTER_BEAN_NAME = "applicationEventMulticaster";

/**
 * 保存事件发布中使用的帮助器类
 */
@Nullable
private ApplicationEventMulticaster applicationEventMulticaster;


/**
 * AbstractApplicationContext的方法
 * 
 * 初始化应用程序事件广播器。 如果自己没有指定广播器，则使用SimpleApplicationEventMulticaster。
 */
protected void initApplicationEventMulticaster() {
    //获取beanFactory
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    /*
     * 本地工厂(忽略父工厂)，如果包含名为"applicationEventMulticaster"的bean定义
     */
    if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
        //那么将该beanName的bean定义作为ApplicationEventMulticaster类型尝试初始化并赋给applicationEventMulticaster属性
        this.applicationEventMulticaster =
                beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
        if (logger.isTraceEnabled()) {
            logger.trace("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
        }
    }
    /*
     * 否则，使用SimpleApplicationEventMulticaster实例作为广播器
     */
    else {
        //新建一个SimpleApplicationEventMulticaster实例，赋给applicationEventMulticaster属性
        this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
        //将初始化的广播器手动注册为一个名为"applicationEventMulticaster"的单例bean实例，因此我们在Spring管理的bean中也可以引入该对象
        beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
        if (logger.isTraceEnabled()) {
            logger.trace("No '" + APPLICATION_EVENT_MULTICASTER_BEAN_NAME + "' bean, using " +
                    "[" + this.applicationEventMulticaster.getClass().getSimpleName() + "]");
        }
    }
}

7 onRefresh扩展点

onRefresh方法默认是一个空的实现，这是留给子类容器实现的模版方法。子类容器可以重写用于添加特定的上下文的刷新工作，比如在普通单例bean实例化之前，进行特殊bean的初始化。非web应用中该方法没有实现，web应用中某些子类则会重写该方法。

/**
 * AbstractApplicationContext的方法
 * 子类容器可以重写用于添加特定的上下文的刷新工作的模版方法，比如在普通单例bean实例化之前，进行特殊bean的初始化。
 */
protected void onRefresh() throws BeansException {
    // 默认空实现
}

8 registerListeners注册Listener

registerListeners方法用于实例化并注册所有的Listener，即监听器。监听器的来源有两个：一个是调用addApplicationListener方法手动添加的listener，它们被添加到AbstractApplicationContext的applicationListeners集合中，另一个就是添加的ApplicationListener类型的普通bean定义，在registerListeners方法中会从beanFactory中找出所有的ApplicationListener类型的bean定义并初始化。
注册所有监听器之后会发布所有的早期的应用程序事件，非web应用默认没有早期事件。

/**
 * AbstractApplicationContext的方法
 * 
 * 实例化并注册监听器到应用事件广播器中，随后发布早期应用程序事件
 */
protected void registerListeners() {
    /*
     * 首先注册手动添加的监听器
     * 手动添加就是调用addApplicationListener方法添加的listener，它们被放入applicationListeners集合
     */
    for (ApplicationListener<?> listener : getApplicationListeners()) {
        //注册到ApplicationEventMulticaster中
        getApplicationEventMulticaster().addApplicationListener(listener);
    }

    /*
     * 随后将beanFactory中的所有ApplicationListener类型的bean定义初始化并注册
     */
    //从beanFactory中获取所有ApplicationListener类型的bean定义的名称数组
    String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
    //遍历listenerBeanNames数组
    for (String listenerBeanName : listenerBeanNames) {
        //注册到ApplicationEventMulticaster中
        getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
    }

    /*
     * 通过应用程序广播器对注册的监听器发布所有收集的早期应用程序事件
     * earlyApplicationEvents默认就是空集合
     */
    Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
    //earlyApplicationEvents置为null
    this.earlyApplicationEvents = null;
    if (!CollectionUtils.isEmpty(earlyEventsToProcess)) {
        for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
            //调用multicastEvent方法按照遍历顺序发布应用程序事件
            getApplicationEventMulticaster().multicastEvent(earlyEvent);
        }
    }
}

//--------AbstractApplicationContext的相关属性

/**
 * 调用addApplicationListener方法添加的listener监听器集合
 */
private final Set<ApplicationListener<?>> applicationListeners = new LinkedHashSet<>();


/**
 * 在广播器和监听器被设置之前发布的应用程序事件，被收集到该集合中
 */
@Nullable
private Set<ApplicationEvent> earlyApplicationEvents;

/**
 * 应用事件广播器，在前面的initApplicationEventMulticaster方法中已经初始化了
 */
@Nullable
private ApplicationEventMulticaster applicationEventMulticaster;


/**
 * AbstractApplicationContext的方法
 * 

 * 返回监听器集合
 */
public Collection<ApplicationListener<?>> getApplicationListeners() {
    return this.applicationListeners;
}

/**
 1. AbstractApplicationContext的方法
 2. 
 3. 返回上下文容器中使用的applicationEventMulticaster，不能为null
 */
ApplicationEventMulticaster getApplicationEventMulticaster() throws IllegalStateException {
    if (this.applicationEventMulticaster == null) {
        throw new IllegalStateException("ApplicationEventMulticaster not initialized - " +
                "call 'refresh' before multicasting events via the context: " + this);
    }
    return this.applicationEventMulticaster;
}

9 小结

本次我们学习了refresh()方法内部的obtainFreshBeanFactory——加载bean定义和finishBeanFactoryInitialization——完成bean初始化这两个方法之间的全部流程，概括起来就是：

prepareBeanFactory：对新获取的BeanFactory进行一系列配置，这也是applicationContext功能的扩展。
postProcessBeanFactory：默认是一个空的实现，这是留给子类容器实现对beanFactory后续处理的扩展方法。
invokeBeanFactoryPostProcessors：实例化所有BeanFactoryPostProcessor（包括其子类 BeanDefinitionRegistryPostProcessor）后处理器并按照一定的顺序调用相应的postProcessBeanDefinitionRegistry和postProcessBeanFactory回调方法，此时所有 bean 定义——beanDefinition都将已加载，但尚未实例化任何普通 bean。这允许我们重写beanDefinition或添加beanDefinition，修改beanFactory中的beanDefinition的任何可以修改的地方。
1. 比如通过 < context:component-scan/>标签解析注册的ConfigurationClassPostProcessor后处理器，就是BeanDefinitionRegistryPostProcessor的实例，就会在此时回调postProcessBeanDefinitionRegistry方法，用于解析配置类以及各种配置注解@Configuration 、@Component、@ComponentScan、@Import、@ImportResource……，@Bean注解也是在这里解析的，解析的bean定义会被注册到注册表中！
2. 比如通过< context:property-placeholder/>标签解析注册的PropertySourcesPlaceholderConfigurer后处理器，就是BeanFactoryPostProcessor的实例，就会在此时回调postProcessBeanFactory方法，先把environment和本地localProperties属性源放到内部的PropertySources集合中，随后用于解析bean定义中的属性值中的占位符，替换为真实值！后续还被用于解析@Resource、@Value等注解的值中的占位符解析、替换为真实值！
3. 这些后处理器的扩展内容后面单独讲解！
registerBeanPostProcessors：实例化和注册所有BeanPostProcessor后处理器，方便后续创建bean实例的时候的回调方法调用，这一步并没有进行回调方法调用。
initMessageSource：为此上下文容器初始化MessageSource消息资源，用于语言国际化处理。
initApplicationEventMulticaster：为此上下文容器初始化事件广播器，应用事件广播。
onRefresh：默认是一个空的实现，这是留给子类容器实现的扩展方法。
registerListeners：实例化和注册所有Listener监听器。

我们还学习了很多扩展点：BeanPostProcessor后处理器、忽略setter自动注入、指定自动注入实例、手动注册单例bean、 postProcessBeanFactory方法、BeanFactoryPostProcessor后处理器扩展点（postProcessBeanFactory方法）、BeanDefinitionRegistryPostProcessor后处理器扩展点（postProcessBeanFactory和postProcessBeanDefinitionRegistry方法）、onRefresh方法等等。

本文只是讲解了容器初始化的大概调用过程，并没有针对某个知识点进行讲解。在后面的文章中我们会对比如< import/>标签的解析、< alias/>标签的解析、< context:property-placeholder/>扩展标签的解析，PropertySourcesPlaceholderConfigurer、ConfigurationClassPostProcessor等一批后处理器的工作原理等一些重要的知识点进行单独解析。

相关文章：
https://spring.io/
Spring Framework 5.x 学习
Spring Framework 5.x 源码

如有需要交流，或者文章有误，请直接留言。另外希望点赞、收藏、关注，我将不间断更新各种Java学习博客！

你可能感兴趣的:(Spring,5.x,源码,后处理器扩展点,Spring,IoC容器初始化,PostProcessor)

为什么wal会提升数据库性能浩澜大大数据库
由于对于一个数据库内会存在很多张表，那么当数据库更新表数据时（1）直接写入磁盘实际写入的位置，会根据表的不同对应到不同的磁盘位置，在写入数据的时候，就会不停的寻找磁盘地址，找到地址后再去写入，对于机械硬盘来说，无规律的寻址是非常耗时的，对应SSD来说虽然性能提升很多，但是也会消耗时间；（2）先写入日志，在写入磁盘（WAL）WAL的过程，由于总是按照在文件末尾追加，只要找到文件写入位置，写入修改后，
《昼颜》里的日本女人：相遇要万种风情，分手要残忍绝情迷影咖啡
作者：迷之菌子神奇菇迷影咖啡：一本正经做烘焙，胡说八道聊电影漫天萤火虫消散之时良宵就将过去，人们也说含苞待放的花蕾总会开了又谢，因紧紧相拥而面红耳赤的躯体，便是我们经历过这热爱的证明。夫妻关系介绍《昼颜》是2014年电视剧《昼颜：工作日下午三点的恋人们》的续集，故事发在电视剧情节结束的三年后，讲述了已经恢复独身的纱和偶然与曾经的出轨对象北野重逢后再次陷入感情漩涡的故事。《昼颜》制作灵感源自利佳子在
被隔离的日子（五）@三七会写作营三七会萍海临风
从隔离的初期，我们三人都不适应，彼此说话都还火药味十足。后随着时间的推移，到现在，我们仨人能够心平气和，幽默地对待彼此。看来，时间可真是个好东西，不仅能见证一个人的心性，还能看清自己的需求、他人的本质。今天晚上，孩子跑到厨房，告诉我她给人捐款了。我纳闷，不是给河南捐过款了么。当时，我还落后于她捐的呢。这次又捐给谁？看到我一脸狐疑，孩子说，还记得初四给她补课的那个男老师么？当让记得，当时，就因为是男
2022年河南省高等职业教育技能大赛云计算赛项竞赛赛卷（样卷）忘川_ydy 云计算云计算 openstack kubernetes docker python k8s ansible
#需要资源（软件包及镜像）或有问题的，可私博主！！！#需要资源（软件包及镜像）或有问题的，可私博主！！！#需要资源（软件包及镜像）或有问题的，可私博主！！！第一部分：私有云任务1私有云服务搭建(10分)使用提供的用户名密码，登录竞赛用的云计算平台，按要求自行使用镜像创建两台云主机，创建完云主机后确保网络正常通信，然后按要求配置服务器。根据提供安装脚本框架，补充脚本完成OpenStack平台的安装搭
浪潮 M5系列服务器IPMI无法监控存储RAID卡问题. Songxwn 硬件服务器服务器运维
简介浪潮的M5代服务器，可能有WebBMC无法查看存储RAID/SAS卡状态的情况，可以通过以下方式修改。修改完成后重启BMC即可生效。ESXiIPMITools使用：https://songxwn.com/ESXi8_IPMI/（Linux也可以直接使用）Linux/ESXiIPMITool下载：https://songxwn.com/file/ipmitoolWindows下载：https:/
【OpenModelica】4命令行大全 Wumbuk python 开发语言 modelica
命令行大全文章目录命令行大全一、SummaryofCommandsfortheInteractiveSessionHandler二、Runningthecompilerfromcommandline一、SummaryofCommandsfortheInteractiveSessionHandler以下是交互式会话处理器中当前可用命令的完整列表。•simulate(modelname)：翻译一个名为
LeetCode1047：删除字符串中的所有相邻重复项一个小猴子｀ LeetCode 算法数据结构 c++leetcode
题目描述给出由小写字母组成的字符串S，重复项删除操作会选择两个相邻且相同的字母，并删除它们。在S上反复执行重复项删除操作，直到无法继续删除。在完成所有重复项删除操作后返回最终的字符串。答案保证唯一。示例：输入：“abbaca”输出：“ca”解释：例如，在“abbaca”中，我们可以删除“bb”由于两字母相邻且相同，这是此时唯一可以执行删除操作的重复项。之后我们得到字符串“aaca”，其中又只有“a
下载Android源码赛非斯
repoinit-uhttps://mirrors.tuna.tsinghua.edu.cn/git/AOSP/platform/manifest-bandroid-10.0.0_r411.首先下载repo：a）终端运行gitclonegit://codeaurora.org/tools/repo.gitb）mkdir~/binc）拷贝repo到~/bin下面，修改repo权限，chmoda+x~
华为OD机试 - 单向链表中间节点（Java & JS & Python & C & C++）华为OD题库华为od 链表 java
须知哈喽，本题库完全免费，收费是为了防止被爬，大家订阅专栏后可以私信联系退款。感谢支持文章目录须知题目描述输出描述解析代码题目描述给定一个单链表L，请编写程序输出L中间结点保存的数据。如果有两个中间结点，则输出第二个中间结点保存的数据。例如：给定L为1→7→5，则输出应该为7；给定L为1→2→3→4，则输出应该为3；输入描述每个输入包含1个测试用例。每个测试用例：第一行给出链表首结点的地址、结点总
男人请珍惜十六七岁陪在你身边的女孩吧小朋友嘿哈
你相信那种从校服到婚纱的爱情吗。01朋友阿伟18岁的时候就是一混混，放学不是和这个学校的学生约架，就是那个小弟被欺负了要为此出头，溜冰场上看谁不顺眼，一个字：打。当然，放学蹲点泡妞是常事，看到这个学生妹浓妆艳抹，搭讪，看到那个前凸后翘的，搭讪。阿伟也不例外，他说：“我当时和几个兄弟在学校后门的小卖部抽烟，姗姗背着双肩背包，扎着马尾辫，看到我们几个混混有些害怕的低着头快步走过我们面前，那时候我在想啊
SpringMVC设置全局异常处理器水岸齐天 java spring
文章目录背景分析使用@ControllerAdvice（@RestControllerAdvice）+@ExceptionHandler实现全局异常全局异常处理-多个处理器匹配顺序存在一个类中存在不同的类中对于过滤器和拦截器中的异常，有两种思路可以考虑背景在项目中我们有需求做一个全局异常处理，来规范所有出去的异常信息。参考：官方文档分析首先ControllerAdvice(RestControll
为什么说仪式和习惯非常重要？章鱼老师zy
这是章鱼姐第【40】篇原创文章，日更计划第【37/100】天。阅读张萌萌姐【精力管理手册】第【6/7】章。一阅读摘要这一章萌姐讲到了习惯的重要性，为什么说养成一个习惯很重要？如何养成一个好习惯？如何建立自己的仪式感？二金句精力管理最重要的是产生什么效果。当你想做却没有动力去做一件事情时，你就应该把它养成习惯。习惯可以帮我们创造稳定框架。对于那些特别考验意志的事情，我们应该先行后思。三思考题，萌姐讲
第一章山洞传来牛铃声满眼荷花
春夏时节，田野一片青碧，山林薄雾蔼蔼，水草萋萋的小河边静静立着一只白鹭，像一位白头钓翁，在耐心地等鱼。王三乐牵着一头老黄牛，正在河边田埂上放牛。看见白鹭，他百无聊赖地捡起一块小石头扔了过去。白鹭动作舒缓、姿势优美地飞起避过，在空中飞行一段后，宛若晴空一片云，翩然而下，又静静立于河边青草间，继续呈现完美的画面。王三乐也觉得自己很无聊，这也难怪，从他记事起就开始放牛，一直到现在都大学毕业了，还没丢下放
口才训练的第一个礼物 Leah82
昨天，看到陶子教练在总结里写的“随机抽，已经是很久远的年代了”，Tom教练在后面回复“久远是多远？不过是几个月罢了！”。看着就想笑。对呀，感觉很久远的事，不过是几个月而已。为什么会有这种感觉呢？因为，在这短短的几个月里，我们都经历了太多太多。成长，蜕变，口才，思想……“那久远的年代里”，曾经让自己心惊胆战的随机抽，已经是过眼云烟了。但是，我们还是记忆犹新。因为，随机抽通关，是我们跨入口才训练大门后
1.计算机处理器架构+嵌入式处理器架构及知识 vv 啊 arm-linux学习 linux 系统架构
目录一：x86-64处理器架构二：Intel80386处理器（i386）1.i3862.i686三：嵌入式Linux知识：1.MinGW2.GNU计划2.1GNU工具链概述此次只分享英特尔和ADM处理器有关于x86的架构，至于嵌入式处理器架构请查看https://en.wikipedia.org/wiki/List_of_ARM_processors一：x86-64处理器架构x86-64，也称为x
数据挖掘|数据预处理|基于Python的数据标准化方法皖山文武数据挖掘数据建模与分析 python 数据挖掘开发语言
基于Python的数据标准化方法1.z-score方法2.极差标准化方法3.最大绝对值标准化方法在数据分析之前，通常需要先将数据标准化（Standardization），利用标准化后的数据进行数据分析，以避免属性之间不同度量和取值范围差异造成数据对分析结果的影响。1.z-score方法Z-score方法是基于原始数据的均值和标准差来进行数据标准化的，处理后的数据均值为0，方差为1，符合标准正态分布
使用多线程的方式模拟高并发请求接口，用于自测接口的稳定性【项目】还算善良_ 私有代码库工具类 java list 数据结构
packagecom.gitee.taven.test;importcom.gitee.taven.ApiResult;importcom.gitee.taven.aop.RepeatSubmitAspect;importorg.slf4j.Logger;importorg.slf4j.LoggerFactory;importorg.springframework.beans.factory.an
零元购晋迪
初听到零元购这个词，我们都感觉好奇。同事老王收到一条快递取件码的短信，可她清楚记得自己最近并没有买东西。快递公司给她打来电话让她去取件，听明白后，她才知道是怎么回事。原来有天闲着没事，她在拼多多上看到有个零元购，出于好奇，她进去看了，不小心点到一个商品，可当时也没用付钱，她并不知道这样就算下单了，今天收到快递公司的电话，她去查看，竟然自动扣款了。商家可能琢磨到人性的弱点，干脆发明这么一种销售方式，
心赏（2018.10.8）六一节_3928
1.上班第一天，同事彤休完产假，回来上班，给我带了酸奶和水果。她生小孩时，我给她发了一个小红包贺喜，哪知她就记在心里了。心赏这个有心的90后。2.女儿放学回来，说自己当了小组长。一边说不想当，一边得意的样子。心赏老师给了孩子这个锻炼的机会。3.老妈今天做了"蚂蚁上树"的菜，得到女儿的高度肯定。心赏老妈还在不断学习。
springboot集成logback-spring.xml文件 RT_0114 SpringBoot spring boot spring logback
彩色日志日志分debug和error文件输出，方便开发人员运维日志限制最大保管天数日志限制总量大小占用量GB日志限制单个文件大小MB日志显示最大保留天数屏蔽没用的日志${CONSOLE_LOG_PATTERN}${log.path}/debug.log${log.path}/%d{yyyy-MM-dd,aux}/debug.%d{yyyy-MM-dd}.%i.log.gz1024MB50GB365
常用API---初始化，话题和服务对象创建，回旋/头函数，时间（如：获取当前时刻，持续时间执行频率，休眠，定时器等），运行频率，定时器，节点生命周期，日志相关API 李卓璐机器人人工智能 c++
初始化ROS节点ros::init(argc,argv,“name”,options);作用：ros初始化函数参数： 1.argc—封装实参的个数（n+1个->有一个是自身）； 2.argv—封装参数的数组； 3.name—为节点命名（唯一性）； 4.options—节点启动项，解决节点重名问题。返回值：void使用： 1.argc和argv的使用：如果按照ROS中的特定格式传入实参，那么RO
matlab按行读取txt文件数据集地上悬河 matlab 开发语言
功能：使用Matlab按行读取txt文件，按照特定符号进行分割后加入数组中fid=fopen('coordinate.txt');%首先打开文本文件coordinate.txttemp=[]while~feof(fid)%while循环表示文件指针没到达末尾，则继续%每次读取一行,str是字符串格式str=fgetl(fid);%以','作为分割数据的字符,结果为cell数组s=regexp(st
＜商务世界＞《第25课餐桌上的礼仪-简单的流程》 Ealser 商务世界中国餐桌礼节
第一：迎客席座一般的程序是主人给客人邀请函——日子到了，主人到门外迎客——客人到了，问候几句——带着可人到0客厅小坐一会儿，给客人茶点——带客人入席坐好！第二：入座与座次首先要请客人中长者或地位高的先入座，再按身份地位依次入座，入座时要从椅子左边进入。（正对门口的为上座，一般是根据对方的.身份地位来安排）。入座后不要动筷子，更不要弄出什么响声来，也不要起身走动。如果有什么事要向主人打招呼！（做小辈
chrome扩展，“manifest_version“: 3, chrome 扩展图标点击事件徐同保 chrome 前端
在Chrome扩展中，从ManifestV3开始，后台脚本（backgroundscripts）被服务工作线程（serviceworkers）所取代。这改变了扩展图标点击事件（通常称为浏览器操作或者页面操作）的处理方式。在ManifestV3中，您需要使用chrome.action.onClicked监听器来处理扩展图标的点击事件。下面是一个如何设置扩展图标点击事件处理器的示例：在manifest
以高质量调查研究助力组织工作提质增效木同木同
近日，中共中央办公厅印发了《关于在全党大兴调查研究的工作方案》(后简称《方案》），要求各地区各部门结合实际认真贯彻落实。调查研究是我们党的传家宝，是谋事之基、成事之道。组织部门作为党管干部的核心部门，肩负着管党员、管干部、管人才的重要职责，调查研究更是把握组织工作规律、破解组织工作难题的重要办法。要用好调查研究这一法宝，把准政治方向，贯穿问题导向，坚持实事求是，以高质量调查研究助力组织工作提质增效
npm 搭建 Vite 项目渺小的虫子 viter 前端 javascript 开发语言
兼容性注意Vite需要Node.js版本>=12.0.0。1、使用npm安装Viter$npminitvite@latest使用npm初始化项目#npm6.xnpminitvite@latestmy-vue-app--templatevue#npm7+,需要额外的双横线：npminitvite@latestmy-vue-app----templatevue2、配置路由：npminstallvue-
中国最美的100个地方，待“软禁”结束后，满血复活去一次旅行！是北河二1995
【阅读原文，请点击：原文，硬核100个】离成为一个倾国倾城、走路带风的女子还有365天！大家好，我是小草们的北河二~一转眼，2020年已过1/4，突如其来的病毒，搅得人心惶惶。原本的3月里，景区爆满、街道拥堵、小吃铺做无缺席。然而，地球妈妈不会一直宠着我们，给了我们好几个警告。如今，连CCTV-1播出的《人与自然》，我都可以看上好一会儿......高山、流水、湖泊、森林、大海.....它们也在这初
中国大学：你站起来！立恒语文
我们先来看看中国大学对外国留学生的“奇葩”待遇。近日，有网友曝出吉林大学有要求中国学生起床后须叫醒外国留学生的服务。看完之后，真是让人大跌眼镜。有网友就直接质问：吉大是大学，还是酒店？中国学生是学生，还是服务员？外国留学生是来求学的，还是享受的？这不仅让人联想到最近一段时间以来网上频频曝出的许多中国大学对外国留学生的一些“奇葩”待遇，这里举几个比较有名的事例，以飨读者。1.山东大学的“三陪”制度，
图论记录之最短路迪杰斯特拉 Just right 算法图论 java 开发语言
简述思想这个思想能用一句话来概括，精简到的极致:每次找到一个最短距离的点并更新起点到各个点的最短距离如果要可视化的话，B站搜索Dijksra算法，有视频讲解伪代码写到这里，其实是想整一个动画的，这样效果更好点，但由于种种原因所以就拖一下intdijkstr(){dist[1]=0;其余的点的距离全部初始化为真无穷，不要写成int的最大值迭代n次将不在s中的，且距离最近的点给tsj即先到t，再加上t
00后的我和你们三七_f4f4
大部分人认为，这个社会压力最大的莫过于90后。可能上有老下有小，可以正在被催婚。工作压力大。可是也有大部分00后也步入了社会，比起90后，他们更是迷茫，不知所措。虽没有来自家庭的压力，没有来自催婚的烦劳。可迷茫真的很可怕，不知道一会该干嘛，该想那些方面发展。觉得自己以后就这样碌碌无为了吗？就这样过一辈子吗？又不甘。图片发自App前几天在抖音上看见一个视频，他说姚明在苦练篮球。谁谁在苦练什么。问，你
knob UI插件使用换个号韩国红果果 JavaScript jsonp knob
图形是用canvas绘制的 js代码 var paras = { max:800, min:100, skin:'tron',//button type thickness:.3,//button width width:'200',//define canvas width.,canvas height displayInput:'tr
Android+Jquery Mobile学习系列(5)-SQLite数据库白糖_ JQuery Mobile
目录导航 SQLite是轻量级的、嵌入式的、关系型数据库，目前已经在iPhone、Android等手机系统中使用,SQLite可移植性好，很容易使用，很小，高效而且可靠。因为Android已经集成了SQLite，所以开发人员无需引入任何JAR包，而且Android也针对SQLite封装了专属的API，调用起来非常快捷方便。我也是第一次接触S
impala-2.1.2-CDH5.3.2 dayutianfei impala
最近在整理impala编译的东西，简单记录几个要点：根据官网的信息（https://github.com/cloudera/Impala/wiki/How-to-build-Impala）： 1. 首次编译impala，推荐使用命令： ${IMPALA_HOME}/buildall.sh -skiptests -build_shared_libs -format 2.仅编译BE ${I
求二进制数中1的个数周凡杨 java 算法二进制
解法一：对于一个正整数如果是偶数，该数的二进制数的最后一位是 0 ，反之若是奇数，则该数的二进制数的最后一位是 1 。因此，可以考虑利用位移、判断奇偶来实现。 public int bitCount(int x){ int count = 0; while(x!=0){ if(x%2!=0){ /
spring中hibernate及事务配置 g21121 Hibernate
hibernate的sessionFactory配置：  <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> <
log4j.properties 使用 510888780 log4j
log4j.properties 使用一.参数意义说明输出级别的种类 ERROR、WARN、INFO、DEBUG ERROR 为严重错误主要是程序的错误 WARN 为一般警告，比如session丢失 INFO 为一般要显示的信息，比如登录登出 DEBUG 为程序的调试信息配置日志信息输出目的地 log4j.appender.appenderName = fully.qua
Spring mvc-jfreeChart柱图（2）布衣凌宇 jfreechart
上一篇中生成的图是静态的，这篇将按条件进行搜索，并统计成图表，左面为统计图，右面显示搜索出的结果。第一步：导包第二步；配置web.xml(上一篇有代码) 建BarRenderer类用于柱子颜色 import java.awt.Color; import java.awt.Paint; import org.jfree.chart.renderer.category.BarR
我的spring学习笔记14-容器扩展点之PropertyPlaceholderConfigurer aijuans Spring3
PropertyPlaceholderConfigurer是个bean工厂后置处理器的实现，也就是BeanFactoryPostProcessor接口的一个实现。关于BeanFactoryPostProcessor和BeanPostProcessor类似。我会在其他地方介绍。 PropertyPlaceholderConfigurer可以将上下文（配置文件）中的属性值放在另一个单独的标准java
maven 之 cobertura 简单使用 antlove maven test unit cobertura report
1. 创建一个maven项目 2. 创建com.CoberturaStart.java package com; public class CoberturaStart { public void helloEveryone(){ System.out.println("=================================================
程序的执行顺序百合不是茶 JAVA执行顺序
刚在看java核心技术时发现对java的执行顺序不是很明白了,百度一下也没有找到适合自己的资料,所以就简单的回顾一下吧代码如下; 经典的程序执行面试题 //关于程序执行的顺序 //例如： //定义一个基类 public class A(){ public A(
设置session失效的几种方法 bijian1013 web.xml session失效监听器
在系统登录后，都会设置一个当前session失效的时间，以确保在用户长时间不与服务器交互，自动退出登录，销毁session。具体设置很简单，方法有三种：（1）在主页面或者公共页面中加入：session.setMaxInactiveInterval(900);参数900单位是秒，即在没有活动15分钟后，session将失效。这里要注意这个session设置的时间是根据服务器来计算的，而不是客户端。所
java jvm常用命令工具 bijian1013 java jvm
一.概述程序运行中经常会遇到各种问题，定位问题时通常需要综合各种信息，如系统日志、堆dump文件、线程dump文件、GC日志等。通过虚拟机监控和诊断工具可以帮忙我们快速获取、分析需要的数据，进而提高问题解决速度。本文将介绍虚拟机常用监控和问题诊断命令工具的使用方法，主要包含以下工具: &nbs
【Spring框架一】Spring常用注解之Autowired和Resource注解 bit1129 Spring常用注解
Spring自从2.0引入注解的方式取代XML配置的方式来做IOC之后，对Spring一些常用注解的含义行为一直处于比较模糊的状态，写几篇总结下Spring常用的注解。本篇包含的注解有如下几个： Autowired Resource Component Service Controller Transactional 根据它们的功能、目的，可以分为三组，Autow
mysql 操作遇到safe update mode问题 bitray update
我并不知道出现这个问题的实际原理,只是通过其他朋友的博客,文章得知的一个解决方案,目前先记录一个解决方法,未来要是真了解以后,还会继续补全. 在mysql5中有一个safe update mode,这个模式让sql操作更加安全,据说要求有where条件,防止全表更新操作.如果必须要进行全表操作,我们可以执行 SET
nginx_perl试用 ronin47 nginx_perl试用
因为空闲时间比较多，所以在CPAN上乱翻，看到了nginx_perl这个项目(原名Nginx::Engine)，现在托管在github.com上。地址见：https://github.com/zzzcpan/nginx-perl 这个模块的目的，是在nginx内置官方perl模块的基础上，实现一系列异步非阻塞的api。用connector/writer/reader完成类似proxy的功能（这里
java-63-在字符串中删除特定的字符 bylijinnan java
public class DeleteSpecificChars { /** * Q 63 在字符串中删除特定的字符 * 输入两个字符串，从第一字符串中删除第二个字符串中所有的字符。 * 例如，输入”They are students.”和”aeiou”，则删除之后的第一个字符串变成”Thy r stdnts.” */ public static voi
EffectiveJava--创建和销毁对象 ccii 创建和销毁对象
本章内容： 1. 考虑用静态工厂方法代替构造器 2. 遇到多个构造器参数时要考虑用构建器（Builder模式） 3. 用私有构造器或者枚举类型强化Singleton属性 4. 通过私有构造器强化不可实例化的能力 5. 避免创建不必要的对象 6. 消除过期的对象引用 7. 避免使用终结方法 1. 考虑用静态工厂方法代替构造器类可以通过
[宇宙时代]四边形理论与光速飞行 comsci
从四边形理论来推论为什么光子飞船必须获得星光信号才能够进行光速飞行？一组星体组成星座向空间辐射一组由复杂星光信号组成的辐射频带，按照四边形-频率假说一组频率就代表一个时空的入口那么这种由星光信号组成的辐射频带就代表由这些星体所控制的时空通道，该时空通道在三维空间的投影是一
ubuntu server下python脚本迁移数据 cywhoyi python Kettle pymysql cx_Oracle ubuntu server
因为是在Ubuntu下，所以安装python、pip、pymysql等都极其方便，sudo apt-get install pymysql，但是在安装cx_Oracle（连接oracle的模块）出现许多问题，查阅相关资料，发现这边文章能够帮我解决，希望大家少走点弯路。http://www.tbdazhe.com/archives/602 1.安装python 2.安装pip、pymysql
Ajax正确但是请求不到值解决方案 dashuaifu Ajax async
Ajax正确但是请求不到值解决方案解决方案：1 . async: false , 2. 设置延时执行js里的ajax或者延时后台java方法！！！！！！！例如： $.ajax({ &
windows安装配置php+memcached dcj3sjt126com PHP Install memcache
Windows下Memcached的安装配置方法 1、将第一个包解压放某个盘下面，比如在c:\memcached。 2、在终端（也即cmd命令界面）下输入 'c:\memcached\memcached.exe -d install' 安装。 3、再输入： 'c:\memcached\memcached.exe -d start' 启动。（需要注意的: 以后memcached将作为windo
iOS开发学习路径的一些建议 dcj3sjt126com ios
iOS论坛里有朋友要求回答帖子，帖子的标题是：想学IOS开发高阶一点的东西，从何开始，然后我吧啦吧啦回答写了很多。既然敲了那么多字，我就把我写的回复也贴到博客里来分享，希望能对大家有帮助。欢迎大家也到帖子里讨论和分享，地址：http://bbs.csdn.net/topics/390920759 下面是我回复的内容：结合自己情况聊下iOS学习建议，
Javascript闭包概念 fanfanlovey JavaScript 闭包
1.参考资料 http://www.jb51.net/article/24101.htm http://blog.csdn.net/yn49782026/article/details/8549462 2.内容概述要理解闭包，首先需要理解变量作用域问题内部函数可以饮用外面全局变量 var n=999; 　　functio
yum安装mysql5.6 haisheng mysql
1、安装http://dev.mysql.com/get/mysql-community-release-el7-5.noarch.rpm 2、yum install mysql 3、yum install mysql-server 4、vi /etc/my.cnf 添加character_set_server=utf8
po/bo/vo/dao/pojo的详介 IT_zhlp80 java BO VO DAO POJO po
JAVA几种对象的解释 PO:persistant object持久对象,可以看成是与数据库中的表相映射的java对象。最简单的PO就是对应数据库中某个表中的一条记录，多个记录可以用PO的集合。PO中应该不包含任何对数据库的操作. VO:value object值对象。通常用于业务层之间的数据传递，和PO一样也是仅仅包含数据而已。但应是抽象出的业务对象,可
java设计模式 kerryg java 设计模式
设计模式的分类：一、设计模式总体分为三大类： 1、创建型模式（5种）：工厂方法模式，抽象工厂模式，单例模式，建造者模式，原型模式。 2、结构型模式（7种）：适配器模式，装饰器模式，代理模式，外观模式，桥接模式，组合模式，享元模式。 3、行为型模式（11种）：策略模式，模版方法模式，观察者模式，迭代子模式，责任链模式，命令模式，备忘录模式，状态模式，访问者
[1]CXF3.1整合Spring开发webservice——helloworld篇木头.java spring webservice CXF
Spring 版本3.2.10 CXF 版本3.1.1 项目采用MAVEN组织依赖jar 我这里是有parent的pom，为了简洁明了，我直接把所有的依赖都列一起了，所以都没version，反正上面已经写了版本 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="ht
Google 工程师亲授：菜鸟开发者一定要投资的十大目标 qindongliang1922 工作感悟人生
身为软件开发者，有什么是一定得投资的？ Google 软件工程师 Emanuel Saringan 整理了十项他认为必要的投资，第一项就是身体健康，英文与数学也都是必备能力吗？来看看他怎么说。（以下文字以作者第一人称撰写））你的健康无疑地，软件开发者是世界上最久坐不动的职业之一。每天连坐八到十六小时，休息时间只有一点点，绝对会让你的鲔鱼肚肆无忌惮的生长。肥胖容易扩大罹患其他疾病的风险，
linux打开最大文件数量1,048,576 tianzhihehe c linux
File descriptors are represented by the C int type. Not using a special type is often considered odd, but is, historically, the Unix way. Each Linux process has a maximum number of files th
java语言中PO、VO、DAO、BO、POJO几种对象的解释衞酆夼 java VO BO POJO po
PO:persistant object持久对象最形象的理解就是一个PO就是数据库中的一条记录。好处是可以把一条记录作为一个对象处理，可以方便的转为其它对象。可以看成是与数据库中的表相映射的java对象。最简单的PO就是对应数据库中某个表中的一条记录，多个记录可以用PO的集合。PO中应该不包含任何对数据库的操作。 BO:business object业务对象封装业务逻辑的java对象

Spring IoC容器初始化源码(5)—prepareBeanFactory准备Bean工厂、回调BeanFactoryPostProcessor、注册BeanPostProcessor【两万字】

Spring IoC容器初始化源码 系列文章

文章目录

1 prepareBeanFactory配置BeanFactory

1.1 BeanPostProcessor后置处理器扩展点

1.1.1 使用案例

1.1.2 ApplicationContextAwareProcessor

1.2 忽略setter自动注入扩展点

1.2.1 ignoreDependencyType

1.2.2 ignoreDependencyInterface

1.3 指定自动注入实例扩展点

1.3.1 预定义的自动注入实例

1.3.2 自定义的自动注入实例

1.4 手动注册单例bean扩展点

2 postProcessBeanFactory扩展BeanFactory

3 invokeBeanFactoryPostProcessors回调BeanFactoryPostProcessor

3.1 BeanFactoryPostProcessor扩展点

3.2 BeanDefinitionRegistryPostProcessor扩展点

3.3 invokeBeanFactoryPostProcessors回调BeanFactoryPostProcessor

3.3.1 getBeanFactoryPostProcessors获取上下文中的beanFactoryPostProcessors

3.3.2 invokeBeanFactoryPostProcessors回调BeanFactoryPostProcessor

3.3.2.1 sortPostProcessors优先级排序

3.3.2.1.1 OrderComparator比较器

4 registerBeanPostProcessors注册BeanPostProcessor

4.1 registerBeanPostProcessors注册BeanPostProcessor

5 initMessageSource初始化MessageSource

6 initApplicationEventMulticaster初始化ApplicationEventMulticaster

7 onRefresh扩展点

8 registerListeners注册Listener

9 小结

你可能感兴趣的:(Spring,5.x,源码,后处理器扩展点,Spring,IoC容器初始化,PostProcessor)

Spring IoC容器初始化源码系列文章