Spring中refresh分析之invokeBeanFactoryPostProcessors方法詳解

關聯博文：

AbstractApplicationContext中refresh方法詳解Spring中refresh分析之prepareRefresh方法詳解

Spring中refresh分析之obtainFreshBeanFactory方法詳解

Spring中refresh分析之prepareBeanFactory方法詳解

Spring中refresh分析之postProcessBeanFactory方法詳解

Spring中refresh分析之invokeBeanFactoryPostProcessors方法詳解

Spring中refresh分析之registerBeanPostProcessors方法詳解

Spring中refresh分析之initMessageSource方法詳解

Spring中refresh分析之initApplicationEventMulticaster方法詳解

Spring中refresh分析之onRefresh方法詳解

Spring中refresh分析之registerListeners方法詳解

Spring中refresh分析之finishBeanFactoryInitialization方法詳解

Spring中refresh分析之finishRefresh方法詳解

接上文Spring中refresh分析之postProcessBeanFactory方法詳解我們分析過postProcessBeanFactory後，本文分析invokeBeanFactoryPostProcessors方法。

方法功能總結：該方法執行後，DefaultListableBeanFactory中的beanDefinitionMap就擁有了系統中的BeanDefinition ！

關于BeanFactoryPostProcessors的更多介紹可以參考博文：

Spring中那些BeanFactoryPostProcessors詳解（一）Spring中那些BeanFactoryPostProcessors詳解（二）

【1】前言

在單例bean執行個體化前，執行個體化并調用所有注冊的BeanFactoryPostProcessor，如果給定了order，則遵循順序。注意哦，不是BeanPostProcessor。

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
  PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());

  // Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime
  // (e.g. through an @Bean method registered by ConfigurationClassPostProcessor)
  if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
    beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
    beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
  }
}

如上代碼所示首先調用

invokeBeanFactoryPostProcessors

，然後判斷是否有oadTimeWeaver 有則注冊LoadTimeWeaverAwareProcessor到bean後置處理器集合并為beanFactory設定tempClassLoader。

LoadTimeWeaver是加載時織入，是AspectJ領域的東西。在Java 語言中，從織入切面的方式上來看，存在三種織入方式：編譯期織入、類加載期織入和運作期織入。編譯期織入是指在Java編譯期，采用特殊的編譯器，将切面織入到Java類中；而類加載期織入則指通過特殊的類加載器，在類位元組碼加載到JVM時，織入切面；運作期織入則是采用CGLib工具或JDK動态代理進行切面的織入。

AspectJ采用編譯期織入和類加載期織入的方式織入切面，是語言級的AOP實作，提供了完備的AOP支援。它用AspectJ語言定義切面，在編譯期或類加載期将切面織入到Java類中。

AspectJ提供了兩種切面織入方式，第一種通過特殊編譯器，在編譯期，将AspectJ語言編寫的切面類織入到Java類中，可以通過一個Ant或Maven任務來完成這個操作；第二種方式是類加載期織入，也簡稱為LTW（Load Time Weaving）。

① 什麼是BeanFactoryPostProcessor？

這裡我們首先有個問題，什麼是

BeanFactoryPostProcessor

？其是一個工廠鈎子，允許自定義修改bean定義并調整其屬性值。

BeanFactoryPostProcessor

可以與

BeanDefinition

互動并對其進行修改，但是不能與bean執行個體進行互動。這樣做可能會導緻過早執行個體化bean，導緻意外的副作用。如果需要bean執行個體互動，請考慮實作BeanPostProcessor。

注冊

ApplicationContext

自動在其維護的吧

beanDefinitionMap

中檢測

BeanFactoryPostProcessor

，并在建立任何其他bean之前應用它們。

BeanFactoryPostProcessor

也可以通過程式設計方式注冊到

ConfigurableApplicationContext

。

排序

ApplicationContext

自動檢測到的

BeanFactoryPostProcessor

将會根據其

PriorityOrdered

或者

Ordered

語義對其進行排序。

相對的，通過程式設計方式注冊到

ConfigurableApplicationContext

的

BeanFactoryPostProcessor

将會遵循注冊的順序，這時将會忽略PriorityOrdered或者Ordered的語義。

此外，

BeanFactoryPostProcessor

Bean 不考慮@Order注解的應用。

如下所示，其是一個功能性接口，隻有一個方法postProcessBeanFactory。該方法允許在bean factory執行個體化後、bean定義已經被加載但是沒有被執行個體化前覆寫或添加屬性，甚至是對渴望初始化的bean。

