当前位置：首页 > news >正文

Spring BeanFactoryPostProcessor 接口

news 2026/6/16 1:51:56

[[Spring IOC 源码学习总笔记]]

BeanFactoryPostProcessor是 Spring 框架提供的一个扩展点接口，它允许开发者在 Spring 在BeanFactory 加载了所有bean定义，但尚未实例化任何bean 之后，对底层的 BeanDefinition 和 BeanFactory 进行扩展定制, 包括修改已注册的bean定义添加新的bean定义等等。

BeanFactoryPostProcessor的主要作用包括：

修改已注册的Bean定义： 可以通过BeanFactoryPostProcessor来修改已注册的bean的配置信息，例如修改属性值、添加新的属性等。
添加新的Bean定义： 可以向容器中添加新的bean定义，这样在实例化bean时，新定义的bean也会被纳入管理。
对Bean定义进行后处理： 可以在容器加载了bean的定义后对这些定义进行后处理，以满足特定的需求。

BeanFactoryPostProcessor

org.springframework.beans.factory.config.BeanFactoryPostProcessor 的源码

package org.springframework.beans.factory.config;import org.springframework.beans.BeansException;/*** Factory hook that allows for custom modification of an application context's* bean definitions, adapting the bean property values of the context's underlying* bean factory.*** <p>Useful for custom config files targeted at system administrators that* override bean properties configured in the application context. See* {@link PropertyResourceConfigurer} and its concrete implementations for* out-of-the-box solutions that address such configuration needs.** <p>A {@code BeanFactoryPostProcessor} may interact with and modify bean* definitions, but never bean instances. Doing so may cause premature bean* instantiation, violating the container and causing unintended side effects.* If bean instance interaction is required, consider implementing* {@link BeanPostProcessor} instead.** <h3>Registration</h3>* <p>An {@code ApplicationContext} auto-detects {@code BeanFactoryPostProcessor}* beans in its bean definitions and applies them before any other beans get created.* A {@code BeanFactoryPostProcessor} may also be registered programmatically* with a {@code ConfigurableApplicationContext}.** <h3>Ordering</h3>* <p>{@code BeanFactoryPostProcessor} beans that are autodetected in an* {@code ApplicationContext} will be ordered according to* {@link org.springframework.core.PriorityOrdered} and* {@link org.springframework.core.Ordered} semantics. In contrast,* {@code BeanFactoryPostProcessor} beans that are registered programmatically* with a {@code ConfigurableApplicationContext} will be applied in the order of* registration; any ordering semantics expressed through implementing the* {@code PriorityOrdered} or {@code Ordered} interface will be ignored for* programmatically registered post-processors. Furthermore, the* {@link org.springframework.core.annotation.Order @Order} annotation is not* taken into account for {@code BeanFactoryPostProcessor} beans.** @author Juergen Hoeller* @author Sam Brannen* @since 06.07.2003* @see BeanPostProcessor* @see PropertyResourceConfigurer*/
@FunctionalInterface
public interface BeanFactoryPostProcessor {/*** Modify the application context's internal bean factory after its standard* initialization. All bean definitions will have been loaded, but no beans* will have been instantiated yet. This allows for overriding or adding* properties even to eager-initializing beans.* 在加载了所有bean定义，但尚未实例化任何bean。(可以对底层的 BeanDefinition 和 BeanFactory 进行扩展定制)** @param beanFactory the bean factory used by the application context* @throws org.springframework.beans.BeansException in case of errors*/void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;}

BeanDefinitionRegistryPostProcessor 接口

BeanDefinitionRegistryPostProcessor(BDRPP) 接口继承自BeanFactoryPostProcessor(BFPP) 它会优先于BFPP调用, 目的是可以在BFPP之前注册/修改 BeanDefinition 到 BeanFactory中

org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor

package org.springframework.beans.factory.support;import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;/*** Extension to the standard {@link BeanFactoryPostProcessor} SPI, allowing for* the registration of further bean definitions <i>before</i> regular* BeanFactoryPostProcessor detection kicks in. In particular,* BeanDefinitionRegistryPostProcessor may register further bean definitions* which in turn define BeanFactoryPostProcessor instances.** 对标准 {@link BeanFactoryPostProcessor} SPI的扩展，允许在常规 BeanFactoryPostProcessor检测开始之前注册更多的bean定义。*  特别是，BeanDefinitionRegistryPostProcessor 可以注册进一步的bean定义，这些bean定义又定义了 BeanFactoryPostProcessor 实例。** @author Juergen Hoeller* @since 3.0.1* @see org.springframework.context.annotation.ConfigurationClassPostProcessor*/
public interface BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor {/*** Modify the application context's internal bean definition registry after its* standard initialization. All regular bean definitions will have been loaded,* but no beans will have been instantiated yet. This allows for adding further* bean definitions before the next post-processing phase kicks in.* @param registry the bean definition registry used by the application context* @throws org.springframework.beans.BeansException in case of errors*/void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException;/*** Empty implementation of {@link BeanFactoryPostProcessor#postProcessBeanFactory}* since custom {@code BeanDefinitionRegistryPostProcessor} implementations will* typically only provide a {@link #postProcessBeanDefinitionRegistry} method.* @since 6.1*/@Overridedefault void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {}}

Srping 对于注解的支持实现

一个例子是在 Spring 中对于注解的支持就是通过 BeanDefinitionRegistryPostProcessor的扩展实现的, 见关系图

注意: 关于 Spring IOC 支持注解最原始的入口点并不在这.
本文只讨论Spring 如何通过 BeanDefinitionRegistryPostProcessor 扩展实现对注解的支持

org.springframework.context.annotation.ConfigurationClassPostProcessor 部分源码


