AbstractApplicationContext源码解析(2)

prepareBeanFactory方法

大概理解一下prepareBeanFactory方法的作用，源码如下：

/**

* 配置工厂的标准上下文特征，例如上下文的 ClassLoader 和后处理器。

* @param beanFactory 要配置的 BeanFactory

* Configure the factory's standard context characteristics,

* such as the context's ClassLoader and post-processors.

* @param beanFactory the BeanFactory to configure

*/

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {

// Tell the internal bean factory to use the context's class loader etc.

// 设置beanFactory的classloader为当前context的classloader

beanFactory.setBeanClassLoader(getClassLoader());

// 设置beanfactory的表达式语言处理器

beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));

// 为beanFactory增加一个默认的propertyEditor，这个主要是对bean的属性等设置管理的一个工具类

beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

// Configure the bean factory with context callbacks.

// 添加beanPostProcessor,ApplicationContextAwareProcessor此类用来完成某些Aware对象的注入

beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));

// 设置要忽略自动装配的接口，很多同学理解不了为什么此处要对这些接口进行忽略，原因非常简单，这些接口的实现是由容器通过set方法进行注入的，

// 所以在使用autowire进行注入的时候需要将这些接口进行忽略

beanFactory.ignoreDependencyInterface(EnvironmentAware.class);

beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);

beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);

beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);

beanFactory.ignoreDependencyInterface(MessageSourceAware.class);

beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);

// BeanFactory interface not registered as resolvable type in a plain factory.

// MessageSource registered (and found for autowiring) as a bean.

// 设置几个自动装配的特殊规则,当在进行ioc初始化的如果有多个实现，那么就使用指定的对象进行注入

beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);

beanFactory.registerResolvableDependency(ResourceLoader.class, this);

beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);

beanFactory.registerResolvableDependency(ApplicationContext.class, this);

// Register early post-processor for detecting inner beans as ApplicationListeners.

// 注册BPP

beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

// Detect a LoadTimeWeaver and prepare for weaving, if found.

// 增加对AspectJ的支持，在java中织入分为三种方式，分为编译器织入，类加载器织入，运行期织入，编译器织入是指在java编译器，采用特殊的编译器，将切面织入到java类中，

// 而类加载期织入则指通过特殊的类加载器，在类字节码加载到JVM时，织入切面，运行期织入则是采用cglib和jdk进行切面的织入

// aspectj提供了两种织入方式，第一种是通过特殊编译器，在编译器，将aspectj语言编写的切面类织入到java类中，第二种是类加载期织入，就是下面的load time weaving，此处后续讲

if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {

beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));

// Set a temporary ClassLoader for type matching.

beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));

}

// Register default environment beans.

// 注册默认的系统环境bean到一级缓存中

if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {

beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());

}

if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {

beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());

}

if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {

beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());

}

}

对prepareBeanFactory方法的总结：beanFactory的准备工作，对各种属性进行填充；

prepareBeanFactory

postProcessBeanFactory方法

    /**

* 在标准初始化之后修改应用程序上下文的内部 bean 工厂。所有 bean 定义都将被加载，但还没有 bean 被实例化。这允许在某些 ApplicationContext 实现中注册特殊的 BeanPostProcessors 等。

* Modify the application context's internal bean factory after its standard

* initialization. All bean definitions will have been loaded, but no beans

* will have been instantiated yet. This allows for registering special

* BeanPostProcessors etc in certain ApplicationContext implementations.

* @param beanFactory the bean factory used by the application context

*/

protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {

}

这个方法点进去看，发现是个空方法，是预留以后拓展使用的；对其进行总结：子类覆盖方法做额外的处理，此处我们自己一般不做任何扩展工作，但是可以查看web中的代码，是有具体实现的

postProcessBeanFactory

invokeBeanFactoryPostProcessors方法

