Spring技术内幕：Ioc容器【阅读笔记】

用着spring当然得懂核心技术以及原理啦~~~
话不多说，开干！不定期增加内容。

本文源码来自于spring 5.2.0.BUILD-SNAPSHOT

spring 核心实现

什么是IoC

一个引用自https://www.zhihu.com/question/23277575的故事

我开了一家薯条店，底下有一百家分店
一开始我懒，让分店自己去炸薯条，反正只要他们按照统一的配方来就好，比如油温170度，炸两分钟
有一天我突然发现油温169度炸出来的薯条更好次，kao！我得打100个电话，告诉分店经理改配方！（就是你要改很多处代码）
有了这次教训，我觉得让总店（就是Spring容器）来统一炸好薯条，然后送到各个分店去，要吃的时候再拿出来炸热一下就ok了
本来是分店自己决定怎么炸薯条的，虽然我给了他们配方，但是最终决定权在他们手上，他们偷偷少炸几秒钟、少放点油，我都管不着，现在我霸道了，把炸薯条权收归中央，这不就是控制反转（IOC）了吗？换个角度讲，现在分店的薯条，都是我总店炸好送过去的，分店依赖总店的薯条，这不就是依赖注入了吗？

Spring的IoC容器系列

　　IoC容器为开发者管理对象之间的依赖关系提供了很多便利和基础服务。有许多IoC容器供开发者选择，其实对IoC容器的使用者来说，我们经常接触到的BeanFactory和ApplicationContext都可以看成是容易的具体表现形式。如果深入到Spring的实现中区看，我们通常所说的IoC容器，实际上代表着一系列功能各异的容器产品，只是容器的功能有大有小，有各自的特点。

　　以百货商店出售水桶为例,如果把IoC容易看成一个水桶，那么这个BeanFactory就定义了可以作为水桶的基本功能，比如至少能装水，有个提手等。对于Spring的具体IoC容易实现来说，他需要满足基本的基本特性是什么呢？它需要满足BeanFactory这个基本的接口定义，它是作为一个最基本的接口类出现在Spring的IoC容易体系中的。

Spring IoC容器设计

从接口BeanFactory---HierarchicalBeanFactory---ConfigurableBeanFactory，是一条主要的BeanFactory设计路径。ConfigurableBeanFactory还继承了SingletonBeanFactory使得它活的了Bean的注册功能。通过这些接口设计的叠加，定义了BeanFactory就是简单的IOC容器的基本功能。
第二条接口设计主线是以ApplicationContext应用上下文接口为核心的接口设计，从BeanFactory---ListableBeanFactory---ApplicationContext---WebApplicationContext（ConfigurableApplicationContext）。
具体的IoC容器都是在以上的接口体系下实现的，比如DefaultListableBeanFactory，实现了ConfigurableBeanFactory，从而成为一个简单IoC容器的实现。其他的如XmlBeanFactory，都是在DefaultListableBeanFactory的基础上做扩展，ApplicationContext也是如此。
BeanFactory是IoC容器最基本的接口，提供的是最基本的IoC容器的功能，比如getBean、containsBean等，其他高级IoC容器接口再在此基础功能上进行扩展

public interface BeanFactory {
    String FACTORY_BEAN_PREFIX = "&";
    Object getBean(String name) throws BeansException;
    <T> T getBean(String name, Class<T> requiredType) throws BeansException;
    Object getBean(String name, Object... args) throws BeansException;
    <T> T getBean(Class<T> requiredType) throws BeansException;
    <T> T getBean(Class<T> requiredType, Object... args) throws BeansException;
    <T> ObjectProvider<T> getBeanProvider(Class<T> requiredType);
    <T> ObjectProvider<T> getBeanProvider(ResolvableType requiredType);
    boolean containsBean(String name);//判断容器中是否存在bean
    //查询指定名字的bean是否是Singleton类型的bean
    boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
    //查询指定名字的bean是否是prototype类型
    boolean isPrototype(String name) throws NoSuchBeanDefinitionException;
    boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;
    boolean isTypeMatch(String name, Class<?> typeToMatch) throws NoSuchBeanDefinitionException;
    //查询指定名字的Bean的Class类型
    Class<?> getType(String name) throws NoSuchBeanDefinitionException;
    String[] getAliases(String name);//查询指定名字的Bean的所有别名
}