@FunctionalInterface
public interface BeanFactoryPostProcessor {

  void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;

}

注冊，如果自定義服務實作了該接口在方法裡面觸發了getBean，那麼會導緻Bean的過早執行個體化，可能會引起不可預知錯誤。

本文beanFactoryPostProcessors 有如下所示三個：

{SharedMetadataReaderFactoryContextInitializer$CachingMetadataReaderFactoryPostProcessor@5199} 
{ConfigurationWarningsApplicationContextInitializer$ConfigurationWarningsPostProcessor@5200} 
{ConfigFileApplicationListener$PropertySourceOrderingPostProcessor@5201}

注意哦，這三個是在refresh前通過

context.addBeanFactoryPostProcessor()

注冊到

DefaultListableBeanFactory

的

List<BeanFactoryPostProcessor> beanFactoryPostProcessors

中的。

② BeanDefinitionRegistryPostProcessor

為什麼我們這裡又繼續提到了

BeanDefinitionRegistryPostProcessor

？因為在方法

invokeBeanFactoryPostProcessors

中首先就判斷目前bean是否為

BeanDefinitionRegistry

。而

BeanDefinitionRegistryPostProcessor

從名字上看，就聯想到其是處理

BeanDefinitionRegistry

的。

BeanDefinitionRegistry是Spring的bean工廠包中唯一一個封裝bean定義注冊的接口，其提供了beandefinition的注冊、移除和查找、擷取與統計。

BeanDefinitionRegistryPostProcessor

繼承自

BeanFactoryPostProcessor

提供了

postProcessBeanDefinitionRegistry

方法。其是對标準BeanFactoryPostProcessor SPI的擴充，允許在正常

BeanFactoryPostProcessor

檢測開始之前注冊進一步的bean定義。尤其是，

BeanDefinitionRegistryPostProcessor

可以注冊更多的bean定義，這些定義反過來定義

BeanFactoryPostProcessor

執行個體。

postProcessBeanDefinitionRegistry

方法允許在标準初始化之後修改應用程式上下文的内部bean定義系統資料庫。這時已加載所有正常bean定義，但尚未執行個體化任何bean。允許在下一個後處理階段開始之前添加更多的bean定義。

比如MapperScannerConfigurer、ConfigurationClassPostProcessor均實作了BeanDefinitionRegistryPostProcessor接口。

【2】核心方法invokeBeanFactoryPostProcessors

這裡觸發的是

PostProcessorRegistrationDelegate

的

invokeBeanFactoryPostProcessors

方法。

public static void invokeBeanFactoryPostProcessors(
        ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {

    // Invoke BeanDefinitionRegistryPostProcessors first, if any.
    // 記錄已經處理過的Bean
    Set<String> processedBeans = new HashSet<>();

    // 判斷是否為 BeanDefinitionRegistry
    // 這裡DefaultListableBeanFactory 實作了 BeanDefinitionRegistry
    if (beanFactory instanceof BeanDefinitionRegistry) {
        BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;

// 建立了兩個 List 集合, 用來存放處理器
// BeanDefinitionRegistryPostProcessor 是 BeanFactoryPostProcessor 的子接口
//還可以額外處理 BeanDefinition, 添加 BeanDefinition
        List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
        List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();

// 循環 beanFactoryPostProcessors
// beanFactoryPostProcessors 是使用 API context.addBeanFactoryPostProcessor 添加進來的，與getBean檢索不同
        for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {

            // BeanDefinitionRegistryPostProcessor 要單獨添加到 registryProcessors
            if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
                BeanDefinitionRegistryPostProcessor registryProcessor =
                        (BeanDefinitionRegistryPostProcessor) postProcessor;

                // 處理 Bean 的資訊
                registryProcessor.postProcessBeanDefinitionRegistry(registry);
                registryProcessors.add(registryProcessor);
            } else {
            // 正常的BeanFactoryPostProcessor 
                regularPostProcessors.add(postProcessor);
            }
        }

        // Do not initialize FactoryBeans here: We need to leave all regular beans
        // uninitialized to let the bean factory post-processors apply to them!
        // Separate between BeanDefinitionRegistryPostProcessors that implement
        // PriorityOrdered, Ordered, and the rest.

// 先執行實作了 PriorityOrdered接口的，然後是 Ordered 接口的，最後執行剩下的
// currentRegistryProcessors 記錄目前符合判斷條件将要被執行的
        List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();

        // First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
// 第一步先調用實作了PriorityOrdered的BeanDefinitionRegistryPostProcessors

// 從容器中查找BeanDefinitionRegistryPostProcessor
// true表示包括非單例，false表示不允許早期/急切初始化
        String[] postProcessorNames =
                beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
        for (String ppName : postProcessorNames) {
        // 判斷是否實作了PriorityOrdered接口
            if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
                // 添加 bean到currentRegistryProcessors
                currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                // 這裡隻添加了名字 後面用來判斷誰已經執行過了
                processedBeans.add(ppName);
            }
        }
        // 排序
        sortPostProcessors(currentRegistryProcessors, beanFactory);
        // 放到registryProcessors中
        registryProcessors.addAll(currentRegistryProcessors);

        // 循環執行 processors 的 postProcessBeanDefinitionRegistry 方法
        invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
        // 清空currentRegistryProcessors
        currentRegistryProcessors.clear();

        // Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
// 再次檢索BeanDefinitionRegistryPostProcessor，因為其本身可能引入新的BeanDefinitionRegistryPostProcessor
        postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
        // 處理實作 Ordered 的 processor
        for (String ppName : postProcessorNames) {
            // 隻有不包含的才執行, 執行完之後會添加進 processedBeans
            if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
                currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                processedBeans.add(ppName);
            }
        }
        // 排序
        sortPostProcessors(currentRegistryProcessors, beanFactory);
        // 放到registryProcessors
        registryProcessors.addAll(currentRegistryProcessors);
