Sping源码（七）— BeanFactoryPostProcessor

已于 2024-04-18 17:03:58 修改
阅读量81 收藏
点赞数
分类专栏： Spring源码 文章标签： java spring 源码
于 2023-08-22 16:26:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43936962/article/details/132396273
版权

简单回顾一下上一篇文章，是在BeanFacroty创建完之后，可以通过Editor和EditorRegistrar实现对类属性的自定义扩展，以及忽略要自动装配的Aware接口。
本篇帖子会顺着refresh()主流程方法接着向下执行。在讲invokeBeanFactoryPostProcessors方法的具体逻辑之前，先简单介绍BeanFactoryPostProcessor接口和整个invokeBeanFactoryPostProcessors方法的执行流程。

refresh

public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			prepareRefresh();
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
			prepareBeanFactory(beanFactory);

			try {
				postProcessBeanFactory(beanFactory);
				invokeBeanFactoryPostProcessors(beanFactory);
			}		
		}
	}

在这里插入图片描述

@FunctionalInterface
public interface BeanFactoryPostProcessor {

	void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;
}


public interface BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor {

	void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException;
}

BFPP和BDRPP

根据上面的流程图以及代码块可以看出BFPP和BDRPP的关系，其中BFPP类中只有一个postProcessBeanFactory()方法，而BDRPP中只有postProcessBeanDefinitionRegistry()方法，因为是继承的关系，所以所有实现BDRPP接口的类，也会有postProcessBeanFactory()方法。
而BFPP和BDRPP其中有一个很重要的区别就在于，它们两个方法接收的参数不同，其中BFPP接收BeanFactory参数，针对整个BeanFactory做操作，而BDRPP接收的参数是BeanDefinitionRegistry（可以理解是对Definition做一些增删改查的操作）。

BeanDefinitionRegistry

public interface BeanDefinitionRegistry extends AliasRegistry {

	/**
	 * 注册BeanDefinition到注册表
	 */
	void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
			throws BeanDefinitionStoreException;

	/**
	 * 移除注册表中beanName的BeanDefinition
	 */
	void removeBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;

	/**
	 * 获取注册表中beanName的BeanDefinition
	 */
	BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;

	/**
	 * 检查此注册表是否包含具有给定名称的BeanDefinition
	 */
	boolean containsBeanDefinition(String beanName);

	/**
	 * 返回此注册表中定义的所有bean的名称
	 */
	String[] getBeanDefinitionNames();

	/**
	 * 返回注册表中定义的bean的数目
	 */
	int getBeanDefinitionCount();

	/**
	 *  确定给定bean名称是否已在该注册表中使用
	 */
	boolean isBeanNameInUse(String beanName);

}

接口的作用和整体的执行流程已经介绍完成，下面看看invokeBeanFactoryPostProcessors方法的具体执行逻辑。

invokeBeanFactoryPostProcessors

主要是调用delegate中的同名invokeBeanFactoryPostProcessors方法，对BaenFactory中和自定义注册进来的BFPP的实现类进行处理。
其中getBeanFactoryPostProcessors()会获取自定义扩展继承了BFPP和BDRPP的类。同时，也会先处理这部分的BFPP。

invokeBeanFactoryPostProcessors

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
		// 获取到当前应用程序上下文的beanFactoryPostProcessors变量的值，并且实例化调用执行所有已经注册的beanFactoryPostProcessor
		// 默认情况下，通过getBeanFactoryPostProcessors()来获取已经注册的BFPP，但是默认是空的
		PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());

		// Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime
		if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
			beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
			beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
		}
	}