　　通过这一系列的BeanFactory接口，可以使用不用的Bean的检索方法，很方便的从IoC容器中得到需要的Bean，从而忽略具体的IoC容器的实现，从这个角度上看，这些检索方法代表的是最基本的容器入口。

BeanFactory容器的设计原理

　　从XmlBeanFactory的实现入手进行分析，来看看一个基本的IoC容器是怎样实现的。

　　XmlBeanFactory继承自DefaultListableBeanFactory。

public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory
        implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {

　　DefaultListableBeanFactory它是整个Spring IoC的始祖。Spring把这个类作为一个默认的功能完整的IoC容器来使用。

- DefaultListableBeanFactory功能的实现是通过实现特定功能的接口来完成。

- AbstractAutowireCapableBeanFactory 实现属性的自动绑定功能。

- ConfigurableListableBeanFactory提供了对bean定义的分析和修改的便利方法，同时也提供了对单例的预实例化。

- ListableBeanFactory提供枚举所有的bean实例，而不是客户端通过名称一个一个的查询得出所有的实例。

- BeanDefinitionRegistry 提供了beanDefinition的管理。

　XmlBeanFactory在继承了DefaultListableBeanFactory容器的功能的同事，增加了新的功能，增加了XML的解析功能。

public class XmlBeanFactory extends DefaultListableBeanFactory {
    //通过XmlBeanDefinitionReader 扩展对xml资源的解析功能
    private final XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(this);

    /**
     * 构造方法需要指定xml的资源地址
     */
    public XmlBeanFactory(Resource resource) throws BeansException {
        this(resource, null);
    }
    /**
     * 通过XmlBeanDefinitionReader对资源进行解析
     */
    public XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory) throws BeansException {
        super(parentBeanFactory);
        this.reader.loadBeanDefinitions(resource);
    }
}

　　我们看xmlBeanFactory使用了DefaultListableBeanFactory作为基类，DefaultListableBeanFactory是很重要的一个IoC实现，在其他IoC容易中，比如ApplicationContext，其其实的基本原理和XmlBeanFactory一样，也是通过持有或者扩展DefaultListableBeanFactory来获得基本的IoC容器的功能的。

　　参考XMLBeanFactory的实现，我们以编程的方式使用DefaultListableBeanFactory。从中我们可以看到IoC容器使用的一些基本过程。尽管我们在应用中使用IoC容器的很少会使用这些原始方式，但是了解一些这个基本过程，对我们了解IoC容器的那些关键类之间的相互关系，例如他们是如何把IoC容器的功能解耦，又是如何结合在一起为IoC容器服务的。

编程使用IoC容器：

        ClassPathResource res = new ClassPathResource("bean.xml");
        DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
        XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(factory);
        reader.loadBeanDefinitions(res);

ApplicationContext的设计原理

　　我们以常用的FileSystemXmlApplicationContext的实现为例说明ApplicationContext容器的设计原理。FileSystemXmlApplicationContext应用上下文的主要功能已经在基类中实现了，在FileSystemXmlApplicationContext中，只需要实现和它自身设计相关的两个功能

对于实例化这个应用上下文的支持，同事启动IoC容器的refresh()过程

    public FileSystemXmlApplicationContext(
            String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)
            throws BeansException {

        super(parent);
        setConfigLocations(configLocations);
        if (refresh) {
            refresh();
        }
    }//这个refresh方法过程会牵扯IoC容器启动的一系列复杂的操作，同事，对于不同的容器实现，这些操作都是类似的，因此在基类中将他们分装好

为在文件系统中读取XML形式存在的资源做准备，因此不同的应用上下文实现对应着不同的资源定位方式

    protected Resource getResourceByPath(String path) {
        if (path.startsWith("/")) {
            path = path.substring(1);
        }
        return new FileSystemResource(path);
    }//调用这个方法，可以得到资源定位

IoC容器的初始化过程

　　简单的来说，IoC容器的初始化是由前边介绍的refresh()方法来启动的，这个方法标志着IoC容器的正式启动，具体来说，这个启动的过程包括BeanDefinition的Resource定位，载入和注册三个基本过程。这个三个过程分别使用了不同的模块来完成，如使用相应的ResourceLoader、BeanDefinitionReader等。通过这样的方式可以让用户更加灵活地对这三个过程进行剪裁和扩展，定义出最适合自己的IoC容器初始化过程。