/**

* 实例化并且调用所有已经注册了的beanFactoryPostProcessor,遵循指明的顺序

*

* Instantiate and invoke all registered BeanFactoryPostProcessor beans,

* respecting explicit order if given.

*

Must be called before singleton instantiation.

*/

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {

// 获取到当前应用程序上下文的beanFactoryPostProcessors变量的值，并且实例化调用执行所有已经注册的beanFactoryPostProcessor

// 默认情况下，通过getBeanFactoryPostProcessors()来获取已经注册的BFPP，但是默认是空的，那么问题来了，如果你想扩展，怎么进行扩展工作？

PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());

// Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime

// (e.g. through an @Bean method registered by ConfigurationClassPostProcessor)

if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {

beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));

beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));

}

}

PostProcessorRegistrationDelegate.java

    public static void invokeBeanFactoryPostProcessors(

            ConfigurableListableBeanFactory beanFactory, List beanFactoryPostProcessors) {

        // Invoke BeanDefinitionRegistryPostProcessors first, if any.

        // 无论是什么情况，优先执行BeanDefinitionRegistryPostProcessors

        // 将已经执行过的BFPP存储在processedBeans中，防止重复执行

        Set processedBeans = new HashSet<>();

        // 判断beanfactory是否是BeanDefinitionRegistry类型，此处是DefaultListableBeanFactory,实现了BeanDefinitionRegistry接口，所以为true

        if (beanFactory instanceof BeanDefinitionRegistry) {

            // 类型转换

            BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;

            // 此处希望大家做一个区分，两个接口是不同的，BeanDefinitionRegistryPostProcessor是BeanFactoryPostProcessor的子集

            // BeanFactoryPostProcessor主要针对的操作对象是BeanFactory，而BeanDefinitionRegistryPostProcessor主要针对的操作对象是BeanDefinition

            // 存放BeanFactoryPostProcessor的集合

            List regularPostProcessors = new ArrayList<>();

            // 存放BeanDefinitionRegistryPostProcessor的集合

            List registryProcessors = new ArrayList<>();

            // 首先处理入参中的beanFactoryPostProcessors,遍历所有的beanFactoryPostProcessors，将BeanDefinitionRegistryPostProcessor

            // 和BeanFactoryPostProcessor区分开

            for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {

                // 如果是BeanDefinitionRegistryPostProcessor

                if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {

                    BeanDefinitionRegistryPostProcessor registryProcessor =

                            (BeanDefinitionRegistryPostProcessor) postProcessor;

                    // 直接执行BeanDefinitionRegistryPostProcessor接口中的postProcessBeanDefinitionRegistry方法

                    registryProcessor.postProcessBeanDefinitionRegistry(registry);

                    // 添加到registryProcessors，用于后续执行postProcessBeanFactory方法

                    registryProcessors.add(registryProcessor);

                } else {

                    // 否则，只是普通的BeanFactoryPostProcessor，添加到regularPostProcessors，用于后续执行postProcessBeanFactory方法

                    regularPostProcessors.add(postProcessor);

                }

            }

            // Do not initialize FactoryBeans here: We need to leave all regular beans

            // uninitialized to let the bean factory post-processors apply to them!

            // Separate between BeanDefinitionRegistryPostProcessors that implement

            // PriorityOrdered, Ordered, and the rest.

            // 用于保存本次要执行的BeanDefinitionRegistryPostProcessor

            List currentRegistryProcessors = new ArrayList<>();

            // First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.

            // 调用所有实现PriorityOrdered接口的BeanDefinitionRegistryPostProcessor实现类

            // 找到所有实现BeanDefinitionRegistryPostProcessor接口bean的beanName

            String[] postProcessorNames =

                    beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);

            // 遍历处理所有符合规则的postProcessorNames

            for (String ppName : postProcessorNames) {

                // 检测是否实现了PriorityOrdered接口

                if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {

                    // 获取名字对应的bean实例，添加到currentRegistryProcessors中

                    currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));

                    // 将要被执行的BFPP名称添加到processedBeans，避免后续重复执行

                    processedBeans.add(ppName);

                }

            }

            // 按照优先级进行排序操作

            sortPostProcessors(currentRegistryProcessors, beanFactory);

            // 添加到registryProcessors中，用于最后执行postProcessBeanFactory方法

            registryProcessors.addAll(currentRegistryProcessors);

            // 遍历currentRegistryProcessors，执行postProcessBeanDefinitionRegistry方法

            invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);

            // 执行完毕之后，清空currentRegistryProcessors

            currentRegistryProcessors.clear();

            // Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.

            // 调用所有实现Ordered接口的BeanDefinitionRegistryPostProcessor实现类

            // 找到所有实现BeanDefinitionRegistryPostProcessor接口bean的beanName，

            // 此处需要重复查找的原因在于上面的执行过程中可能会新增其他的BeanDefinitionRegistryPostProcessor

            postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);

            for (String ppName : postProcessorNames) {

                // 检测是否实现了Ordered接口，并且还未执行过

                if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {

                    // 获取名字对应的bean实例，添加到currentRegistryProcessors中

                    currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));

                    // 将要被执行的BFPP名称添加到processedBeans，避免后续重复执行

                    processedBeans.add(ppName);

                }

            }

            // 按照优先级进行排序操作

            sortPostProcessors(currentRegistryProcessors, beanFactory);

            // 添加到registryProcessors中，用于最后执行postProcessBeanFactory方法

            registryProcessors.addAll(currentRegistryProcessors);

            // 遍历currentRegistryProcessors，执行postProcessBeanDefinitionRegistry方法

            invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);

            // 执行完毕之后，清空currentRegistryProcessors

            currentRegistryProcessors.clear();

            // Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.

            // 最后，调用所有剩下的BeanDefinitionRegistryPostProcessors

            boolean reiterate = true;

            while (reiterate) {

                reiterate = false;

                // 找出所有实现BeanDefinitionRegistryPostProcessor接口的类

                postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);

                // 遍历执行

                for (String ppName : postProcessorNames) {

                    // 跳过已经执行过的BeanDefinitionRegistryPostProcessor

                    if (!processedBeans.contains(ppName)) {

                        // 获取名字对应的bean实例，添加到currentRegistryProcessors中

                        currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));

                        // 将要被执行的BFPP名称添加到processedBeans，避免后续重复执行

                        processedBeans.add(ppName);

                        reiterate = true;

                    }

                }

                // 按照优先级进行排序操作

                sortPostProcessors(currentRegistryProcessors, beanFactory);

                // 添加到registryProcessors中，用于最后执行postProcessBeanFactory方法

                registryProcessors.addAll(currentRegistryProcessors);

                // 遍历currentRegistryProcessors，执行postProcessBeanDefinitionRegistry方法

                invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);

                // 执行完毕之后，清空currentRegistryProcessors

                currentRegistryProcessors.clear();

            }

            // Now, invoke the postProcessBeanFactory callback of all processors handled so far.

            // 调用所有BeanDefinitionRegistryPostProcessor的postProcessBeanFactory方法

            invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);

            // 最后，调用入参beanFactoryPostProcessors中的普通BeanFactoryPostProcessor的postProcessBeanFactory方法

            invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);

        } else {

            // Invoke factory processors registered with the context instance.

            // 如果beanFactory不归属于BeanDefinitionRegistry类型，那么直接执行postProcessBeanFactory方法

            invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);

        }

        // 到这里为止，入参beanFactoryPostProcessors和容器中的所有BeanDefinitionRegistryPostProcessor已经全部处理完毕，下面开始处理容器中

        // 所有的BeanFactoryPostProcessor

        // 可能会包含一些实现类，只实现了BeanFactoryPostProcessor，并没有实现BeanDefinitionRegistryPostProcessor接口

        // Do not initialize FactoryBeans here: We need to leave all regular beans

        // uninitialized to let the bean factory post-processors apply to them!

        // 找到所有实现BeanFactoryPostProcessor接口的类

        String[] postProcessorNames =

                beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

        // Separate between BeanFactoryPostProcessors that implement PriorityOrdered,

        // Ordered, and the rest.

        // 用于存放实现了PriorityOrdered接口的BeanFactoryPostProcessor

        List priorityOrderedPostProcessors = new ArrayList<>();

        // 用于存放实现了Ordered接口的BeanFactoryPostProcessor的beanName

