得到处理器后，开始调用这些扩展的处理器。

    1. public static void invokeBeanFactoryPostProcessors(
    2.   ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
    4.   // Invoke BeanDefinitionRegistryPostProcessors first, if any.
    5.   Set<String> processedBeans = new HashSet<>();
    7.   if (beanFactory instanceof BeanDefinitionRegistry) {
    8.     BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
    9.     List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
    10.     List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
    12.     for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
    13.       if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
    14.         BeanDefinitionRegistryPostProcessor registryProcessor =
    15.           (BeanDefinitionRegistryPostProcessor) postProcessor;
    16.         registryProcessor.postProcessBeanDefinitionRegistry(registry);
    17.         registryProcessors.add(registryProcessor);
    18.       }
    19.       else {
    20.         regularPostProcessors.add(postProcessor);
    21.       }
    22.     }
    24.     // Do not initialize FactoryBeans here: We need to leave all regular beans
    25.     // uninitialized to let the bean factory post-processors apply to them!
    26.     // Separate between BeanDefinitionRegistryPostProcessors that implement
    27.     // PriorityOrdered, Ordered, and the rest.
    28.     List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();
    30.     // First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
    31.     String[] postProcessorNames =
    32.       beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
    33.     for (String ppName : postProcessorNames) {
    34.       if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
    35.         currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
    36.         processedBeans.add(ppName);
    37.       }
    38.     }
    39.     sortPostProcessors(currentRegistryProcessors, beanFactory);
    40.     registryProcessors.addAll(currentRegistryProcessors);
    41.     invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
    42.     currentRegistryProcessors.clear();
    44.     // Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
    45.     postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
    46.     for (String ppName : postProcessorNames) {
    47.       if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
    48.         currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
    49.         processedBeans.add(ppName);
    50.       }
    51.     }
    52.     sortPostProcessors(currentRegistryProcessors, beanFactory);
    53.     registryProcessors.addAll(currentRegistryProcessors);
    54.     invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
    55.     currentRegistryProcessors.clear();
    57.     // Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
    58.     boolean reiterate = true;
    59.     while (reiterate) {
    60.       reiterate = false;
    61.       postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
    62.       for (String ppName : postProcessorNames) {
    63.         if (!processedBeans.contains(ppName)) {
    64.           currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
    65.           processedBeans.add(ppName);
    66.           reiterate = true;
    67.         }
    68.       }
    69.       sortPostProcessors(currentRegistryProcessors, beanFactory);
    70.       registryProcessors.addAll(currentRegistryProcessors);
    71.       invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
    72.       currentRegistryProcessors.clear();
    73.     }
    75.     // Now, invoke the postProcessBeanFactory callback of all processors handled so far.
    76.     invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
    77.     invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
    78.   }
    80.   else {
    81.     // Invoke factory processors registered with the context instance.
    82.     invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
    83.   }
    85.   // Do not initialize FactoryBeans here: We need to leave all regular beans
    86.   // uninitialized to let the bean factory post-processors apply to them!
    87.   String[] postProcessorNames =
    88.     beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
    90.   // Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
    91.   // Ordered, and the rest.
    92.   List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
    93.   List<String> orderedPostProcessorNames = new ArrayList<>();
    94.   List<String> nonOrderedPostProcessorNames = new ArrayList<>();
    95.   for (String ppName : postProcessorNames) {
    96.     if (processedBeans.contains(ppName)) {
    97.       // skip - already processed in first phase above
    98.     }
    99.     else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
    100.       priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
    101.     }
    102.     else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
    103.       orderedPostProcessorNames.add(ppName);
    104.     }
    105.     else {
    106.       nonOrderedPostProcessorNames.add(ppName);
    107.     }
    108.   }
    110.   // First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
    111.   sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
    112.   invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
    114.   // Next, invoke the BeanFactoryPostProcessors that implement Ordered.
    115.   List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
    116.   for (String postProcessorName : orderedPostProcessorNames) {
    117.     orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
    118.   }
    119.   sortPostProcessors(orderedPostProcessors, beanFactory);
    120.   invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
    122.   // Finally, invoke all other BeanFactoryPostProcessors.
    123.   List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
    124.   for (String postProcessorName : nonOrderedPostProcessorNames) {
    125.     nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
    126.   }
    127.   invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
    129.   // Clear cached merged bean definitions since the post-processors might have
    130.   // modified the original metadata, e.g. replacing placeholders in values...
    131.   beanFactory.clearMetadataCache();
    132. }

    这块代码很长，但是分开以后看，每块做的事情很清楚，如下章节。