0
点赞
收藏
分享

微信扫一扫

Spring启动流程源码之obtainFreshBeanFactory

快乐码农Alan007 2022-03-12 阅读 100
springjava

invokeBeanFactoryPostProcessors是Spring启动中一个十分重要的方法，在解析这个方法的源码之前首先我们需要先了解几个概念。

一、BeanDefinition

1.1、普通对象的实例化

我们知道普通的java文件在java运行时会先编译成.class的文件加载到jvm内存中，当我们使用的时候通过new去实例化获取到一个对象，具体如下：

1.2、Spring中bean的实例化

在Spring中实例化一个对象和普通的java文件还是有所不同的，他引入了一个BeanDefinition对象，BeanDefinition是一个接口，他的主要作用是去描述java对象的一些信息的，包括是否是单例、java对象中的方法、属性等等，可以看作是另一个.class对象。BeanDefinition的继承关系图如下：

从图上我们可以得知BeanDefinition的主要由一下几种实现：

  1. GenericBeanDefinition : 通用的bean实现，自2.5以后新加入的bean文件配置属性定义类，是ChildBeanDefinition和RootBeanDefinition更好的替代者；
  2. ​ScannedGenericBeanDefinition : 被包扫描到的bean定义；
  3. ​AnnotatedGenericBeanDefinition : 查找类注解初始化的定义；
  4. RootBeanDefinition : 代表一个从配置源（XML，Java Config等）中生成的BeanDefinition
  5. ChildBeanDefinition : 可以从父BeanDefinition中集成构造方法，属性等。

 Spring的实例化过程可以参考下图：

具体的流程和源码解析可以看我的另一篇文章【Spring】Spring中的三级缓存及循环依赖的问题

这里就不在详细对比和赘述了。 

二、invokeBeanFactoryPostProcessors

invokeBeanFactoryPostProcessors的源码在org.springframework.context.support.AbstractApplicationContext#invokeBeanFactoryPostProcessors里，解合我们之前提到的关于BeanDefinition的概念，具体解析如下：

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory{
		/**
		 * 此处通过反射调用了BeanFctory后置处理器
		 * 调用循序为：1.bean定义注册后置处理器，2.bean工厂后置处理器
		 * 也会调用getBean、doGetBean、createBean、doCreateBean等创建bean的过程
         * 注意：getBeanFactoryPostProcessors是初始化对象，里面没有内容
		 */
		PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());  // ===>
		
		//检测是否存在loadTimeWeaver
		if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
			beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
			beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
		}
}

从上面代码可以看到，invokeBeanFactoryPostProcessors里面主要实现是PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());这行代码，那么其中又做了些什么呢，我们继续看下去。