// 循環調用BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry
        invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
        // 清空currentRegistryProcessors
        currentRegistryProcessors.clear();

        // Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
        // 最後執行其他
        boolean reiterate = true;
        while (reiterate) {
            reiterate = false;
            postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
            for (String ppName : postProcessorNames) {
                // 隻有不包含的才執行, 執行完之後會添加進 processedBeans
                if (!processedBeans.contains(ppName)) {
                    currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                    processedBeans.add(ppName);
                    reiterate = true;
                }
            }
            sortPostProcessors(currentRegistryProcessors, beanFactory);
            registryProcessors.addAll(currentRegistryProcessors);
            // 比如MapperScannerConfigurer就是在前面被引入，這裡會檢測出來
            invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
            currentRegistryProcessors.clear();
        }

        // Now, invoke the postProcessBeanFactory callback of all processors handled so far.
// 上面處理的都是 postProcessBeanDefinitionRegistry 是在 -> BeanDefinitionRegistryPostProcessor 中
// 下面開始處理 postProcessBeanFactory  -> 是在 BeanFactoryPostProcessor 中
        invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
        invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
    } else {
        // Invoke factory processors registered with the context instance.
        // 不是 BeanDefinitionRegistry 則是普通 BeanFactory 直接執行 beanFactoryPostProcessors 即可
        invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
    }

    // Do not initialize FactoryBeans here: We need to leave all regular beans
    // uninitialized to let the bean factory post-processors apply to them!

    // 第二部分--處理BeanFactoryPostProcessor
    String[] postProcessorNames =
            beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

    // Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
    // Ordered, and the rest.
    // 分成三個部分 PriorityOrdered Ordered及其他
    List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
    List<String> orderedPostProcessorNames = new ArrayList<>();
    List<String> nonOrderedPostProcessorNames = new ArrayList<>();
    for (String ppName : postProcessorNames) {
        if (processedBeans.contains(ppName)) {
            // skip - already processed in first phase above
            // 說明上面已經執行了, 下面忽略
        } else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
            priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
        } else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
            orderedPostProcessorNames.add(ppName);
        } else {
            nonOrderedPostProcessorNames.add(ppName);
        }
    }

    // First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
    // 執行實作 PriorityOrdered 的
    sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
    invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

    // Next, invoke the BeanFactoryPostProcessors that implement Ordered.
    List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
    for (String postProcessorName : orderedPostProcessorNames) {
        orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
    }
    sortPostProcessors(orderedPostProcessors, beanFactory);
    invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

    // Finally, invoke all other BeanFactoryPostProcessors.
    List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
    for (String postProcessorName : nonOrderedPostProcessorNames) {
        nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
    }
    invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);

    // Clear cached merged bean definitions since the post-processors might have
    // modified the original metadata, e.g. replacing placeholders in values...
    // 清空不必要的中繼資料資訊
    beanFactory.clearMetadataCache();
}

方法大緻我們分為兩個部分，以

String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

