Spring中BeanDefinitionRegistoryPostProcessor的实现

最新推荐文章于 2024-03-14 13:45:00 发布

雾里看花叹朦胧

最新推荐文章于 2024-03-14 13:45:00 发布

阅读量231

点赞数 1

分类专栏： Spring java 文章标签： PriorityOrdered Ordered BeanDefinitionRegistoryPostProcesso BeanFactoryPostProcessor BeanFactory

本文链接：https://blog.csdn.net/hsl0530hsl/article/details/87100863

版权

java 同时被 2 个专栏收录

18 篇文章 0 订阅

订阅专栏

Spring

9 篇文章 0 订阅

订阅专栏

BeanFactoryPostProcessor用于在BeanFactory实例化完成之后，
再做的增强处理
而BeanDefinitionRegistoryPostProcessor用于在BeanDefinition注册完成之后，
再做的增强处理

实现了BeanFactoryPostProcessor接口的，
要晚于实现了BeanDefinitionRegistryPostProcessor接口的被调用

实现了PriorityOrdered接口的优先调用.
先于实现了Ordered接口
先于没有实现这两个接口的

调用的优先顺序如下：
1.BeanDefinitionRegistoryPostProcessor > BeanFactoryPostProcessor
2.PriorityOrdered > Ordered > 没有实现这两个接口的

所有的相关处理，都是在Spring的以下类中实现的：
org.springframework.context.support.PostProcessorRegistrationDelegate
的invokeBeanFactoryPostProcessors()方法中

另外，关于invokeBeanFactoryPostProcessors()方法，请参考如下文章：
Spring中PostProcessorRegistrationDelegate类中beanFactory.getBeanNamesForType()的4次调用

PostProcessorRegistrationDelegate类的示例请参考如下文章：
基于PostProcessorRegistrationDelegate类的示例

//MyBeanDefinitionRegistryPostProcessor1.java
package sping.analysis.postprocessor;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor;
import org.springframework.stereotype.Component;

/**
 * 
 * BeanFactoryPostProcessor用于在BeanFactory实例化完成之后，
 *   再做的增强处理
 *   而BeanDefinitionRegistoryPostProcessor用于在BeanDefinition注册完成之后，
 *     再做的增强处理
 * 
 * 优先执行postProcessBeanDefinitionRegistry
 *   等所有的postProcessBeanDefinitionRegistry执行完之后，再执行postProcessBeanFactory
 * 
 * @author slHuang
 * @since 2019-02-11
 */
@Component
public class MyBeanDefinitionRegistryPostProcessor1 implements BeanDefinitionRegistryPostProcessor {

	public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
		System.out.println(this.getClass().getName() + ".postProcessBeanFactory() 被调用了...");
	}

	public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
		System.out.println("没有实现 Ordered 接口的最后调用。");
		System.out.println(this.getClass().getName() + ".postProcessBeanDefinitionRegistry()被调用了...");
	}

}

//MyBeanDefinitionRegistryPostProcessor2.java
package sping.analysis.postprocessor;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor;
import org.springframework.core.Ordered;
import org.springframework.stereotype.Component;

/**
 * BeanFactoryPostProcessor用于在BeanFactory实例化完成之后，
 *   再做的增强处理
 *   而BeanDefinitionRegistoryPostProcessor用于在BeanDefinition注册完成之后，
 *     再做的增强处理
 * 
 * @author slHuang
 * @since 2019-02-12
 */
@Component
public class MyBeanDefinitionRegistryPostProcessor2 implements BeanDefinitionRegistryPostProcessor, Ordered {

	public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
		System.out.println(this.getClass().getName() + ".postProcessBeanFactory(Ordered=1)被调用了...");
	}

	/**
	 * Order越小，越优先执行
	 */
	public int getOrder() {
		return 1;
	}

	public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
		System.out.println(this.getClass().getName() + ".postProcessBeanDefinitionRegistry(Ordered=1)被调用了...");
	}

}

//MyBeanDefinitionRegistryPostProcessor3.java
package sping.analysis.postprocessor;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor;
import org.springframework.core.Ordered;
import org.springframework.stereotype.Component;

/**
 * BeanFactoryPostProcessor用于在BeanFactory实例化完成之后，
 *   再做的增强处理
 *   而BeanDefinitionRegistoryPostProcessor用于在BeanDefinition注册完成之后，
 *     再做的增强处理
 * 
 * Order值越小，越优先调用
 * 
 * @author slHuang
 * @since 2019-02-12
 */
@Component
public class MyBeanDefinitionRegistryPostProcessor3 implements BeanDefinitionRegistryPostProcessor, Ordered {

	public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
		System.out.println(this.getClass().getName() + ".postProcessBeanFactory(Ordered=0)被调用了...");
	}

	/**
	 * Order越小，越优先执行
	 */
	public int getOrder() {
		return 0;
	}

	public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
		System.out.println("order值越小，越优先调用。");
		System.out.println(this.getClass().getName() + ".postProcessBeanDefinitionRegistry(Ordered=0)被调用了...");
	}

}

//MyBeanDefinitionRegistryPostProcessor4.java
package sping.analysis.postprocessor;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor;
import org.springframework.core.PriorityOrdered;
import org.springframework.stereotype.Component;