我们看到FileSystemeXmlApplicationContext已经通过继承AbstractApplicationContext具备了ResourceLoader读入Resource定义的BeanDefinition的能力。

refresh()方法解

public void refresh() throws BeansException, IllegalStateException {
        synchronized (this.startupShutdownMonitor) {
            // 准备刷新上下文环境
            prepareRefresh();
            // 创建并初始化 BeanFactory
            ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
            // 填充BeanFactory功能
            prepareBeanFactory(beanFactory);
            try {
                // 设置BeanFactory的后置处理
                postProcessBeanFactory(beanFactory);
                // 激活各种BeanFactory处理器
                invokeBeanFactoryPostProcessors(beanFactory);
                // 注册拦截Bean创建的Bean处理器，即注册 BeanPostProcessor
                registerBeanPostProcessors(beanFactory);
                // 初始化上下文中的资源文件，如国际化文件的处理等
                initMessageSource();
                // 初始化上下文事件广播器
                initApplicationEventMulticaster();
                // 给子类扩展初始化其他Bean
                onRefresh();
                // 在所有bean中查找listener bean，然后注册到广播器中
                registerListeners();
                // 初始化剩下的单例Bean(非延迟加载的)
                finishBeanFactoryInitialization(beanFactory);
                // 完成刷新过程,通知生命周期处理器lifecycleProcessor刷新过程,同时发出ContextRefreshEvent通知别人
                finishRefresh();
            }catch (BeansException ex) {
                if (logger.isWarnEnabled()) {
                    logger.warn("Exception encountered during context initialization - " +
                            "cancelling refresh attempt: " + ex);
                }
                //  销毁已经创建的Bean
                destroyBeans();
                // 重置容器激活标签
                cancelRefresh(ex);
                // 抛出异常
                throw ex;
            }
            finally {
                // Reset common introspection caches in Spring's core, since we
                // might not ever need metadata for singleton beans anymore...
                resetCommonCaches();
            }
        }
    }

prepareRefresh()

初始化上下文环境，对系统的环境变量或者系统属性进行准备和校验,如环境变量中必须设置某个值才能运行，否则不能运行，这个时候可以在这里加这个校验，重写initPropertySources方法就好了

protected void prepareRefresh() {
       // 设置启动日期
        this.startupDate = System.currentTimeMillis();
        // 设置 context 当前状态
        this.closed.set(false);
        this.active.set(true);

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

        // 初始化context environment（上下文环境）中的占位符属性来源
        initPropertySources();

        // 对属性进行必要的验证
        getEnvironment().validateRequiredProperties();

        this.earlyApplicationEvents = new LinkedHashSet<>();
    }

该方法主要是做一些准备工作，如：

设置 context 启动时间
设置 context 的当前状态
初始化 context environment 中占位符
对属性进行必要的验证

obtainFreshBeanFactory()

创建并初始化 BeanFactory

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
       // 刷新 BeanFactory
        refreshBeanFactory();
        // 获取 BeanFactory
        ConfigurableListableBeanFactory beanFactory = getBeanFactory();
        if (logger.isDebugEnabled()) {
            logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
        }
        return beanFactory;
    }

核心方法就在 refreshBeanFactory() ，该方法的核心任务就是创建 BeanFactory 并对其就行一番初始化。如下：

   protected final void refreshBeanFactory() throws BeansException {
        if (hasBeanFactory()) {
            destroyBeans();
            closeBeanFactory();
        }
        try {
            DefaultListableBeanFactory beanFactory = createBeanFactory();
            beanFactory.setSerializationId(getId());
            customizeBeanFactory(beanFactory);
            loadBeanDefinitions(beanFactory);
            synchronized (this.beanFactoryMonitor) {
                this.beanFactory = beanFactory;
            }
        }
        catch (IOException ex) {
            throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
        }
    }

判断当前容器是否存在一个 BeanFactory，如果存在则对其进行销毁和关闭
调用 createBeanFactory() 创建一个 BeanFactory 实例，其实就是 DefaultListableBeanFactory
自定义 BeanFactory
加载 BeanDefinition
将创建好的 bean 工厂的引用交给的 context 来管理

