【spring源码】七、后置处理器BeanPostProcessor

文章目录

- ⑥==registerBeanPostProcessors()==
- - 后置处理器的源码

spring源码系列文章地址：https://blog.csdn.net/hancoder/category_10184847.html

⑥registerBeanPostProcessors()

这篇其实没什么好说的，该说的我已经在第五篇说过了，getBean的问题我想留给后面讲。

这里的我们的最大意义就是知道实例化了后置处理器吧

由其是internalAutoProxyCreater这个后置处理器，他正常是不在我们的ac容器的bd map中的，为什么他如今到了bd map中了，从而能被实例化呢？原因是在实例化工厂后置处理器的时候由@EnableAspectJAutoProxy注解注入的（而他是由ConfigurationClassPostProcessor这个工厂后置处理器扫描到的）

我们想要了解spring在什么时候注册自动代理，即@EnableAspectJAutoProxy等一系列执行的时机。这里值得注意的是，@EnableAspectJAutoProxy的操作是在refresh()方法的invoke()阶段完成了bean定义信息的注入，而还没完成实例化。实例化是在registerBeanPostProcessor注册后置处理器阶段完成的。

public abstract class AbstractApplicationContext extends DefaultResourceLoader implements ConfigurableApplicationContext, DisposableBean {
    
    
    
    protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
    
    
        PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
    }

我们调用registerBeanPostProcessors()的时候已经能从容器中拿到bean定义了，只是还是实例化。所以我们的流程是先实例化后置处理器，再实例化普通的bean，因为普通的bean要用到后置处理器。

调用栈：

refresh()
AbstractApplicationContext.registerBeanPostProcessors()
PostProcessorRegistrationDelegate.registerBeanPostProcessors()

流程：即拿到bean定义后，通过getBean生成bean实例，然后在beanFactory中有个beanPostProcessors属是个list，我们把bean追加到这个list里即可，但要注意顺序，bean是有优先级的。

getBean步骤：

扫描二维码关注公众号，回复： 12424084 查看本文章

创建3个list用于保存3种"要创建的后置处理器"，把"beanPostProcessor定义信息"按照priorityOrdered、ordered、nonOrdered分为3类，依次add到对应的list
3个list按序调用（priorityOrdered最优先调用完）注册这些后置处理器，注册方式是通过beanFactory.getBean去获取实例
新建3个list用于保存创建好的后置处理器。创建好后置处理器实例后依次add追加到对应的3个list，调用registerBeanPostProcessors(beanFactory, orderedPostProcessors);(另外一个)把后置处理器告诉工厂是什么类型的。

后置处理器的源码