語句為分割線，其上屬于第一部分，其下屬于第二部分。

第一部分

第一部分分為兩塊，如果目前BeanFactory是BeanDefinitionRegistry執行個體則進行已經複雜的處理。否則直接調用invokeBeanFactoryPostProcessors。

我們來梳理一下BeanFactory是BeanDefinitionRegistry執行個體時流程：

建立兩個list， regularPostProcessors 和 registryProcessors ；
循環周遊 beanFactoryPostProcessors ，如果其是 BeanDefinitionRegistryPostProcessor 類型則調用 postProcessBeanDefinitionRegistryf 方法并放到 registryProcessors 中，否則放到 regularPostProcessors 中。
掃描容器中的 BeanDefinitionRegistryPostProcessor ，分成 PriorityOrdered 、 Ordered 和 其他 三個部分，對每一部分都進行排序然後觸發每個執行個體的 postProcessBeanDefinitionRegistry 方法。
最後對 registryProcessors 和 regularPostProcessors 兩個集合所有執行個體的postProcessBeanFactory方法進行執行。

第二部分

第一部分可以簡單了解其是處理的

BeanDefinitionRegistryPostProcessor

執行個體的

postProcessBeanDefinitionRegistry

方法和

postProcessBeanFactory

方法。第二部分則是處理其父接口BeanFactoryPostProcessor的postProcessBeanFactory方法。

其從容器中掃描BeanFactoryPostProcessor然後分為三個部分：PriorityOrdered、Ordered和其他。對每一部分進行排序然後調用其postProcessBeanFactory方法。

beanFactoryPostProcessors來源

SharedMetadataReaderFactoryContextInitializer的initialize方法。

@Override
public void initialize(ConfigurableApplicationContext applicationContext) {
  applicationContext.addBeanFactoryPostProcessor(new CachingMetadataReaderFactoryPostProcessor());
}

ConfigurationWarningsApplicationContextInitializer的initialize方法。

@Override
public void initialize(ConfigurableApplicationContext context) {
  context.addBeanFactoryPostProcessor(new ConfigurationWarningsPostProcessor(getChecks()));
}

ConfigFileApplicationListener的addPostProcessors方法。

protected void addPostProcessors(ConfigurableApplicationContext context) {
  context.addBeanFactoryPostProcessor(new PropertySourceOrderingPostProcessor(context));
}

這三個方法均是在prepareContext方法中觸發的，此時還沒有進行refresh。

【3】CachingMetadataReaderFactoryPostProcessor

CachingMetadataReaderFactoryPostProcessor

是

SharedMetadataReaderFactoryContextInitializer

的靜态内部類，實作了

BeanDefinitionRegistryPostProcessor

和

PriorityOrdered

接口。

private static class CachingMetadataReaderFactoryPostProcessor
    implements BeanDefinitionRegistryPostProcessor, PriorityOrdered {

  @Override
  public int getOrder() {
    // Must happen before the ConfigurationClassPostProcessor is created
    // Integer.MIN_VALUE
    return Ordered.HIGHEST_PRECEDENCE;
  }

  @Override
  public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
  }

  @Override
  public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
    register(registry);
    configureConfigurationClassPostProcessor(registry);
  }

// 注冊SharedMetadataReaderFactoryBean BeanDefinition
  private void register(BeanDefinitionRegistry registry) {
    BeanDefinition definition = BeanDefinitionBuilder
        .genericBeanDefinition(SharedMetadataReaderFactoryBean.class, SharedMetadataReaderFactoryBean::new)
        .getBeanDefinition();
    // internalCachingMetadataReaderFactory-definition 
    registry.registerBeanDefinition(BEAN_NAME, definition);
  }

  private void configureConfigurationClassPostProcessor(BeanDefinitionRegistry registry) {
    try {
      BeanDefinition definition = registry
          .getBeanDefinition(AnnotationConfigUtils.CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME);
// internalConfigurationAnnotationProcessor添加metadataReaderFactory=internalCachingMetadataReaderFactory
      definition.getPropertyValues().add("metadataReaderFactory", new RuntimeBeanReference(BEAN_NAME));
    }
    catch (NoSuchBeanDefinitionException ex) {
    }
  }

}

可以看到其postProcessBeanDefinitionRegistry方法做了兩件事：

注冊 BeanDefinition：internalCachingMetadataReaderFactory — SharedMetadataReaderFactoryBean ；
擷取 internalConfigurationAnnotationProcessor 的BeanDefinition為其添加屬性值 metadataReaderFactory — new RuntimeBeanReference(internalCachingMetadataReaderFactory)