上面 5 个步骤，都是比较简单的，但是有必要讲解下第 4 步：加载 BeanDefinition。如下：

ClassPathResource resource = new ClassPathResource("bean.xml");
DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(factory);
reader.loadBeanDefinitions(resource);

只不过这段代码的 loadBeanDefinitions() 是定义在 BeanDefinitionReader 中，而此处的 loadBeanDefinitions() 则是定义在 AbstractRefreshableApplicationContext 中，如下：

   protected abstract void loadBeanDefinitions(DefaultListableBeanFactory beanFactory)
            throws BeansException, IOException

由具体的子类实现，我们以 AbstractXmlApplicationContext 为例，实现如下：

    protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
        // Create a new XmlBeanDefinitionReader for the given BeanFactory.
        XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);

        // Configure the bean definition reader with this context's
        // resource loading environment.
        beanDefinitionReader.setEnvironment(this.getEnvironment());
        beanDefinitionReader.setResourceLoader(this);
        beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));

        // Allow a subclass to provide custom initialization of the reader,
        // then proceed with actually loading the bean definitions.
        initBeanDefinitionReader(beanDefinitionReader);
        loadBeanDefinitions(beanDefinitionReader);
    }

新建 XmlBeanDefinitionReader 实例对象 beanDefinitionReader，调用 initBeanDefinitionReader() 对其进行初始化，然后调用 loadBeanDefinitions() 加载 BeanDefinition。

    protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
        Resource[] configResources = getConfigResources();
        if (configResources != null) {
            reader.loadBeanDefinitions(configResources);
        }
        String[] configLocations = getConfigLocations();
        if (configLocations != null) {
            reader.loadBeanDefinitions(configLocations);
        }
    }

到这里我们发现，其实内部依然是调用 BeanDefinitionReader#loadBeanDefinitionn() 进行 BeanDefinition 的加载进程。

prepareBeanFactory(beanFactory)

填充 BeanFactory 功能

上面获取获取的 BeanFactory 除了加载了一些 BeanDefinition 就没有其他任何东西了，这个时候其实还不能投入生产，因为还少配置了一些东西，比如 context的 ClassLoader 和后置处理器等等。

    protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        // 设置beanFactory的classLoader
        beanFactory.setBeanClassLoader(getClassLoader());

        // 设置beanFactory的表达式语言处理器,Spring3开始增加了对语言表达式的支持,默认可以使用#{bean.xxx}的形式来调用相关属性值
        beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
        // 为beanFactory增加一个默认的propertyEditor
        beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

        // 添加ApplicationContextAwareProcessor
        beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
        // 设置忽略自动装配的接口
        beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
        beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
        beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
        beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
        beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
        beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);

        // 设置几个自动装配的特殊规则
        beanFactory.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.
        beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

        // 增加对AspectJ的支持
        if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
            beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
            // Set a temporary ClassLoader for type matching.
            beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
        }

        // 注册默认的系统环境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());
        }
    }

看上面的源码知道这个就是对 BeanFactory 设置各种各种的功能。

postProcessBeanFactory()

提供子类覆盖的额外处理，即子类处理自定义的BeanFactoryPostProcess

invokeBeanFactoryPostProcessors()