/*** 主要负责解析注解的关键类, 注意它实现的其中一个接口: BeanDefinitionRegistryPostProcessor** {@link BeanFactoryPostProcessor} used for bootstrapping processing of* {@link Configuration @Configuration} classes.* <p>Registered by default when using {@code <context:annotation-config/>} or* {@code <context:component-scan/>}. Otherwise, may be declared manually as* with any other {@link BeanFactoryPostProcessor}.** <p>This post processor is priority-ordered as it is important that any* {@link Bean @Bean} methods declared in {@code @Configuration} classes have* their corresponding bean definitions registered before any other* {@code BeanFactoryPostProcessor} executes.** @author Chris Beams* @author Juergen Hoeller* @author Phillip Webb* @author Sam Brannen* @since 3.0*/
public class ConfigurationClassPostProcessor implements BeanDefinitionRegistryPostProcessor,BeanRegistrationAotProcessor, BeanFactoryInitializationAotProcessor, PriorityOrdered,ResourceLoaderAware, ApplicationStartupAware, BeanClassLoaderAware, EnvironmentAware {public ConfigurationClassPostProcessor(){System.out.println("ConfigurationClassPostProcessor 构造");}..../*** Build and validate a configuration model based on the registry of* {@link Configuration} classes.*/public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {/*** 存所有视为 Candidate 的 BeanDefinition*/List<BeanDefinitionHolder> configCandidates = new ArrayList<>();//拿到所有的已注册的 Bean NameString[] candidateNames = registry.getBeanDefinitionNames();// 遍历, 筛选视为 Candidate 的 beanDefinition, 把它们添加到 configCandidates 中for (String beanName : candidateNames) {BeanDefinition beanDef = registry.getBeanDefinition(beanName);/*** BeanDefinition 如果包含 configurationClass 属性, 则表示该 beanDefinition 已经被处理过了*/if (beanDef.getAttribute(ConfigurationClassUtils.CONFIGURATION_CLASS_ATTRIBUTE) != null) {if (logger.isDebugEnabled()) {logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);}}/*** 如果是该 (bean)beanDefinition*  1. 添加了 @Configuration 会被视作是 Candidate 放入 configCandidates*  2. 如果添加了 @Component, @ComponentScan @Import ,@ImportResource 或者 有方法是添加了 @Bean 注解的, 也会被视作是 Candidate 放入 configCandidates*  并且给它设置属性 configurationClass 值为 'lite' 区分一下** <!> 所以能被 Spring 识别为bean 添加到容器中的注解, 就是以上的2种情况.*/else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));}}// Return immediately if no @Configuration classes were found// 如果没有任何 Candidate , 返回if (configCandidates.isEmpty()) {return;}// 排序 即: @Order// Sort by previously determined @Order value, if applicableconfigCandidates.sort((bd1, bd2) -> {int i1 = ConfigurationClassUtils.getOrder(bd1.getBeanDefinition());int i2 = ConfigurationClassUtils.getOrder(bd2.getBeanDefinition());return Integer.compare(i1, i2);});/*** 这一块是对 bean的 自定义命名生成 策略的处理*/// Detect any custom bean name generation strategy supplied through the enclosing application contextSingletonBeanRegistry sbr = null;if (registry instanceof SingletonBeanRegistry _sbr) {sbr = _sbr;if (!this.localBeanNameGeneratorSet) {BeanNameGenerator generator = (BeanNameGenerator) sbr.getSingleton(AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR);//这个是默认的 名称生成器if (generator != null) {this.componentScanBeanNameGenerator = generator;this.importBeanNameGenerator = generator;}}}// 环境对象if (this.environment == null) {this.environment = new StandardEnvironment();}// Parse each @Configuration class/*** ConfigurationClassParser: 解析注解的关键解析对象* 又开始倒手了.*/ConfigurationClassParser parser = new ConfigurationClassParser(this.metadataReaderFactory, this.problemReporter, this.environment,this.resourceLoader, this.componentScanBeanNameGenerator, registry);// 用 set 方便去重 集合运算吧Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);// 已经解析处理过的Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());do {StartupStep processConfig = this.applicationStartup.start("spring.context.config-classes.parse");/*** <!> 重点,  用 ConfigurationClassParser 去解析* 最终得到的是 Set<ConfigurationClass> !*/parser.parse(candidates);parser.validate();Set<ConfigurationClass> configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());// 移出 已经解析处理过的configClasses.removeAll(alreadyParsed);/*** <!> 重点, 解析得到 Set<ConfigurationClass> 再用 ConfigurationClassBeanDefinitionReader 去加载 BeanDefinition*/// Read the model and create bean definitions based on its contentif (this.reader == null) {this.reader = new ConfigurationClassBeanDefinitionReader(registry, this.sourceExtractor, this.resourceLoader, this.environment,this.importBeanNameGenerator, parser.getImportRegistry());}this.reader.loadBeanDefinitions(configClasses);alreadyParsed.addAll(configClasses);processConfig.tag("classCount", () -> String.valueOf(configClasses.size())).end();candidates.clear();if (registry.getBeanDefinitionCount() > candidateNames.length) {String[] newCandidateNames = registry.getBeanDefinitionNames();Set<String> oldCandidateNames = Set.of(candidateNames);Set<String> alreadyParsedClasses = new HashSet<>();for (ConfigurationClass configurationClass : alreadyParsed) {alreadyParsedClasses.add(configurationClass.getMetadata().getClassName());}for (String candidateName : newCandidateNames) {if (!oldCandidateNames.contains(candidateName)) {BeanDefinition bd = registry.getBeanDefinition(candidateName);if (ConfigurationClassUtils.checkConfigurationClassCandidate(bd, this.metadataReaderFactory) &&!alreadyParsedClasses.contains(bd.getBeanClassName())) {candidates.add(new BeanDefinitionHolder(bd, candidateName));}}}candidateNames = newCandidateNames;}}while (!candidates.isEmpty());// Register the ImportRegistry as a bean in order to support ImportAware @Configuration classesif (sbr != null && !sbr.containsSingleton(IMPORT_REGISTRY_BEAN_NAME)) {sbr.registerSingleton(IMPORT_REGISTRY_BEAN_NAME, parser.getImportRegistry());}// Store the PropertySourceDescriptors to contribute them Ahead-of-time if necessarythis.propertySourceDescriptors = parser.getPropertySourceDescriptors();if (this.metadataReaderFactory instanceof CachingMetadataReaderFactory cachingMetadataReaderFactory) {// Clear cache in externally provided MetadataReaderFactory; this is a no-op// for a shared cache since it'll be cleared by the ApplicationContext.cachingMetadataReaderFactory.clearCache();}}.....

查看全文

http://www.gsyq.cn/news/57504.html