spring源码-BeanPostProcessor

1 BeanPostProcessor是bean的实例化之前和之后对bean做一些更改

2 BeanFactoryPostProcessor是在beandefinition的时候对它的一些修改，就是属于bean的初始化阶段

3 bean的生命周期是首先.java文件变成一个class文件 经过类加载器加到jvm中成为一个class对象，然后变成一个bd这就是初始化阶段 后面再进行实例化变成一个bean，中间还会有生命周期的回调 这伴随着实例化的过程就是通过一个个BeanPostProcessor来完成的，下面详细介绍

1 第一次是过滤掉不需要代理（例如aspect类型的类）或者已经被代理的类，有些类会提前aop,只是我一直还没找到应用场景，有知道的可以告诉我

try {
            beanInstance = this.resolveBeforeInstantiation(beanName, mbdToUse);
            if (beanInstance != null) {
                return beanInstance;
            }
        }

2 第二次是在创建的bean的时候需要推断用哪个构造器

 @Nullable
    protected Constructor[] determineConstructorsFromBeanPostProcessors(@Nullable Class beanClass, String beanName) throws BeansException {
        if (beanClass != null && this.hasInstantiationAwareBeanPostProcessors()) {
            Iterator var3 = this.getBeanPostProcessors().iterator();

            while(var3.hasNext()) {
                BeanPostProcessor bp = (BeanPostProcessor)var3.next();
                if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
                    SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor)bp;
                    Constructor[] ctors = ibp.determineCandidateConstructors(beanClass, beanName);
                    if (ctors != null) {
                        return ctors;
                    }
                }
            }
        }

        return null;
    }

3 第三次是合并bd,因为bd之间有继承关系，要变成rootBeandifinition

protected void applyMergedBeanDefinitionPostProcessors(RootBeanDefinition mbd, Class beanType, String beanName) {
        Iterator var4 = this.getBeanPostProcessors().iterator();

        while(var4.hasNext()) {
            BeanPostProcessor bp = (BeanPostProcessor)var4.next();
            if (bp instanceof MergedBeanDefinitionPostProcessor) {
                MergedBeanDefinitionPostProcessor bdp = (MergedBeanDefinitionPostProcessor)bp;
                bdp.postProcessMergedBeanDefinition(mbd, beanType, beanName);
            }
        }

    }

4 第四次是ioc的时候收集需要注入的元数据

PropertyValues pvsToUse = ibp.postProcessProperties((PropertyValues)pvs, bw.getWrappedInstance(), beanName);

5 第五次是在initializeBean方法里会调用所有beanpostprocessor前置处理方法

 if (mbd == null || !mbd.isSynthetic()) {
            wrappedBean = this.applyBeanPostProcessorsBeforeInitialization(bean, beanName);
        }

6 第六次是在initializeBean方法里会调用所有beanpostprocessor后置处理方法，比较经典的就是这里会生成aop（有的话）

if (mbd == null || !mbd.isSynthetic()) {
            wrappedBean = this.applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
        }

1 aop具体生成逻辑,@EnableAspectJAutoProxy注解里的AspectJAutoProxyRegistrar会生成这样一个bd

  if (registry.containsBeanDefinition("org.springframework.aop.config.internalAutoProxyCreator")) {
            BeanDefinition definition = registry.getBeanDefinition("org.springframework.aop.config.internalAutoProxyCreator");
            definition.getPropertyValues().add("proxyTargetClass", Boolean.TRUE);
        }

最终会实例化成一个AbstractAutoProxyCreator，这就是一个beanPostprocessor，在后置处理会生成aop对象