spring 源码 refresh() 中的方法 invokeBeanFactoryPostProcessors(beanFactory) 解析（五）

你的名字 2023-10-07 13:08 15阅读 0赞

前面已经通过

ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory(); 方法

解析了，spring各种标签 、创建工厂、注解扫描等，现在我们接着往下介绍其他方法

1、先来到 refresh 方法

@Override
    public void refresh() throws BeansException, IllegalStateException {
       synchronized (this.startupShutdownMonitor) {
        //删除已经介绍过的部分代码

ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();//这个重要方法上篇已经介绍过
          /*
          * 这个给beanFactory设置一些属性值，简单了解一下，可以不用重点看，
          * */
          prepareBeanFactory(beanFactory);
          try {
             // 允许在上下文子类中对bean工厂进行后置处理。可以简单了解一下。
             postProcessBeanFactory(beanFactory);
             /*
             * BeanDefinitionRegistryPostProcessor
             * BeanFactoryPostProcessor
             * 完成对这两个接口的调用  调用上下文并注册为bean的工厂处理器
              1、调用实现了 PriorityOrdered 排序接口 
              2、调用实现了 Ordered 排序接口 
              3、获取 BeanDefinitionRegistry 对象，
               从而可以获取这个对象中注册的所有 BeanDefinition 对象，
                我们拥有这个对象就可以完成里面所有 BeanDefinition 对象的增删改操作
               这个方法今天可以重点看一下，点击进入
             * */
             invokeBeanFactoryPostProcessors(beanFactory);
    
             /*
             * 把实现了BeanPostProcessor接口的类实例化，并且加入到BeanFactory中
               注册拦截bean创建的bean处理器
             * */
             registerBeanPostProcessors(beanFactory);
    
             //国际化 设置，可以简单看看
             initMessageSource();
    
             //初始化事件管理类
             initApplicationEventMulticaster();
    
             //这个方法目前是空方法、着重理解模板设计模式，因为在springboot中，这个方法是用来做内嵌tomcat启动的
             onRefresh();
          
           //往事件管理类中注册事件类
             registerListeners();
    
        //删除今天不解析的代码
         
    }

2、invokeBeanFactoryPostProcessors(beanFactory)

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()));
       }
    }

这里先实现 BeanDefinitionRegistryPostProcessor 接口，后续业务会用

import com.enjoy.jack.bean.BeanDefinitionBean;
    import org.springframework.beans.BeansException;
    import org.springframework.beans.MutablePropertyValues;
    import org.springframework.beans.factory.config.BeanDefinition;
    import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
    import org.springframework.beans.factory.support.BeanDefinitionRegistry;
    import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor;
    import org.springframework.beans.factory.support.DefaultListableBeanFactory;
    import org.springframework.beans.factory.support.GenericBeanDefinition;
    import org.springframework.core.Ordered;
    import org.springframework.core.PriorityOrdered;
    import org.springframework.stereotype.Component;
    
     
    //@Import(ImportAwareClass.class)
    @Component
    //@Service
    //@Controller
    //@Repository
    //@Configuration
    public class BeanPro implements BeanDefinitionRegistryPostProcessor, PriorityOrdered, Ordered {
       //可以对 BeanDefinition 对象的增删改查
        @Override
        public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
            //查询BeanDefinition
            final String[] beanDefinitionNames = registry.getBeanDefinitionNames();
            for (String beanDefinitionName : beanDefinitionNames) {
                BeanDefinition beanDefinition = registry.getBeanDefinition(beanDefinitionName);
                System.out.println(beanDefinition);
            }
    
            GenericBeanDefinition genericBeanDefinition = new GenericBeanDefinition();
            genericBeanDefinition.setBeanClass(BeanDefinitionBean.class);
            MutablePropertyValues propertyValues = genericBeanDefinition.getPropertyValues();
            propertyValues.add("name","Jack");
            registry.registerBeanDefinition("beanDefinitionBean",genericBeanDefinition);
    
    
    //        ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(registry);
    //        //需要过滤的注解
    //        scanner.addIncludeFilter(new AnnotationTypeFilter(MyService.class));
    //        scanner.scan("com.enjoy.jack.customBean");
        }
    
        @Override
        public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
            BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
            String[] beanDefinitionNames = registry.getBeanDefinitionNames();
    
            DefaultListableBeanFactory beanFactory1 = (DefaultListableBeanFactory)beanFactory;
            beanFactory1.setAllowBeanDefinitionOverriding(true);
            beanFactory1.setAllowCircularReferences(true);
            beanFactory1.setAllowRawInjectionDespiteWrapping(true);
        }
    
        @Override
        public int getOrder() {
            return 0;
        }
    }