/**
 * BeanFactoryPostProcessor用于在BeanFactory实例化完成之后，
 *   再做的增强处理
 *   而BeanDefinitionRegistoryPostProcessor用于在BeanDefinition注册完成之后，
 *     再做的增强处理
 * 
 * 实现了PriorityOrdered接口的优先调用.
 *   先于实现了Ordered接口
 * 
 * @author slHuang
 * @since 2019-02-11
 */
@Component
public class MyBeanDefinitionRegistryPostProcessor4 implements BeanDefinitionRegistryPostProcessor, PriorityOrdered {

	public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
		System.out.println(this.getClass().getName() + ".postProcessBeanFactory()被调用了...");
	}

	/**
	 * Order越小，越优先执行
	 */
	public int getOrder() {
		return 0;
	}

	public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
		System.out.println("实现了PriorityOrdered接口的优先调用.");
		System.out.println(this.getClass().getName() + ".postProcessBeanDefinitionRegistry()被调用了...");
	}

}

//MyBeanFactoryPostProcessor1.java
package sping.analysis.postprocessor;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.stereotype.Component;

/**
 * BeanFactoryPostProcessor用于在BeanFactory实例化完成之后，
 *   再做的增强处理
 *   而BeanDefinitionRegistoryPostProcessor用于在BeanDefinition注册完成之后，
 *     再做的增强处理
 * 
 * 实现了BeanFactoryPostProcessor接口的，
 *   要晚于实现了BeanDefinitionRegistryPostProcessor接口的被调用
 * 
 * @author slHuang
 * @since 2019-02-11
 */
@Component
public class MyBeanFactoryPostProcessor1 implements BeanFactoryPostProcessor {

	public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
		System.out.println(this.getClass().getName() + ".postProcessBeanFactory() 被调用 了...");
	}

}

//MyBeanFactoryPostProcessor2.java
package sping.analysis.postprocessor;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.core.Ordered;
import org.springframework.stereotype.Component;

/**
 * BeanFactoryPostProcessor用于在BeanFactory实例化完成之后，
 *   再做的增强处理
 *   而BeanDefinitionRegistoryPostProcessor用于在BeanDefinition注册完成之后，
 *     再做的增强处理
 * 
 * 实现了BeanFactoryPostProcessor接口的，
 *   要晚于实现了BeanDefinitionRegistryPostProcessor接口的被调用
 * 
 * @author slHuang
 * @since 2019-02-11
 */
@Component
public class MyBeanFactoryPostProcessor2 implements BeanFactoryPostProcessor, Ordered {

	public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
		System.out.println(this.getClass().getName() + ".postProcessBeanFactory(Order=1) 被调用 了...");
	}

	public int getOrder() {
		return 1;
	}
}

//MyBeanFactoryPostProcessor3.java
package sping.analysis.postprocessor;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.core.Ordered;
import org.springframework.stereotype.Component;

/**
 * BeanFactoryPostProcessor用于在BeanFactory实例化完成之后，
 *   再做的增强处理
 *   而BeanDefinitionRegistoryPostProcessor用于在BeanDefinition注册完成之后，
 *     再做的增强处理
 * 
 * 实现了BeanFactoryPostProcessor接口的，
 *   要晚于实现了BeanDefinitionRegistryPostProcessor接口的被调用
 * 
 * Order值越小，越优先调用
 * 
 * @author slHuang
 * @since 2019-02-11
 */
@Component
public class MyBeanFactoryPostProcessor3 implements BeanFactoryPostProcessor, Ordered {

	public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
		System.out.println("Order值越小越优先调用。");
		System.out.println(this.getClass().getName() + ".postProcessBeanFactory(Order=0) 被调用 了...");
	}

	public int getOrder() {
		return 0;
	}
}

//MyBeanFactoryPostProcessor4.java
package sping.analysis.postprocessor;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.core.PriorityOrdered;
import org.springframework.stereotype.Component;

/**
 * BeanFactoryPostProcessor用于在BeanFactory实例化完成之后， 再做的增强处理
 * 而BeanDefinitionRegistoryPostProcessor用于在BeanDefinition注册完成之后， 再做的增强处理
 * 
 * 实现了BeanFactoryPostProcessor接口的，
 * 要晚于实现了BeanDefinitionRegistryPostProcessor接口的被调用
 * 
 * 实现了PriorityOrdered接口的优先调用. 先于实现了Ordered接口
 * 
 * @author slHuang
 * @since 2019-02-11
 */
@Component
public class MyBeanFactoryPostProcessor4 implements BeanFactoryPostProcessor, PriorityOrdered {

	public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
		System.out.println("实现BeanFactoryPostProcessor接口，晚于实现了BeanDefinitionRegistryPostProcessor接口调用。");
		System.out.println("实现了PriorityOrdered接口的优+先调用。");
		System.out.println(this.getClass().getName() + ".postProcessBeanFactory() 被调用 了...");
	}

	public int getOrder() {
		return 0;
	}
}

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">

    <context:component-scan base-package="sping.analysis.postprocessor"/>

</beans>

//TestProcessor.java
package sping.analysis.beans;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:application.xml")
public class TestFactoryBean {
	
	@Test
	public void test() {
	}
		
}

雾里看花叹朦胧

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
Spring中BeanDefinitionRegistoryPostProcessor的实现

BeanFactoryPostProcessor用于在BeanFactory实例化完成之后，再做的增强处理而BeanDefinitionRegistoryPostProcessor用于在BeanDefinition注册完成之后，再做的增强处理实现了BeanFactoryPostProcessor接口的，要晚于实现了BeanDefinitionRegistryPostProcessor接口...
复制链接

扫一扫