public static void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
        //保存所有后置处理器bean名称的集合
		Set<String> processedBeans = new HashSet();
		//BeanFactoryPostProcessor集合
        ArrayList regularPostProcessors;
		//BeanDefinitionRegistryPostProcessor集合
        ArrayList registryProcessors;
        int var9;
        ArrayList currentRegistryProcessors;
        String[] postProcessorNames;
		//beanFactoryPostProcessors分为BeanFactoryPostProcessor集合与BeanDefinitionRegistryPostProcessor集合
		//1.判断beanFactory是否为BeanDefinitionRegistry，普通的beanFactory是DefaultListableBeanFactory,而DefaultListableBeanFactory实现了BeanDefinitionRegistry接口，因此这边为true
        if (beanFactory instanceof BeanDefinitionRegistry) {
            BeanDefinitionRegistry registry = (BeanDefinitionRegistry)beanFactory;
            regularPostProcessors = new ArrayList();
            registryProcessors = new ArrayList();
            Iterator var6 = beanFactoryPostProcessors.iterator();

			//2.处理入参beanFactoryPostProcessors
            while(var6.hasNext()) {
                BeanFactoryPostProcessor postProcessor = (BeanFactoryPostProcessor)var6.next();
                if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
                    BeanDefinitionRegistryPostProcessor registryProcessor = (BeanDefinitionRegistryPostProcessor)postProcessor;
                    //如果是BeanDefinitionRegistryPostProcessor则直接执行BeanDefinitionRegistryPostProcessor接口的postProcessBeanDefinitionRegistry方法
					registryProcessor.postProcessBeanDefinitionRegistry(registry);
                    registryProcessors.add(registryProcessor);
                } else {
                    regularPostProcessors.add(postProcessor);
                }
            }

            currentRegistryProcessors = new ArrayList();
			//3.找出所有实现BeanDefinitionRegistryPostProcessor接口的Bean的beanName
            postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
            String[] var16 = postProcessorNames;
            var9 = postProcessorNames.length;

            int var10;
            String ppName;
            for(var10 = 0; var10 < var9; ++var10) {
                ppName = var16[var10];
				//校验是否实现了PriorityOrdered接口
                if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
					//获取对应的bean实例, 添加到currentRegistryProcessors中
                    currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                    processedBeans.add(ppName);
                }
            }
			//排序(根据是否实现PriorityOrdered(优先顺序)、Ordered(顺序)接口和order(再次之)值来排序)
            sortPostProcessors(currentRegistryProcessors, beanFactory);
            registryProcessors.addAll(currentRegistryProcessors);
			//遍历currentRegistryProcessors, 执行postProcessBeanDefinitionRegistry方法
            invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
			//清空currentRegistryProcessors
            currentRegistryProcessors.clear();
			
			//4.与上边3的流程差不多，这是这里处理的是实现Ordered接口
            postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
            var16 = postProcessorNames;
            var9 = postProcessorNames.length;

            for(var10 = 0; var10 < var9; ++var10) {
                ppName = var16[var10];
                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();
			
			//5.调用所有剩下的BeanDefinitionRegistryPostProcessors
            boolean reiterate = true;
            while(reiterate) {
                reiterate = false;
				//找出所有实现BeanDefinitionRegistryPostProcessor接口的类
                postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
                String[] var19 = postProcessorNames;
                var10 = postProcessorNames.length;

                for(int var26 = 0; var26 < var10; ++var26) {
                    String ppName = var19[var26];
					//跳过已经执行过的
                    if (!processedBeans.contains(ppName)) {
                        currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                        processedBeans.add(ppName);
                        reiterate = true;
                    }
                }

                sortPostProcessors(currentRegistryProcessors, beanFactory);
                registryProcessors.addAll(currentRegistryProcessors);
				//6.遍历currentRegistryProcessors, 执行postProcessBeanDefinitionRegistry方法
                invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
                currentRegistryProcessors.clear();
            }
			//7.调用所有BeanDefinitionRegistryPostProcessor的postProcessBeanFactory方法
            invokeBeanFactoryPostProcessors((Collection)registryProcessors, (ConfigurableListableBeanFactory)beanFactory);
            //8.最后, 调用入参beanFactoryPostProcessors中的普通BeanFactoryPostProcessor的postProcessBeanFactory方法
			invokeBeanFactoryPostProcessors((Collection)regularPostProcessors, (ConfigurableListableBeanFactory)beanFactory);
        } else {
            invokeBeanFactoryPostProcessors((Collection)beanFactoryPostProcessors, (ConfigurableListableBeanFactory)beanFactory);
        }

		//到这里 , 入参beanFactoryPostProcessors和容器中的所有BeanDefinitionRegistryPostProcessor已经全部处理完毕
		//下面开始处理容器中的所有BeanFactoryPostProcessor
		//9.找出所有实现BeanFactoryPostProcessor接口的类
        String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
		
		//用于存放实现了PriorityOrdered接口的BeanFactoryPostProcessor
        regularPostProcessors = new ArrayList();
		//用于存放实现了Ordered接口的BeanFactoryPostProcessor的beanName
        registryProcessors = new ArrayList();
		//用于存放普通BeanFactoryPostProcessor的beanName
        currentRegistryProcessors = new ArrayList();
		
        postProcessorNames = postProcessorNames;
        int var20 = postProcessorNames.length;

        String ppName;
        for(var9 = 0; var9 < var20; ++var9) {
            ppName = postProcessorNames[var9];
			//跳过已经执行过的，遍历，并将BeanFactoryPostProcessor按照实现不同接口添加到对应的集合中
            if (!processedBeans.contains(ppName)) {
                if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
                    regularPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
                } else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
                    registryProcessors.add(ppName);
                } else {
                    currentRegistryProcessors.add(ppName);
                }
            }
        }
		//10.调用所有实现PriorityOrdered接口的BeanFactoryPostProcessor
		//10.1对priorityOrderedPostProcessors排序
        sortPostProcessors(regularPostProcessors, beanFactory);
		//10.2遍历priorityOrderedPostProcessors, 执行postProcessBeanFactory方法
        invokeBeanFactoryPostProcessors((Collection)regularPostProcessors, (ConfigurableListableBeanFactory)beanFactory);
        
		List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList();
        Iterator var21 = registryProcessors.iterator();

        while(var21.hasNext()) {
            String postProcessorName = (String)var21.next();
            orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
        }
		//10.3对orderedPostProcessors排序
        sortPostProcessors(orderedPostProcessors, beanFactory);
		//10.4遍历orderedPostProcessors排序，执行postProcessBeanFactory方法
        invokeBeanFactoryPostProcessors((Collection)orderedPostProcessors, (ConfigurableListableBeanFactory)beanFactory);
		
		// 11.调用所有剩下的BeanFactoryPostProcessor
        List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList();
        Iterator var24 = currentRegistryProcessors.iterator();

        while(var24.hasNext()) {
            ppName = (String)var24.next();
			// 11.1获取postProcessorName对应的bean实例, 添加到nonOrderedPostProcessors, 准备执行
            nonOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
        }

		// 11.2 遍历nonOrderedPostProcessors, 执行postProcessBeanFactory方法
        invokeBeanFactoryPostProcessors((Collection)nonOrderedPostProcessors, (ConfigurableListableBeanFactory)beanFactory);
        // 12.清除元数据缓存（mergedBeanDefinitions、allBeanNamesByType、singletonBeanNamesByType），
		// 因为后处理器可能已经修改了原始元数据，例如， 替换值中的占位符...
		beanFactory.clearMetadataCache();
    }