3、PostProcessorRegistrationDelegate 这个类

public static void invokeBeanFactoryPostProcessors(
          ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
    
       //设置一个非重集合
       Set<String> processedBeans = new HashSet<>();
    
       if (beanFactory instanceof BeanDefinitionRegistry) {
          BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
          List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
          List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
    
          for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
             if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
                BeanDefinitionRegistryPostProcessor registryProcessor =
                      (BeanDefinitionRegistryPostProcessor) postProcessor;
                registryProcessor.postProcessBeanDefinitionRegistry(registry);
                registryProcessors.add(registryProcessor);
             }
             else {
                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.
          List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();
    
          //获取实现了BeanDefinitionRegistryPostProcessor接口的所有类的BeanDefinition对象的beanName
          // First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
          String[] postProcessorNames =
                beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
          for (String ppName : postProcessorNames) {
             //判断是否实现了排序接口 PriorityOrdered
             if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
                currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                processedBeans.add(ppName);
             }
          }
    
          //排序
          sortPostProcessors(currentRegistryProcessors, beanFactory);
          registryProcessors.addAll(currentRegistryProcessors);
    
          //调用过程
          invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
          currentRegistryProcessors.clear();
    
          // Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
          postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
          for (String ppName : postProcessorNames) {
    
             //判断是否是实现的Ordered接口
             if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
                currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                processedBeans.add(ppName);
             }
          }
          sortPostProcessors(currentRegistryProcessors, beanFactory);
          registryProcessors.addAll(currentRegistryProcessors);
          invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
          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) {
                if (!processedBeans.contains(ppName)) {
                   currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                   processedBeans.add(ppName);
                   reiterate = true;
                }
             }
             sortPostProcessors(currentRegistryProcessors, beanFactory);
             registryProcessors.addAll(currentRegistryProcessors);
             //
             invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
             currentRegistryProcessors.clear();
          }
    
          //调用postProcessBeanFactory方法
          // Now, invoke the postProcessBeanFactory callback of all processors handled so far.
          invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
          invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
       }
    
       else {
          // Invoke factory processors registered with the context instance.
          invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
       }
    
       //获取实现了BeanFactoryPostProcessor接口的类，获取beanDefinition的名称
       // Do not initialize FactoryBeans here: We need to leave all regular beans
       // uninitialized to let the bean factory post-processors apply to them!
       String[] postProcessorNames =
             beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
    
       // Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
       // Ordered, and the rest.
       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
          }
          //实现了PriorityOrdered接口的
          else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
             priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
          }
          //实现了Ordered接口的
          else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
             orderedPostProcessorNames.add(ppName);
          }
          else {
             //没实现接口的
             nonOrderedPostProcessorNames.add(ppName);
          }
       }
    
       //排序
       // First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
       sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
    
       //调用
       invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
    
       // Next, invoke the BeanFactoryPostProcessors that implement Ordered.
       List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>();
       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<>();
       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();
    }

获取所有实现接口 BeanDefinitionRegistryPostProcessor 的类：

![5354bdbea52b4bd58828ad652ecfb330.png][]

实现 PriorityOrdered 接口：

![3edf00a4f2e44f69b688c4ffc6fe1664.png][] 进入：

private static void invokeBeanDefinitionRegistryPostProcessors(
    			Collection<? extends BeanDefinitionRegistryPostProcessor> postProcessors, BeanDefinitionRegistry registry) {
    
    		for (BeanDefinitionRegistryPostProcessor postProcessor : postProcessors) {
    			postProcessor.postProcessBeanDefinitionRegistry(registry);
    		}
    	}

如图

![a864388230634396aba32ffaa5e48bf6.png][]

马上进入到 BeanPro 类的 postProcessBeanDefinitionRegistry 方法

![601f23c139e64f4080666b36127deb67.png][]

下面实现 Ordered 接口的同理，这里就不在演示了。

调用 postProcessBeanFactory 接口：

![88fef37cc6b640d0aaaf3782feb9bbd2.png][]

进入：

