spring源码-3.beanFactory后处理器

其他 2020-02-23 10:44:28 阅读次数: 0

上一节我们已经讲完了beanFactory是如何初始化，并且是如何将需要注入到容器中的bean的beanDefinition注册到beanFactory中的。这一节我们再来看一下beanFactory的后处理器是如何运行的。
这里从初始化完beanFactory到beanFactory的后处理器的执行有三步：

  1. beanFactory的准备工作
  2. 自定义方法对beanFactory中的后处理器在执行前进行一些操作
  3. 解析beanFactory中的beanDefinition，如果有BeanDefinitionRegistryPostProcessor和BeanFactoryPostProcessor的实现类，那么执行其后处理器的方法

下面我们分别看一下这三步的实现：

beanFactory的准备工作

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
	// 设置classLoad，这个classLoad就是加载容器的classLoad
	beanFactory.setBeanClassLoader(getClassLoader());
	beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
	beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

	//添加一个后处理bean
	beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
	//向ignoredDependencyInterfaces中添加class
	beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
	beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
	beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
	beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
	beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
	beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);

    //设置类和autowired的名称的映射
	beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
	beanFactory.registerResolvableDependency(ResourceLoader.class, this);
	beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
	beanFactory.registerResolvableDependency(ApplicationContext.class, this);

	//添加一个后处理bean
	beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

	if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
		beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
		//设置一个临时的classLoad，用于类型匹配
		beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
	}

	// 如果容器中不存在environment，那么初始化一个默认的
	if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
		beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
	}
	if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
		beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
	}
	if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
		beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
	}
}

从上面的代码可以看出，这里就是对beanFactory在标准化初始化完成以后，一些手动的操作，例如设置classLoad,添加后处理bean，设置一些环境相关的beanDefinition等操作。

通过自定义的代码对beanFactory中内置的后处理器进行相应的操作

这里需要用户来自定义逻辑，所以源码中是一个空方法：

protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {}

执行beanFactory的后处理器

这里去解析beanFactory中的beanDefinition，看看其是否实现了BeanDefinitionRegistryPostProcessor或BeanFactoryPostProcessor，如果有实现，那么说明这个beanDefinition是一个beanFactory的后处理器，执行其处理方法。

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
    //将beanFactory（容器中的beanDefinition都在里面）和applicationCotext中的beanFactoryPostProcessors作为参数，去执行beanFactory的后处理器方法
	PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
    //这里的这一步在prepareBeanFactory已经做过了，设置一个临时的类加载器，用于类型匹配的类加载
	if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
		beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
		beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
	}
}