激活各种BeanFactory处理器

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

        // 定义一个 set 保存所有的 BeanFactoryPostProcessors
        Set<String> processedBeans = new HashSet<>();

        // 如果当前 BeanFactory 为 BeanDefinitionRegistry
        if (beanFactory instanceof BeanDefinitionRegistry) {
            BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
            // BeanFactoryPostProcessor 集合
            List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
            // BeanDefinitionRegistryPostProcessor 集合
            List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();

            // 迭代注册的 beanFactoryPostProcessors
            for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
                // 如果是 BeanDefinitionRegistryPostProcessor，则调用 postProcessBeanDefinitionRegistry 进行注册，
                // 同时加入到 registryProcessors 集合中
                if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
                    BeanDefinitionRegistryPostProcessor registryProcessor =
                            (BeanDefinitionRegistryPostProcessor) postProcessor;
                    registryProcessor.postProcessBeanDefinitionRegistry(registry);
                    registryProcessors.add(registryProcessor);
                }
                else {
                    // 否则当做普通的 BeanFactoryPostProcessor 处理
                    // 添加到 regularPostProcessors 集合中即可，便于后面做后续处理
                    regularPostProcessors.add(postProcessor);
                }
            }

            // 用于保存当前处理的 BeanDefinitionRegistryPostProcessor
            List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();

            // 首先处理实现了 PriorityOrdered (有限排序接口)的 BeanDefinitionRegistryPostProcessor
            String[] postProcessorNames =
                    beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
            for (String ppName : postProcessorNames) {
                if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
                    currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                    processedBeans.add(ppName);
                }
            }

            // 排序
            sortPostProcessors(currentRegistryProcessors, beanFactory);

            // 加入registryProcessors集合
            registryProcessors.addAll(currentRegistryProcessors);

            // 调用所有实现了 PriorityOrdered 的 BeanDefinitionRegistryPostProcessors 的 postProcessBeanDefinitionRegistry()
            invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);

            // 清空，以备下次使用
            currentRegistryProcessors.clear();

            // 其次，调用是实现了 Ordered（普通排序接口）的 BeanDefinitionRegistryPostProcessors
            // 逻辑和 上面一样
            postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
            for (String ppName : postProcessorNames) {
                if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
                    currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                    processedBeans.add(ppName);
                }
            }
            sortPostProcessors(currentRegistryProcessors, beanFactory);
            registryProcessors.addAll(currentRegistryProcessors);
            invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
            currentRegistryProcessors.clear();

            // 最后调用其他的 BeanDefinitionRegistryPostProcessors
            boolean reiterate = true;
            while (reiterate) {
                reiterate = false;
                // 获取 BeanDefinitionRegistryPostProcessor
                postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
                for (String ppName : postProcessorNames) {

                    // 没有包含在 processedBeans 中的（因为包含了的都已经处理了）
                    if (!processedBeans.contains(ppName)) {
                        currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                        processedBeans.add(ppName);
                        reiterate = true;
                    }
                }

                // 与上面处理逻辑一致
                sortPostProcessors(currentRegistryProcessors, beanFactory);
                registryProcessors.addAll(currentRegistryProcessors);
                invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
                currentRegistryProcessors.clear();
            }

            // 调用所有 BeanDefinitionRegistryPostProcessor (包括手动注册和通过配置文件注册)
            // 和 BeanFactoryPostProcessor(只有手动注册)的回调函数(postProcessBeanFactory())
            invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
            invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
        }

        else {
            // 如果不是 BeanDefinitionRegistry 只需要调用其回调函数（postProcessBeanFactory()）即可
            invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
        }

        //
        String[] postProcessorNames =
                beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

        // 这里同样需要区分 PriorityOrdered 、Ordered 和 no Ordered
        List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
        List<String> orderedPostProcessorNames = new ArrayList<>();
        List<String> nonOrderedPostProcessorNames = new ArrayList<>();
        for (String ppName : postProcessorNames) {
            // 已经处理过了的，跳过
            if (processedBeans.contains(ppName)) {
                // skip - already processed in first phase above
            }
            // PriorityOrdered
            else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
                priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
            }
            // Ordered
            else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
                orderedPostProcessorNames.add(ppName);
            }
            // no Ordered
            else {
                nonOrderedPostProcessorNames.add(ppName);
            }
        }

        // First, PriorityOrdered 接口
        sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
        invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

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

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

        // Clear cached merged bean definitions since the post-processors might have
        // modified the original metadata, e.g. replacing placeholders in values...
        beanFactory.clearMetadataCache();
    }

上述代码较长，但是处理逻辑较为单一，就是对所有的 BeanDefinitionRegistryPostProcessors 、手动注册的 BeanFactoryPostProcessor 以及通过配置文件方式的 BeanFactoryPostProcessor 按照 PriorityOrdered 、 Ordered、no ordered 三种方式分开处理、调用。

registerBeanPostProcessors

注册拦截Bean创建的Bean处理器，即注册 BeanPostProcessor