private static void invokeBeanFactoryPostProcessors(
    			Collection<? extends BeanFactoryPostProcessor> postProcessors, ConfigurableListableBeanFactory beanFactory) {
    
    		for (BeanFactoryPostProcessor postProcessor : postProcessors) {
    			postProcessor.postProcessBeanFactory(beanFactory);//核心接口
    		}
    	}

循环进入两个类的实现方法。

这个方法大家整体看一下，这里主要证明可以对 BeanDefinition 对象增删改查操作。

4、下面进入下一个环节

/*
    				 * 把实现了BeanPostProcessor接口的类实例化，并且加入到BeanFactory中
    				 * */
    				registerBeanPostProcessors(beanFactory);

点击 registerBeanPostProcessors(beanFactory);方法进入

protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
       PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);//继续点击
    }

4、来到 PostProcessorRegistrationDelegate

public static void registerBeanPostProcessors(
          ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
    
       //拿到工程里面所有实现了BeanPostProcessor接口的类，获取到BeanDefinition的名称
       String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
    
       // Register BeanPostProcessorChecker that logs an info message when
       // a bean is created during BeanPostProcessor instantiation, i.e. when
       // a bean is not eligible for getting processed by all BeanPostProcessors.
       int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
       beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
    
       // Separate between BeanPostProcessors that implement PriorityOrdered,
       // Ordered, and the rest.
       List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
       List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
       List<String> orderedPostProcessorNames = new ArrayList<>();
       List<String> nonOrderedPostProcessorNames = new ArrayList<>();
    
       //提前实例化BeanPostProcessor类型的bean，然后bean进行排序
       for (String ppName : postProcessorNames) {
          if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
    
             //getBean是实例化方法，后面我们在讲bean实例化过程是会着重详细讲到
             BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
             priorityOrderedPostProcessors.add(pp);
    
             //判断类型是否是MergedBeanDefinitionPostProcessor，如果是则代码是内部使用的
             if (pp instanceof MergedBeanDefinitionPostProcessor) {
                internalPostProcessors.add(pp);
             }
          }
          else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
             orderedPostProcessorNames.add(ppName);
          }
          else {
             nonOrderedPostProcessorNames.add(ppName);
          }
       }
    
       // First, register the BeanPostProcessors that implement PriorityOrdered.
       sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
    
       //注册到BeanFactory中
       registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
    
       // Next, register the BeanPostProcessors that implement Ordered.
       List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>();
       for (String ppName : orderedPostProcessorNames) {
          BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
          orderedPostProcessors.add(pp);
          if (pp instanceof MergedBeanDefinitionPostProcessor) {
             internalPostProcessors.add(pp);
          }
       }
       sortPostProcessors(orderedPostProcessors, beanFactory);
       registerBeanPostProcessors(beanFactory, orderedPostProcessors);
    
       // Now, register all regular BeanPostProcessors.
       List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
       for (String ppName : nonOrderedPostProcessorNames) {
          BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
          nonOrderedPostProcessors.add(pp);
          if (pp instanceof MergedBeanDefinitionPostProcessor) {
             internalPostProcessors.add(pp);
          }
       }
       registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
    
       // Finally, re-register all internal BeanPostProcessors.
       sortPostProcessors(internalPostProcessors, beanFactory);
       registerBeanPostProcessors(beanFactory, internalPostProcessors);
    
       // Re-register post-processor for detecting inner beans as ApplicationListeners,
       // moving it to the end of the processor chain (for picking up proxies etc).
       beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
    }

大家整体看一下，先有个印象、便于后面使用。还有下面四个方法，大家先简单看一下，下一篇，我们讲解spring 最核心的一个方法：finishBeanFactoryInitialization(beanFactory);敬请期待！

[5354bdbea52b4bd58828ad652ecfb330.png]: https://img-blog.csdnimg.cn/5354bdbea52b4bd58828ad652ecfb330.png
[3edf00a4f2e44f69b688c4ffc6fe1664.png]: https://img-blog.csdnimg.cn/3edf00a4f2e44f69b688c4ffc6fe1664.png
[a864388230634396aba32ffaa5e48bf6.png]: https://img-blog.csdnimg.cn/a864388230634396aba32ffaa5e48bf6.png
[601f23c139e64f4080666b36127deb67.png]: https://img-blog.csdnimg.cn/601f23c139e64f4080666b36127deb67.png
[88fef37cc6b640d0aaaf3782feb9bbd2.png]: https://img-blog.csdnimg.cn/88fef37cc6b640d0aaaf3782feb9bbd2.png