这里继续计入beanFactory的后处理器的方法：

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

	//初始化一个set，用于记录已经处理的beanFactory的后处理器
	Set<String> processedBeans = new HashSet<>();

    //判断beanFactory是否为BeanDefinitionRegistry，beanFactory是DefaultListableBeanFactory，为BeanDefinitionRegistry的实现
	if (beanFactory instanceof BeanDefinitionRegistry) {
		BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
		List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
		List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
        //遍历beanFactoryPostProcessors，由于之前的代码中没有add过，所以为空
		for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
			if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
				BeanDefinitionRegistryPostProcessor registryProcessor =
						(BeanDefinitionRegistryPostProcessor) postProcessor;
				registryProcessor.postProcessBeanDefinitionRegistry(registry);
				registryProcessors.add(registryProcessor);
			}
			else {
				regularPostProcessors.add(postProcessor);
			}
		}

		List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();

		/**
		* 这里的逻辑分为三步
		* 1. 找出所有的BeanDefinitionRegistryPostProcessor的beanDefinition，并且筛选出PriorityOrdered的实现类，
		*    进行排序，并执行接口BeanDefinitionRegistryPostProcessor中定义的方法postProcessBeanDefinitionRegistry
		* 2. 和第一步逻辑是一样的，只不过找出的是Ordered的实现类，因为PriorityOrdered是Ordered的子接口，所以这边需要去除
    	*    在第一步中执行的后处理器
    	* 3. 和前面两步差不多，只不过执行的是前面两步都没有执行过的（没有实现PriorityOrdered是Ordered）
		*/
		String[] postProcessorNames =
				beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
		for (String ppName : postProcessorNames) {
			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();

		//对Ordered的实现后处理器进行处理
		postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
		for (String ppName : postProcessorNames) {
			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();

		//对剩余的后处理器进行处理
		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();
		}

		/**
		* 由于BeanDefinitionRegistryPostProcessor是BeanFactoryPostProcessor的子接口，所以这边还需要执行
		* BeanFactoryPostProcessor中定义的方法postProcessBeanFactory
		*/
		invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
		invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
	}

	else {
		invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
	}

	/**
	* 这里解释以下为什么还需要下面的步骤，spring中定义一个beanFactory后处理器的方法有两种：
	* 1. 实现BeanDefinitionRegistryPostProcessor接口
	* 2. 实现BeanFactoryPostProcessor接口
	* 其中BeanDefinitionRegistryPostProcessor是BeanFactoryPostProcessor的子接口，上面的逻辑已经处理完了
	* BeanDefinitionRegistryPostProcessor的实现类的后处理器，下面现在需要处理的是BeanFactoryPostProcessor的实现类
	*/
	String[] postProcessorNames =
			beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

	//这里的逻辑和上面差不多，找出所有的BeanFactoryPostProcessor的实现，并根据是否实现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)) {
			//如果之前已经执行过了，这边就直接跳过，因为BeanDefinitionRegistryPostProcessor是BeanFactoryPostProcessor的子接口
		}
		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);
		}
	}

	//首先，执行PriorityOrdered的子类
	sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
	invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

	//截至，执行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);

	//最后，执行没有实现排序接口的子类
	List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
	for (String postProcessorName : nonOrderedPostProcessorNames) {
		nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
	}
	invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
	//beanFactory清空元数据缓存（allBeanNamesByType和singletonBeanNamesByType），这两个缓存实在上面getBeanNamesForType创建的
	beanFactory.clearMetadataCache();
}

这一步的逻辑较为复杂，我们来进行一个简单的梳理：

  1. 首先我们需要了解两个定义：
    1.1 beanFactory的后处理器需要实现BeanDefinitionRegistryPostProcessor或者BeanFactoryPostProcessor，前者是后者的子接口，所以如果后处理器是BeanDefinitionRegistryPostProcessor的实现，则需要执行BeanDefinitionRegistryPostProcessor和BeanFactoryPostProcessor的实现方法
    2.2 beanFactory的后处理器的排序可以实现接口PriorityOrdered或者Ordered，前者是后者的子接口
  2. 定义一个Set，用来记录已经执行过的beanFactory的后处理器
  3. 遍历代码中add的后处理器，如果存在则分为两步：
    3.1 如果是BeanDefinitionRegistryPostProcessor的实现，则直接执行其实现方法，并记录于registryProcessors中
    3.2 如果是BeanFactoryPostProcessor，则直接记录于regularPostProcessors
  4. 查询出所有的BeanDefinitionRegistryPostProcessor实现类的beanDefinition，这里有四步：
    4.1 找出PriorityOrdered接口的实现，排序执行，并记录于registryProcessors中
    4.2 找出Ordered接口的实现，排序执行，并记录于registryProcessors中
    4.3 找出剩余的，执行，并记录于registryProcessors中
    4.3 执行registryProcessors中所有的BeanFactoryPostProcessor的接口方法
  5. 查询出所有的BeanFactoryPostProcessor实现类且没有执行过的beanDefinition，这里有三步：
    5.1 找出PriorityOrdered接口的实现，排序执行
    5.2 找出Ordered接口的实现，排序执行
    5.3 找出剩余的，执行
    6.清除查询后处理器的产生的缓存
mazhen1991
发布了81 篇原创文章 · 获赞 16 · 访问量 20万+
私信 关注

猜你喜欢

转载自blog.csdn.net/mazhen1991/article/details/100170801
今日推荐
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
周排行
rbac——界面、权限
Apache CXF + SpringMVC 整合发布WebService
so插件化
Vue.js实战系列---图标字体制作（svg格式）
PAT乙级 1007 素数对猜想(孪生素数对) (20分) ---（C语言 + 详细注释）
被IRM保护的文档，打开失败
Calendar和Date计算日期差的小问题
win10子系统ubuntu18.4安装docker
利用Wrap Shell Script定位Android Native内存泄漏
MySQL: Transaction (Part I - Basic Concept)
每日归档
更多
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022