与 BeanFactoryPostProcessor 一样，也是委托给 PostProcessorRegistrationDelegate 来实现的。

    public static void registerBeanPostProcessors(
            ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {

        // 所有的 BeanPostProcessors
        String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

        // 注册 BeanPostProcessorChecker
        // 主要用于记录一些 bean 的信息，这些 bean 不符合所有 BeanPostProcessors 处理的资格时
        int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
        beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

        // 区分 PriorityOrdered、Ordered 、 no ordered
        List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
        List<String> orderedPostProcessorNames = new ArrayList<>();
        List<String> nonOrderedPostProcessorNames = new ArrayList<>();
        // MergedBeanDefinition
        List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
        for (String ppName : postProcessorNames) {
            if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
                BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
                priorityOrderedPostProcessors.add(pp);
                if (pp instanceof MergedBeanDefinitionPostProcessor) {
                    internalPostProcessors.add(pp);
                }
            }
            else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
                orderedPostProcessorNames.add(ppName);
            }
            else {
                nonOrderedPostProcessorNames.add(ppName);
            }
        }

        // First, PriorityOrdered
        sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
        registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

        // Next, Ordered
        List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>();
        for (String ppName : orderedPostProcessorNames) {
            BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
            orderedPostProcessors.add(pp);
            if (pp instanceof MergedBeanDefinitionPostProcessor) {
                internalPostProcessors.add(pp);
            }
        }
        sortPostProcessors(orderedPostProcessors, beanFactory);
        registerBeanPostProcessors(beanFactory, orderedPostProcessors);

        // onOrdered
        List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
        for (String ppName : nonOrderedPostProcessorNames) {
            BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
            nonOrderedPostProcessors.add(pp);
            if (pp instanceof MergedBeanDefinitionPostProcessor) {
                internalPostProcessors.add(pp);
            }
        }
        registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

        // Finally, all internal BeanPostProcessors.
        sortPostProcessors(internalPostProcessors, beanFactory);
        registerBeanPostProcessors(beanFactory, internalPostProcessors);

        // 重新注册用来自动探测内部ApplicationListener的post-processor，这样可以将他们移到处理器链条的末尾
        beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
    }

initMessageSource

初始化上下文中的资源文件，如国际化文件的处理等

initApplicationEventMulticaster

初始化上下文事件广播器

onRefresh

给子类扩展初始化其他Bean

预留给 AbstractApplicationContext 的子类用于初始化其他特殊的 bean，该方法需要在所有单例 bean 初始化之前调用

registerListeners

在所有 bean 中查找 listener bean，然后注册到广播器中

finishBeanFactoryInitialization

初始化剩下的单例Bean(非延迟加载的)

finishRefresh

完成刷新过程,通知生命周期处理器 lifecycleProcessor 刷新过程,同时发出 ContextRefreshEvent 通知别人

IoC容器的依赖注入

posted @ 2019-11-20 10:55 啊慌阅读(136) 评论(0) 收藏举报

刷新页面返回顶部

大豚豚双优

Spring技术内幕：Ioc容器【阅读笔记】

spring 核心实现

什么是IoC

Spring的IoC容器系列

Spring IoC容器设计

BeanFactory容器的设计原理

ApplicationContext的设计原理

IoC容器的初始化过程

refresh()方法解

prepareRefresh()

obtainFreshBeanFactory()

prepareBeanFactory(beanFactory)

postProcessBeanFactory()

invokeBeanFactoryPostProcessors()

registerBeanPostProcessors

initMessageSource

initApplicationEventMulticaster

onRefresh

registerListeners

finishBeanFactoryInitialization

finishRefresh

IoC容器的依赖注入

公告

大豚豚双优

Spring技术内幕：Ioc容器 【阅读笔记】

spring 核心实现

什么是IoC

Spring的IoC容器系列

Spring IoC容器设计

BeanFactory容器的设计原理

ApplicationContext的设计原理

IoC容器的初始化过程

refresh()方法解

prepareRefresh()

obtainFreshBeanFactory()

prepareBeanFactory(beanFactory)

postProcessBeanFactory()

invokeBeanFactoryPostProcessors()

registerBeanPostProcessors

initMessageSource

initApplicationEventMulticaster

onRefresh

registerListeners

finishBeanFactoryInitialization

finishRefresh

IoC容器的依赖注入

公告

Spring技术内幕：Ioc容器【阅读笔记】