具体处理逻辑
整个invokeBeanFactoryPostProcessors()方法可以分为几块来看

  1. 先处理参数beanFactoryPostProcessors中自定义的BFPP和BDRPP。
      		//优先处理入参中的beanFactoryPostProcessors,遍历所有beanFactoryPostProcessors，
        //并将参数中的BFPP和BDRPP区分开
		for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
            //如果是BDRPP类型
			if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
				BeanDefinitionRegistryPostProcessor registryPostProcessor =
						(BeanDefinitionRegistryPostProcessor) postProcessor;
                        
                //直接调用BDRPP中的postProcessBeanDefinitionRegistry具体方法进行处理
				registryPostProcessor.postProcessBeanDefinitionRegistry(registry);
                //放入registryPostProcessors集合中
				registryPostProcessors.add(registryPostProcessor);
			}
			else {
                //否则，只是普通的BeanFactoryPostProcessor，则放入regularPostProcessors集合
				regularPostProcessors.add(postProcessor);
			}
		}
  2. 获取所有实现BeanDefinitionRegistryPostProcessor类型的beanName，并筛选出继承了PriorityOrdered类的，排序后执行PPBDR方法。
     		// 用于保存本次要执行的BeanDefinitionRegistryPostProcessor
        List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();

        // First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
        // 调用所有实现PriorityOrdered接口的BeanDefinitionRegistryPostProcessor实现类
        // 找到所有实现BeanDefinitionRegistryPostProcessor接口bean的beanName
        String[] postProcessorNames =
                beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
        // 遍历处理所有符合规则的postProcessorNames
        for (String ppName : postProcessorNames) {
            // 检测是否实现了PriorityOrdered接口
            if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
                // 获取名字对应的bean实例，添加到currentRegistryProcessors中
                currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                // 将要被执行的BFPP名称添加到processedBeans，避免后续重复执行
                processedBeans.add(ppName);
            }
        }
        // 按照优先级进行排序操作
        sortPostProcessors(currentRegistryProcessors, beanFactory);
        // 添加到registryProcessors中，用于最后执行postProcessBeanFactory方法
        registryProcessors.addAll(currentRegistryProcessors);
        // 遍历currentRegistryProcessors，执行postProcessBeanDefinitionRegistry方法
        invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
        // 执行完毕之后，清空currentRegistryProcessors
        currentRegistryProcessors.clear();
  3. 再次获取所有实现BeanDefinitionRegistryPostProcessor类型的beanName，找出未执行过并继承了Ordered接口的，排序执行PPBDR方法。
     //再次获取BDRPP类型的所有postProcessorNames
		postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
        //实现了Order接口的BeanDefinitionRegistryPostProcessor放入该集合
		List<BeanDefinitionRegistryPostProcessor> orderedPostProcessors = new ArrayList<BeanDefinitionRegistryPostProcessor>();
		for (String ppName : postProcessorNames) {
            //如果是没执行过，并且实现了Order接口的
			if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
                //放到Order集合中
				orderedPostProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                //放入processedBeans集合，避免重复执行
				processedBeans.add(ppName);
			}
		}
        //按照优先级排序
		OrderComparator.sort(orderedPostProcessors);
        //放入registryPostProcessors集合
		registryPostProcessors.addAll(orderedPostProcessors);
        //遍历orderedPostProcessors集合，执行postProcessBeanDefinitionRegistry方法
		invokeBeanDefinitionRegistryPostProcessors(orderedPostProcessors, registry);
  4. 循环遍历，找出所有继承BeanDefinitionRegistryPostProcessor并且尚未执行的beanName，排序执行
     // 最后，调用所有剩下的BeanDefinitionRegistryPostProcessors
        boolean reiterate = true;
        while (reiterate) {
            reiterate = false;
            // 找出所有实现BeanDefinitionRegistryPostProcessor接口的类
            postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
            // 遍历执行
            for (String ppName : postProcessorNames) {
                // 跳过已经执行过的BeanDefinitionRegistryPostProcessor
                if (!processedBeans.contains(ppName)) {
                    // 获取名字对应的bean实例，添加到currentRegistryProcessors中
                    currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                    // 将要被执行的BFPP名称添加到processedBeans，避免后续重复执行
                    processedBeans.add(ppName);
                    reiterate = true;
                }
            }
            // 按照优先级进行排序操作
            sortPostProcessors(currentRegistryProcessors, beanFactory);
            // 添加到registryProcessors中，用于最后执行postProcessBeanFactory方法
            registryProcessors.addAll(currentRegistryProcessors);
            // 遍历currentRegistryProcessors，执行postProcessBeanDefinitionRegistry方法
            invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
            // 执行完毕之后，清空currentRegistryProcessors
            currentRegistryProcessors.clear();
        }
        //遍历registryPostProcessors和regularPostProcessors中有所的bean，
        //执行BFPP接口postProcessBeanFactory方法
		invokeBeanFactoryPostProcessors(registryPostProcessors, beanFactory);
		invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
  5. 截止到这，已经将所有实现BeanDefinitionRegistryPostProcessor类型的类按照顺序执行了postProcessBeanDefinitionRegistry()方法。
    上面有说到，如果类继承了BeanDefinitionRegistryPostProcessor那么它同时还会拥有BeanFactoryPostProcessor的postProcessBeanFactory()方法。 接下来只需要获取到所有实现BeanFactoryPostProcessor类型的类，并按照PriorityOrdered -> Ordered -> nonOrdered的顺序来执行方法即可。
  		//找到所有实现BeanFactoryPostProcessor的类
		String[] postProcessorNames =
				beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

        //依次声明priorityOrderedPostProcessors、orderedPostProcessorNames和nonOrderedPostProcessorNames分别用来存放对应
        //实现了priorityOrdered、ordered和没实现排序接口的类
		List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
		List<String> orderedPostProcessorNames = new ArrayList<String>();
		List<String> nonOrderedPostProcessorNames = new ArrayList<String>();
        //遍历所有postProcessorNames，将没执行过的BFPP方法的类放入对应集合中。
		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.
        //按照优先级进行排序，并执行具体的BFPP方法
		OrderComparator.sort(priorityOrderedPostProcessors);
		invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

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

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

