Bean后置處理器 - BeanPostProcessor#postProcessBeforeInitialization

代碼片段:

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsBeforeInitialization

@Override
public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
        throws BeansException {

    Object result = existingBean;
    for (BeanPostProcessor processor : getBeanPostProcessors()) {
        Object current = processor.postProcessBeforeInitialization(result, beanName);
        if (current == null) {
            return result;
        }
        result = current;
    }
    return result;
}

這里能滿足的后置處理器, 就比較多了. 調試一下看看:

 

 

 有6個能滿足條件, 一個一個來看

 

ApplicationContextAwareProcessor

這個后置處理器, 主要是用來處理一些 Aware 的.

//bean初始化方法調用之前執行此方法, 此處主要是對以下幾個 *Aware 進行處理, 調用這些 *Aware 定義的接口方法
@Override
@Nullable
public Object postProcessBeforeInitialization(final Object bean, String beanName) throws BeansException {
    AccessControlContext acc = null;

    if (System.getSecurityManager() != null &&
            (bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware ||
                    bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware ||
                    bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware)) {
        acc = this.applicationContext.getBeanFactory().getAccessControlContext();
    }

    if (acc != null) {
        AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
            invokeAwareInterfaces(bean);
            return null;
        }, acc);
    }
    else {
        invokeAwareInterfaces(bean);
    }

    return bean;
}

這里主要看invokeAwareIntefaces方法:

private void invokeAwareInterfaces(Object bean) {
    if (bean instanceof Aware) {
        if (bean instanceof EnvironmentAware) {
            ((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
        }
        if (bean instanceof EmbeddedValueResolverAware) {
            ((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver);
        }
        if (bean instanceof ResourceLoaderAware) {
            ((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);
        }
        if (bean instanceof ApplicationEventPublisherAware) {
            ((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);
        }
        if (bean instanceof MessageSourceAware) {
            ((MessageSourceAware) bean).setMessageSource(this.applicationContext);
        }
        //spring幫你set一個applicationContext對象
        //所以當我們自己的一個對象實現了ApplicationContextAware對象只需要提供setter就能得到applicationContext對象
        if (bean instanceof ApplicationContextAware) {
            ((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
        }
    }
}

 

ConfigurationClassPostProcessor$ImportAwareBeanPostProcessor

@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) {
    if (bean instanceof ImportAware) {
        ImportRegistry ir = this.beanFactory.getBean(IMPORT_REGISTRY_BEAN_NAME, ImportRegistry.class);
        AnnotationMetadata importingClass = ir.getImportingClassFor(bean.getClass().getSuperclass().getName());
        if (importingClass != null) {
            ((ImportAware) bean).setImportMetadata(importingClass);
        }
    }
    return bean;
}

這里主要是注入 ImportAware 的. 也是一種 Aware. 

 

PostProcessorRegistrationDelegate$BeanPostProcessorChecker

//初始化之前, 不做任何處理
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) {
    return bean;
}

這里不做任何處理, 后面貌似, 也只是打印了個日志.

 

CommonAnnotationBeanPostProcessor

其實現由父類完成:

org.springframework.beans.factory.annotation.InitDestroyAnnotationBeanPostProcessor#postProcessBeforeInitialization

@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
    LifecycleMetadata metadata = findLifecycleMetadata(bean.getClass());
    try {
        metadata.invokeInitMethods(bean, beanName);
    }
    catch (InvocationTargetException ex) {
        throw new BeanCreationException(beanName, "Invocation of init method failed", ex.getTargetException());
    }
    catch (Throwable ex) {
        throw new BeanCreationException(beanName, "Failed to invoke init method", ex);
    }
    return bean;
}

findLifecycleMetadata 在 MergedBeanDefinitionPostProcessor 的時候, 就執行過了. 這里也是相當於從緩存中拿取.

拿到 @PostConstructor 對應的方法集合, 進行循環調用.

這里能看到 @PostConstructor 的調用時機, 是初始化(invokeInitMethods - 這里面會調用InitializingBean#afterPropertiesSet() 和用戶自定義的init-method初始化方法 )之前.

 

AutowiredAnnotationBeanPostProcessor

由父類實現:

org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessorAdapter#postProcessBeforeInitialization

@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
    return bean;
}

里面啥也沒干

 

ApplicationListenerDetector

@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) {
    return bean;
}

這里也是啥也沒干

 

從這里看, 雖然他有6個后置處理器, 但是真正起作用的, 就一下幾個:

1. ApplicationContextAwareProcessor - 處理幾個 Aware

2. ConfigurationClassPostProcessor$ImportAwareBeanPostProcessor - 處理 ImportAware

3. CommonAnnotationBeanPostProcessor - 調用 @PostConstructor 對於方法集