SharedMetadataReaderFactoryBean

也是

SharedMetadataReaderFactoryContextInitializer

的靜态内部類，如下所示其維護了一個metadataReaderFactory成員。

static class SharedMetadataReaderFactoryBean
    implements FactoryBean<ConcurrentReferenceCachingMetadataReaderFactory>, BeanClassLoaderAware,
    ApplicationListener<ContextRefreshedEvent> {

  private ConcurrentReferenceCachingMetadataReaderFactory metadataReaderFactory;

  @Override
  public void setBeanClassLoader(ClassLoader classLoader) {
    this.metadataReaderFactory = new ConcurrentReferenceCachingMetadataReaderFactory(classLoader);
  }
  //...
}

如下所示這裡擷取的

internalConfigurationAnnotationProcessor

的

BeanDefinition

是

ConfigurationClassPostProcessor

。

Spring中refresh分析之invokeBeanFactoryPostProcessors方法詳解

【4】ConfigurationClassPostProcessor

ConfigurationClassPostProcessor

做了什麼事情呢？如下所示其實作了

BeanDefinitionRegistryPostProcessor

和

PriorityOrdered

及其他三個XXXAware接口。

public class ConfigurationClassPostProcessor implements BeanDefinitionRegistryPostProcessor,
    PriorityOrdered, ResourceLoaderAware, BeanClassLoaderAware, EnvironmentAware {
    //....
}

其核心是用來處理@Configuration标注的配置類！這個ConfigurationClassPostProcessor 後處理器是按優先級排序的，因為在

@Configuration

配置類中聲明的任何

@Bean

方法都必須在任何其他BeanFactoryPostProcessor執行之前注冊相應的Bean定義，這一點很重要。

其postProcessBeanDefinitionRegistry方法如下所示，其首先對registry進行判斷是否已經處理過，沒有處理過則調用

processConfigBeanDefinitions(registry);

方法。

@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
  int registryId = System.identityHashCode(registry);
  if (this.registriesPostProcessed.contains(registryId)) {
    throw new IllegalStateException(
        "postProcessBeanDefinitionRegistry already called on this post-processor against " + registry);
  }
  if (this.factoriesPostProcessed.contains(registryId)) {
    throw new IllegalStateException(
        "postProcessBeanFactory already called on this post-processor against " + registry);
  }
  this.registriesPostProcessed.add(registryId);
//處理配置bean定義
  processConfigBeanDefinitions(registry);
}

對于候選配置類使用CGLIB Enhancer增強
解析處理@PropertySource 注解
解析@ComponentScan注解,掃描@Configuration、@Service、@Controller、@Repository和@Component注解并注冊BeanDefinition
解析@Import注解,然後進行執行個體化,并執行ImportBeanDefinitionRegistrar的registerBeanDefinitions邏輯,或者ImportSelector的selectImports邏輯
解析@ImportResource注解,并加載相關配置資訊
解析方法級别@Bean注解并将傳回值注冊成BeanDefinition
注冊ImportAwareBeanPostProcessor到容器中,用于處理ImportAware

Spring中refresh分析之invokeBeanFactoryPostProcessors方法詳解

【1】前言

① 什麼是BeanFactoryPostProcessor？

② BeanDefinitionRegistryPostProcessor

【2】核心方法invokeBeanFactoryPostProcessors

beanFactoryPostProcessors來源

【3】CachingMetadataReaderFactoryPostProcessor

【4】ConfigurationClassPostProcessor

繼續閱讀

JAVA自學之路——馬士兵

Rabbitmq指令行手動建立隊列

整合 Spring 開發架構及服務端技術

SSM整合02---Spring-SpringMVC層一、添加web架構支援二、web.xml三、spring-mvc.xml

SSM架構（二）------------表現層的SpringMVC

Intellij idea基于Maven 的SSM 架構整合

PAT (Advanced Level) Practise 1131 Subway Map (30)

ZOJ 3938 Defuse the Bomb

CSU 1565 Word Cloud

ZOJ 3700 Ever Dream

ZOJ 1199 Point of Intersection

CSU 1567 Reverse Rot

Spring資料和Redis

SpringMVC的啟動過程源碼分析1 SpringMVC 配置XML的方式啟動2 SpringMVC純注解模式啟動

Java Spring 架構

SpringCloud微服務（四）之ribbon筆記ribbon是什麼？入門案例自定義均衡負載算法