由上方源码解析可知，在invokeBeanFactoryPostProcessors方法中有个条件，如果传入的beanFactory是BeanDefinitionRegistry，其主要流程如下：

  1. 遍历传入的BeanFactoryPostProcessor集合，查找类型是BeanDefinitionRegistryPostProcessor并执行，然后添加到集合中；
  2. 在容器中查找所有的实现了PriorityOrdered接口的BeanDefinitionRegistryPostProcessor集合，对后置处理器集合排序，遍历；
  3. 在容器中查找所有实现了Ordered接口的BeanDefinitionRegistryPostProcessor集合，对后置处理器集合排序，遍历，执行后置处理的postProcessBeanDefinitionRegistry方法；
  4. 在容器中查找其它（未实现排序接口）的BeanDefinitionRegistryPostProcessor并添加到集合nonOrderedPostProcessors中，对后置处理器集合排序，遍历，执行后置处理的postProcessBeanDefinitionRegistry方法；
  5. 当前所有的BeanDefinitionRegistryPostProcessor处理器的方法postProcessBeanDefinitionRegistry 执行完毕后，执行其父类postProcessBeanFactory方法；
  6. 执行所有非BeanDefinitionRegistryPostProcessor类型的后置处理器的postProcessBeanFactory方法。

如果是传入的beanFactory不是BeanDefinitionRegistry，其主要流程如下：

  1. 遍历传入的BeanFactoryPostProcessor集合，执行后置处理器的postProcessBeanFactory方法；
  2. 在容器中（beanFactory.getBeanNamesForType）查找所有的实现了PriorityOrdered接口的BeanFactoryPostProcessor集合，对后置处理器集合排序，遍历，执行后置处理；
  3. 在容器中查找所有实现了Ordered接口的BeanFactoryPostProcessor集合，对后置处理器集合排序，遍历，执行后置处理；
  4. 在容器中查找其它（未实现排序接口）的BeanFactoryPostProcessor并添加到集合nonOrderedPostProcessors中，对后置处理器集合排序，遍历，执行后置处。
  5.  注意：Spring中的BeanFactoryPostProcessor实现有多个，每个实现都有不同的作用大家可以自己翻下源码梳理，我们也可以自己实现BeanFactoryPostProcessor。

虽然invokeBeanFactoryPostProcessors中内容很多，但仔细阅读源码可以发现，整个方法主要是围绕BeanDefinitionRegistryPostProcessor 和 BeanFactoryPostProcessor两个接口来展开的，其主要作用有以下几点：

  1. 处理入参beanFactoryPostProcessors(默认是空的)中的BeanFactoryPostProcessor，即执行BeanDefinitionRegistryPostProcessor接口的postProcessBeanDefinitionRegistry方法；
  2. 处理容器中所有的BeanDefinitionRegistryPostProcessor；
  3. 处理容器中剩余的所有BeanFactoryPostProcessor。
举报

相关推荐

Spring启动流程源码之registerBeanPostProcessors

springjava

Spring源码 - 容器刷新#obtainFreshBeanFactory()

spring容器java

【Spring源码这样读】-细扒ApplicationContext之obtainFreshBeanFactory()

springjavaioc容器源码

Spring源码(三)-Spring启动流程细节

spring

Spring源码分析-启动流程浅析

springspring启动流程

Flink源码之JobManager启动流程

flink大数据

Flink源码之JobMaster启动流程

前端ajax交互

（三）elasticsearch 源码之启动流程分析

docker网络c++

Spring源码之IOC加载流程

springjava后端

Spring系列：obtainFreshBeanFactory调用链

spring
0 条评论