Spring注解驱动开发--扩展原理BeanFactoryPostProcessor

前言

　　前面的几篇文章中我们看到了 Spring 中后置处理器所扮演的强大角色，提到 BeanPostProcessor 子接口可以大致分为两类，分别在实例化bean和初始化bean中起着强大的作用（具体请查看AOP原理篇两者的比较）。今天我们再认识另外的一种后置处理器 BeanFactoryPostProcessor 。

BeanFactoryPostProcessor

@FunctionalInterface
public interface BeanFactoryPostProcessor {

    /**
     * Modify the application context's internal bean factory after its standard
     * initialization. All bean definitions will have been loaded, but no beans
     * will have been instantiated yet. This allows for overriding or adding
     * properties even to eager-initializing beans.
     * @param beanFactory the bean factory used by the application context
     * @throws org.springframework.beans.BeansException in case of errors
     */
    void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;

}

BeanFactoryPostProcessor 是在 BeanFactory 标准初始化之后调用，来定制和修改 BeanFactory 的内容；

所有的bean定义已经保存加载到beanFactory，但是bean的实例还未创建，
自定义 BeanFactoryPostProcessor 

@Component
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        System.out.println("MyBeanFactoryPostProcessor...postProcessBeanFactory...");
        int count = beanFactory.getBeanDefinitionCount();
        String[] names = beanFactory.getBeanDefinitionNames();
        System.out.println("当前BeanFactory中有"+count+" 个Bean");
        System.out.println(Arrays.asList(names));
    }

}

刷新IOC容器时调用栈，如何找到所有的BeanFactoryPostProcessor并执行他们的方法；

        // Finally, invoke all other BeanFactoryPostProcessors.
        List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
　　　　//直接在BeanFactory中找到所有类型是BeanFactoryPostProcessor的组件，并执行他们的方法
        for (String postProcessorName : nonOrderedPostProcessorNames) {
            nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
        }
        invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);

所有的BeanFactoryPostProcessor后置处理器

 通过BeanDefinitionRegistryPostProcessor注册bean的定义信息

下面通过BeanDefinitionRegistryPostProcessor的注册器给容器注册组件b

@Component
public class MyBeanDefinitionRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor{

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        // TODO Auto-generated method stub
        System.out.println("MyBeanDefinitionRegistryPostProcessor...bean的数量："+beanFactory.getBeanDefinitionCount());
    }

    //BeanDefinitionRegistry Bean定义信息的保存中心，以后BeanFactory就是按照BeanDefinitionRegistry里面保存的每一个bean定义信息创建bean实例；
    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
        // TODO Auto-generated method stub
        System.out.println("postProcessBeanDefinitionRegistry...bean的数量："+registry.getBeanDefinitionCount());
        //RootBeanDefinition beanDefinition = new RootBeanDefinition(Blue.class);
        AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.rootBeanDefinition(Blue.class).getBeanDefinition();
        registry.registerBeanDefinition("hello", beanDefinition);
    }

}

                }
                sortPostProcessors(currentRegistryProcessors, beanFactory);
                registryProcessors.addAll(currentRegistryProcessors);
　　　　　　　　　　//依次触发所有的postProcessBeanDefinitionRegistry()方法
                invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
                currentRegistryProcessors.clear();
            }

            // Now, invoke the postProcessBeanFactory callback of all processors handled so far.
　　　　　　　//再来从容器中找到BeanFactoryPostProcessor组件；然后依次触发postProcessBeanFactory()方法

            invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
            invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);

总结

　 BeanPostProcessor是针对bean的初始化而设计的，BeanFactoryPostProcessor是针对beanFactory的初始化而设计的。beanFactory保存了bean的定义信息，

可以用于给容器中添加一些组件（以bean的定义的方式添加，凡是添加到beanFactory的bean的定义信息都需要实例化）。

以下来自于网路
 BeanPostProcessor：bean后置处理器，bean创建对象初始化前后进行拦截工作的
 
 1、BeanFactoryPostProcessor：beanFactory的后置处理器；
         在BeanFactory标准初始化之后调用，来定制和修改BeanFactory的内容；
         所有的bean定义已经保存加载到beanFactory，但是bean的实例还未创建
 
 
 BeanFactoryPostProcessor原理:
 1)、ioc容器创建对象
 2)、invokeBeanFactoryPostProcessors(beanFactory);
         如何找到所有的BeanFactoryPostProcessor并执行他们的方法；
             1）、直接在BeanFactory中找到所有类型是BeanFactoryPostProcessor的组件，并执行他们的方法
             2）、在初始化创建其他组件前面执行
 
 2、BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor
         postProcessBeanDefinitionRegistry();
         在所有bean定义信息将要被加载，bean实例还未创建的；
 
         优先于BeanFactoryPostProcessor执行；
         利用BeanDefinitionRegistryPostProcessor给容器中再额外添加一些组件；
 
     原理：
         1）、ioc创建对象
         2）、refresh()-》invokeBeanFactoryPostProcessors(beanFactory);
         3）、从容器中获取到所有的BeanDefinitionRegistryPostProcessor组件。
             1、依次触发所有的postProcessBeanDefinitionRegistry()方法
             2、再来触发postProcessBeanFactory()方法BeanFactoryPostProcessor；
 
         4）、再来从容器中找到BeanFactoryPostProcessor组件；然后依次触发postProcessBeanFactory()方法