// List orderedPostProcessorNames = new ArrayList<>();

        List orderedPostProcessor = new ArrayList<>();

        // 用于存放普通BeanFactoryPostProcessor的beanName

// List nonOrderedPostProcessorNames = new ArrayList<>();

        List nonOrderedPostProcessorNames = new ArrayList<>();

        // 遍历postProcessorNames,将BeanFactoryPostProcessor按实现PriorityOrdered、实现Ordered接口、普通三种区分开

        for (String ppName : postProcessorNames) {

            // 跳过已经执行过的BeanFactoryPostProcessor

            if (processedBeans.contains(ppName)) {

                // skip - already processed in first phase above

            }

            // 添加实现了PriorityOrdered接口的BeanFactoryPostProcessor到priorityOrderedPostProcessors

            else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {

                priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));

            }

            // 添加实现了Ordered接口的BeanFactoryPostProcessor的beanName到orderedPostProcessorNames

            else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {

// orderedPostProcessorNames.add(ppName);

                orderedPostProcessor.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));

            } else {

                // 添加剩下的普通BeanFactoryPostProcessor的beanName到nonOrderedPostProcessorNames

// nonOrderedPostProcessorNames.add(ppName);

                nonOrderedPostProcessorNames.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));

            }

        }

        // First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.

        // 对实现了PriorityOrdered接口的BeanFactoryPostProcessor进行排序

        sortPostProcessors(priorityOrderedPostProcessors, beanFactory);

        // 遍历实现了PriorityOrdered接口的BeanFactoryPostProcessor，执行postProcessBeanFactory方法

        invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

        // Next, invoke the BeanFactoryPostProcessors that implement Ordered.

        // 创建存放实现了Ordered接口的BeanFactoryPostProcessor集合