完整代码

class PostProcessorRegistrationDelegate {

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

		// Invoke BeanDefinitionRegistryPostProcessors first, if any.
        //所有已经执行过BFPP的存储在processedBeans，防止重复执行
		Set<String> processedBeans = new HashSet<String>();
        
        //判断beanFactory是否属于BeanDefinitionRegistry类型，默认的beanFactory是DefaultListableBeanFactory，
        //实现了BeanDefinitionRegistry 所以为true
		if (beanFactory instanceof BeanDefinitionRegistry) {
            //强制类型转换
			BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
            
            //存放BFPP类型的集合
			List<BeanFactoryPostProcessor> regularPostProcessors = new LinkedList<BeanFactoryPostProcessor>();
            
            //存放BDRPP类型的集合
			List<BeanDefinitionRegistryPostProcessor> registryPostProcessors =
					new LinkedList<BeanDefinitionRegistryPostProcessor>();
            
            //优先处理入参中的beanFactoryPostProcessors,遍历所有beanFactoryPostProcessors，
            //并将参数中的BFPP和BDRPP区分开
			for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
                //如果是BDRPP类型
				if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
					BeanDefinitionRegistryPostProcessor registryPostProcessor =
							(BeanDefinitionRegistryPostProcessor) postProcessor;
                            
                    //直接调用BDRPP中的postProcessBeanDefinitionRegistry具体方法进行处理
					registryPostProcessor.postProcessBeanDefinitionRegistry(registry);
                    //放入registryPostProcessors集合中
					registryPostProcessors.add(registryPostProcessor);
				}
				else {
                    //否则，只是普通的BeanFactoryPostProcessor，则放入regularPostProcessors集合
					regularPostProcessors.add(postProcessor);
				}
			}

            //根据type获取BeanFactory中所有类型为BDRPP的postProcessorNames
			String[] postProcessorNames =
					beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);

			// First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
            
            //将实现了BDRPP和priorityOrder接口的类放入该集合
			List<BeanDefinitionRegistryPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanDefinitionRegistryPostProcessor>();
			for (String ppName : postProcessorNames) {
                //如果是PriorityOrdered类型的
				if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
                    //放入priorityOrderedPostProcessors集合
					priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                    //放入processedBeans集合，避免重复执行
					processedBeans.add(ppName);
				}
			}
            //按照优先级进行排序
			OrderComparator.sort(priorityOrderedPostProcessors);
            //添加到registryPostProcessors中
			registryPostProcessors.addAll(priorityOrderedPostProcessors);
            //遍历priorityOrderedPostProcessors集合，执行postProcessBeanDefinitionRegistry方法
			invokeBeanDefinitionRegistryPostProcessors(priorityOrderedPostProcessors, registry);

			// Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
            //再次获取BDRPP类型的所有postProcessorNames
			postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
            //实现了Order接口的BeanDefinitionRegistryPostProcessor放入该集合
			List<BeanDefinitionRegistryPostProcessor> orderedPostProcessors = new ArrayList<BeanDefinitionRegistryPostProcessor>();
			for (String ppName : postProcessorNames) {
                //如果是没执行过，并且实现了Order接口的
				if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
                    //放到Order集合中
					orderedPostProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                    //放入processedBeans集合，避免重复执行
					processedBeans.add(ppName);
				}
			}
            //按照优先级排序
			OrderComparator.sort(orderedPostProcessors);
            //放入registryPostProcessors集合
			registryPostProcessors.addAll(orderedPostProcessors);
            //遍历orderedPostProcessors集合，执行postProcessBeanDefinitionRegistry方法
			invokeBeanDefinitionRegistryPostProcessors(orderedPostProcessors, registry);

			// Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
			boolean reiterate = true;
			while (reiterate) {
				reiterate = false;
                //找出所有实现了BDRPP接口的类
				postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
				for (String ppName : postProcessorNames) {
                    //跳过执行过BDRPP的类
					if (!processedBeans.contains(ppName)) {
                        //根据name获取实例
						BeanDefinitionRegistryPostProcessor pp = beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class);
                        //添加到registryPostProcessors集合中
                        registryPostProcessors.add(pp);
                        //添加到processedBeans集合中
						processedBeans.add(ppName);
                        //直接执行BDRPP
						pp.postProcessBeanDefinitionRegistry(registry);
						reiterate = true;
					}
				}
			}   
            
			// Now, invoke the postProcessBeanFactory callback of all processors handled so far.
            //遍历registryPostProcessors和regularPostProcessors中有所的bean，
            //执行BFPP接口postProcessBeanFactory方法
			invokeBeanFactoryPostProcessors(registryPostProcessors, beanFactory);
			invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
		}
        //如果beanFactory不属于BeanDefinitionRegistry，直接执行具体方法
		else {
			// Invoke factory processors registered with the context instance.
			invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
		}
        
        //到这为止，入参的beanFactoryPostProcessors和BeanFactory中BDRPP类型的方法已经全部处理完成
        //后面开始都是操作BFPP类型
        //找到所有实现BeanFactoryPostProcessor的类
		String[] postProcessorNames =
				beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

		// Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
		// Ordered, and the rest.
        //依次声明priorityOrderedPostProcessors、orderedPostProcessorNames和nonOrderedPostProcessorNames分别用来存放对应
        //实现了priorityOrdered、ordered和没实现排序接口的类
		List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
		List<String> orderedPostProcessorNames = new ArrayList<String>();
		List<String> nonOrderedPostProcessorNames = new ArrayList<String>();
        //遍历所有postProcessorNames，将没执行过的BFPP方法的类放入对应集合中。
		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.
        //按照优先级进行排序，并执行具体的BFPP方法
		OrderComparator.sort(priorityOrderedPostProcessors);
		invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

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

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

