程式碼片段:

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 對於方法集