// List orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());

        // 遍历存放实现了Ordered接口的BeanFactoryPostProcessor名字的集合

// for (String postProcessorName : orderedPostProcessorNames) {

        // 将实现了Ordered接口的BeanFactoryPostProcessor添加到集合中

// orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));

// }

        // 对实现了Ordered接口的BeanFactoryPostProcessor进行排序操作

// sortPostProcessors(orderedPostProcessors, beanFactory);

        sortPostProcessors(orderedPostProcessor, beanFactory);

        // 遍历实现了Ordered接口的BeanFactoryPostProcessor，执行postProcessBeanFactory方法

// invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

        invokeBeanFactoryPostProcessors(orderedPostProcessor, beanFactory);

        // Finally, invoke all other BeanFactoryPostProcessors.

        // 最后，创建存放普通的BeanFactoryPostProcessor的集合

// List nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());

        // 遍历存放实现了普通BeanFactoryPostProcessor名字的集合

// for (String postProcessorName : nonOrderedPostProcessorNames) {

        // 将普通的BeanFactoryPostProcessor添加到集合中

// nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));

// }

        // 遍历普通的BeanFactoryPostProcessor，执行postProcessBeanFactory方法

// invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);

        invokeBeanFactoryPostProcessors(nonOrderedPostProcessorNames, beanFactory);

        // Clear cached merged bean definitions since the post-processors might have

        // modified the original metadata, e.g. replacing placeholders in values...

        // 清除元数据缓存（mergeBeanDefinitions、allBeanNamesByType、singletonBeanNameByType）

        // 因为后置处理器可能已经修改了原始元数据，例如，替换值中的占位符

        beanFactory.clearMetadataCache();

    }