看完上面这段源码之后，不知道大家有没有这样的一个疑问，为什么重复代码较多？每次都要根据类型重新获取String[] postProcessorNames，第一次获取后，根据postProcessorNames按照PriorityOrdered和Order进行优先级排序、分组执行不行么？
是因为在执行BDRPP的方法postProcessBeanDefinitionRegistry时，有可能会有新增的额外的BDRPP的类，每次都重新获取，能避免BDRPP类执行的不完全。

流程图
在这里插入图片描述

善良的Leexx
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring源码解析.zip
07-31
spring源码解析。使用xmind进行代码整理。包含ioc，aop，tr相关代码部分。
Spring源码解析.pdf
03-09
Spring源码解析
spring源码雷神spring源码雷神
08-06
spring源码雷神spring源码雷神
Spring源码学习加注释，方便学习.zip
05-11
spring源码中文注释方便学习，spring源码学习加注释。 spring源码中文注释方便学习，spring源码学习加注释。 spring源码中文注释方便学习，spring源码学习加注释。 spring源码中文注释方便学习，spring源码学习加注释。 spring源码中文注释方便学习，spring源码学习加注释。 spring源码中文注释方便学习，spring源码学习加注释。 spring源码中文注释方便学习，spring源码学习加注释。 spring源码中文注释方便学习，spring源码学习加注释。 spring源码中文注释方便学习，spring源码学习加注释。 spring源码中文注释方便学习，spring源码学习加注释。 spring源码中文注释方便学习，spring源码学习加注释。 spring源码中文注释方便学习，spring源码学习加注释。
Spring源码之BeanFactoryPostProcessor
qq_42878176的博客
11-15 213
Spring的重要扩展点，增强beanFactory的功能；可以在加载解析BeanDefinition之后，可以对BeanDefinition进行修改；可以新增一些特殊的BeanPostProcessor，比如新增带有beanFactory的BeanPostProcessor；BeanFactoryPostProcessor的子接口，用于解析注册BeanDefinition，所以它是先于BeanFactoryPostProcessor执行。实现类中很重要。
Spring源码分析 | BeanFactoryPostProcessor的用法与源码分析
死牛胖子的技术随笔
06-20 280
接口只提供了一个回调方法，通过该方法可以调整容器的属性。 还有一个子接口 ，该接口也提供了一个回调方法，通过该方法可以向容器注册 。 方法的回调时间在 方法之前，也就是说优先注册 。 BeanFactoryPostProcessor 在容器启动过程中的执行时机 Spring 应用通过 方法启动容器，在 中会对所有的 执行回调， 的执行时间是在完成 加载之后，执行 实例化之前。所以在 中可以修改容器属性，可以注册 ，但最好不要手动做 Bean 实例化，不然可能导致不可预知的错误。 如何注册 B
Spring源码之BeanFactoryPostProcessor的执行顺序
Java编程方面的技术文章、教程、分享和实践经验
10-11 1404
简介 BeanFactoryPostProcessor是 Factory hook，行话“钩子”。这个类允许我们对 ApplicationContext 中的 BeanDefinition 自定义修改。 Spring 中有两个比较重要的拓展点，一个是 BeanFactoryPostProcessor，另一个是 BeanPostProcessor 如图所示，BeanDefinitionRegistryPostProcessor 是 BeanFactoryPostProcessor 的子类。 .
Spring源码之BeanFactoryPostProcessor(后置处理器)
程序员田同学的博客
03-01 379
Spring源码之BeanFactoryPostProcessor(后置处理器)。 有点水平的Spring开发人员想必都知道BeanFactoryPostProcessor也就是常说的后置管理器，这是Spirng生命周期中的一个接口，实现这个接口可以在beanFactory初始化前做一些事。 我们熟知的Spring和Mybatis的结合，正是因为Mybatis实现了BeanFactoryPostProcessor，它的重要性不言而喻，深入理解他对于切入Mybatis源码有着深刻的意义。 如下图是简单的应用：
精通Spring源码 | BeanFactoryPostProcessor
个人博客
03-30 213
BeanFactoryPostProcessor 是 Spring 中 Bean 工厂的后置处理器，她在 Spring 加载了 Bean 的定义文件后，在 Bean 实例化之前执行。所以，当我们实现了这个接口，就可以修改整个 Bean 工厂的 Bean 的一些属性，比如，修改 Bean 的作用域，设置 despendsOn，设置是否懒加载等等。 @ComponentScan("com.javahl...
spring源码：BeanFactoryPostProcessor原理
咔咔学长
05-04 297
一、介绍   Spring IoC容器允许BeanFactoryPostProcessor(即BeanFactory后处理器)读取配置元数据，并能在容器实例化除BeanFactoryPostProcessor实例之外的任何bean之前更改它。   Spring我们可以配置多个BeanFactoryPostProcessor实例，并且可以通过实现Order或PriorityOrdered接口设置or...
【Spring源码解析】BeanFactoryPostProcessor【相关类】源码解析
01-20
1 BeanFactoryPostProcessor作用 public interface BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor { /** * 可以修改容器Bean内部的定义信息，全部的bean definitions会加载但是bean没有...
Spring注解驱动开发第36讲——或许，这是你以前没看过的从源码角度理解BeanFactoryPostProcessor的原理
08-07
Spring注解驱动开发第36讲——或许，这是你以前没看过的从源码角度理解BeanFactoryPostProcessor的原理
spring培训.pptx
06-27
了解spring的加载机制 beanPostProcessor,beanFactoryPostProcessor 的使用 springmvc 的父子容器 aop切面说明 公司内部培训课件
spring-annotion:Spring源码分析以及注解开发
03-24
ext扩展原理包含beanFactoryPostProcessor，BeanDefinitionRegistryPostProcessor和事件监听器等---> tx Spring声明式事务模块---> config AOP IOC已经一些bean的流程配置模块--->启动也包含SpringMVC注解...
com-spring-ioc-demo:源码主要是学习Spring IOC的原理，以及对Bean的注册及控制，主要运用以下类对Spring进行扩展学习：BeanPostProcessor，BeanFactoryAware，BeanNameAware，ApplicationContextAware，FactoryBean，BeanDefinitionRegistryPostProcessor，BeanFactoryPostProcessor，BeanPostProcessor，ResourceLoaderA
03-22
com-spring-ioc-demo:源码主要是学习Spring IOC的原理，以及对Bean的注册及控制，主要运用以下类对Spring进行扩展学习：BeanPostProcessor，BeanFactoryAware，BeanNameAware，ApplicationContextAware，FactoryBean...
spring源码：BeanFactoryPostProcessor和BeanDefinitionRegistryPostProcessor的区别
小小少年的博客
06-12 659
这篇文章主要记录下BeanFactoryPostProcessor和BeanDefinitionRegistryPostProcessor的学习和一些见解； 结论 我习惯先说结论，然后再细说具体的源码： 前者是后者的父接口，后者是前者的子接口 两者都是在bean实例化之前对beanDefinition进行的一系列操作 spring源码中，先执行后者的实现类，再实现前者的实现类 在spring源码中，这两个接口的实现类完成了bean的扫描和对配置类生成了代理对象 我们以 ***Configuration
spring源码分析-BeanFactoryPostProcessor
qq_29899535的博客
01-03 313
BeanFactoryPostProcessor是BeanFactory的一个钩子接口，更是一种扩展，也正是因为这个接口造就了spring加载Bean的方式变得多种多样。我相信大部分开发人员对这个接口可能还存在一些陌生，毕竟这个接口是属于一种底层扩展。
Spring源码分析-BeanFactoryPostProcessor
qigeminghao的博客
10-31 148
BeanFactoryPostProcessor接口是Spring提供的对Bean的扩展点,它的子接口是BeanDefinitionRegistryPostProcessor @FunctionalInterface public interface BeanFactoryPostProcessor { void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException; }
Spring 源码扩展 BeanFactoryPostProcessor 与 BeanDefinitionRegistryPostProcessor 后置处理器
qq_29799655的博客
04-08 209
目录一. BeanFactoryPostProcessor1. 解释与使用示例2. 运行原理二. BeanDefinitionRegistryPostProcessor1. 解释与使用示例2. 执行原理 一. BeanFactoryPostProcessor 1. 解释与使用示例 BeanFactoryPostProcessor 是一个接口,该接口中有一个 postProcessBeanFacto...
spring通过BeanFactoryPostProcessor动态注入bean
最新发布
05-13
是的，Spring框架提供了BeanFactoryPostProcessor接口，它允许在容器实例化任何其他bean之前修改bean定义。通过实现BeanFactoryPostProcessor接口，开发人员可以在应用程序上下文启动时动态注入bean或修改bean定义。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值