PostProcessorRegistrationDelegate类;
//注册bean的后置处理器来拦截bean的创建
public static void registerBeanPostProcessors(//前面是注册定义，这里是注册
    ConfigurableListableBeanFactory beanFactory,//DefaultListableBeanFactory@3daa422a
    AbstractApplicationContext applicationContext)//AnnotationConfigApplicationContext@38bc8ab5
{
    
    

    // 拿到指定类型的bean（后置处理器）的名字 // postProcessorNames={internalAutowiredAnnotationProcessor、internalRequiredAnnotationProcessor、internalCommonAnnotationProcessor、internalAutoProxyCreater}4个元素。只是定义还没创建对象
    // internalAutoProxyCreater是在上个阶段由@EnableAspectJAutoProxy注解注入的
    String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);//4个
    //先获取ioc容器已经定义了的需要创建对象的所有BeanPostProcessor的名字，这些对象是我们在配置类上注解的（比如我们之前的internalAutoProxyCreator），不是我们自己的
    
    // 3+1+4
    int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() //3 我们自己的
        + 1 
        + postProcessorNames.length;// 4个spring自带的后置处理器

    // 给容器中加别的postProcessor //即上面的1
    beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
    
    List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanPostProcessor>();
    List<BeanPostProcessor> internalPostProcessors = new ArrayList<BeanPostProcessor>();
    List<String> orderedPostProcessorNames = new ArrayList<String>();
    List<String> nonOrderedPostProcessorNames = new ArrayList<String>();
    for (String ppName : postProcessorNames) {
    
    //4个
        if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
    
    //优先注册实现了PriorityOrdered接口的BeanPostProcessor
            // 包括3/4个：internalAutowiredAnnotationProcessor、internalRequiredAnnotationProcessor、internalCommonAnnotationProcessor
            BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);//只有PriorityOrdered类型的才在for里注册//beanFactory为DefaultListableBeanFactory
            priorityOrderedPostProcessors.add(pp);
            if (pp instanceof MergedBeanDefinitionPostProcessor) {
    
    
                internalPostProcessors.add(pp);
            }
        }else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
    
    
            //包括1/4个：internalAutoProxyCreater
            orderedPostProcessorNames.add(ppName);//只是加在了名字的list中
        }
        else {
    
    
            nonOrderedPostProcessorNames.add(ppName);
        }
    }
    // 区分后依次注册，加入到容器中
    // First, register the BeanPostProcessors that implement PriorityOrdered.
    sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
    registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);//这个方法是我们之前说的new definition和注册创建的函数

    // ---------------------------------
    // internalAutoProxyCreater在这里getBean--------
    // Next, register the BeanPostProcessors that implement Ordered.//再注册实现了Ordered接口的BeanPostProcessor//我们的@Enable就实现了这个接口
    List<BeanPostProcessor> orderedPostProcessors = new ArrayList<BeanPostProcessor>();
    for (String ppName : orderedPostProcessorNames) {
    
    // 1/4个
        // 实例化
        BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);//getBean//按名字从beanFactory中得到BeanPostProcessor//如果获取不到就创建//注册BeanPostProcessor实际上就是创建BeanPostProcessors对象，保存在容器中。所以我们分析如何创建AnnotationAwareAspectJAutoProxyCreator类internalAutoProxyCreator名字的。
        orderedPostProcessors.add(pp);
        if (pp instanceof MergedBeanDefinitionPostProcessor) {
    
    
            internalPostProcessors.add(pp);
        }
    }
    sortPostProcessors(orderedPostProcessors, beanFactory);
    registerBeanPostProcessors(beanFactory, orderedPostProcessors);

    // ---------------------------------
    // Now, register all regular BeanPostProcessors.//再注册没有实现优先级接口的BeanPostProcessor
    List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanPostProcessor>();
    for (String ppName : nonOrderedPostProcessorNames) {
    
    // 0/4个
        BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
        nonOrderedPostProcessors.add(pp);
        if (pp instanceof MergedBeanDefinitionPostProcessor) {
    
    
            internalPostProcessors.add(pp);
        }
    }
    registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

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

    // Re-register post-processor for detecting inner beans as ApplicationListeners,
    // moving it to the end of the processor chain (for picking up proxies etc).
    beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
    
    //经测试，在这里工厂中的bean定义已经是10个了，也就是说我们bean定义信息一直在
    //((DefaultListableBeanFactory) beanFactory).alreadyCreated结果为5个，即5个internal：1个在上个阶段创建的+4个本阶段创建的
}

//-----------PostProcessorRegistrationDelegate-------------------------
private static void registerBeanPostProcessors(
    ConfigurableListableBeanFactory beanFactory, List<BeanPostProcessor> postProcessors) {
    
    
    //postProcessors依次为3个、1个、0个
    for (BeanPostProcessor postProcessor : postProcessors) {
    
    
        beanFactory.addBeanPostProcessor(postProcessor);
    }
}
//-----------AbstractBeanFactory-------------------------
@Override
public void addBeanPostProcessor(BeanPostProcessor beanPostProcessor) {
    
    
    Assert.notNull(beanPostProcessor, "BeanPostProcessor must not be null");
    //this为beanFactory
    this.beanPostProcessors.remove(beanPostProcessor);//移除旧的
    this.beanPostProcessors.add(beanPostProcessor);//重新添加新的
    if (beanPostProcessor instanceof InstantiationAwareBeanPostProcessor) {
    
    
        this.hasInstantiationAwareBeanPostProcessors = true;
    }
    if (beanPostProcessor instanceof DestructionAwareBeanPostProcessor) {
    
    
        this.hasDestructionAwareBeanPostProcessors = true;
    }
}