Spring BeanFactoryPostProcessor源码详解（详细注释版）

Spring BeanFactoryPostProcessor源码详解

最新推荐文章于 2025-11-24 12:14:54 发布

原创最新推荐文章于 2025-11-24 12:14:54 发布 · 354 阅读

9 ·

CC 4.0 BY-SA版权

文章标签：

#spring #java #BeanFactory #PostProcessor #源码 #学习

源码学习同时被 2 个专栏收录

118 篇文章

订阅专栏

Spring

47 篇文章

订阅专栏

Spring BeanFactoryPostProcessor源码详解（详细注释版）

1. BeanFactoryPostProcessor接口源码

/*
 * BeanFactoryPostProcessor接口是Spring框架中重要的扩展点之一
 * 允许在BeanFactory标准初始化之后、任何Bean定义加载之前修改Bean定义
 * 是Spring框架中配置处理的核心机制
 * 
 * BeanFactoryPostProcessor的作用：
 * 1. 修改Bean定义的属性值
 * 2. 动态注册新的Bean定义
 * 3. 处理占位符和配置属性
 * 4. 实现条件化的Bean定义
 * 5. 自定义Bean定义的处理逻辑
 * 
 * 注意事项：
 * - 在Bean实例化之前执行
 * - 可以修改Bean定义但不能修改Bean实例
 * - 避免在此接口中过早实例化Bean
 */
package org.springframework.beans.factory.config;

import org.springframework.beans.BeansException;

/**
 * 允许自定义修改应用程序上下文的Bean定义的工厂钩子
 * 
 * BeanFactoryPostProcessor在BeanFactory标准初始化之后执行
 * 此时所有的Bean定义已经被加载，但还没有Bean被实例化
 * 这使得BeanFactoryPostProcessor可以检查和修改现有的Bean定义
 * 
 * 执行时机：
 * 1. Bean定义加载完成
 * 2. BeanFactoryPostProcessor执行
 * 3. Bean实例化
 * 4. Bean属性注入
 * 5. Bean初始化
 * 
 * 常见实现：
 * - PropertyPlaceholderConfigurer: 处理占位符
 * - PropertyOverrideConfigurer: 覆盖属性值
 * - CustomEditorConfigurer: 注册自定义属性编辑器
 * 
 * 注意：实现类应该声明为@Component或通过配置注册
 */
public interface BeanFactoryPostProcessor {

    /**
     * 在标准初始化之后修改应用程序上下文的内部Bean工厂
     * 
     * 此时所有的Bean定义已经被加载，但还没有Bean被实例化
     * 这使得BeanFactoryPostProcessor可以检查和修改现有的Bean定义
     * 
     * @param beanFactory 要应用后处理的Bean工厂
     * @throws BeansException 如果后处理过程中发生错误
     * 
     * 使用建议：
     * - 可以修改Bean定义的属性值
     * - 可以注册新的Bean定义
     * - 避免在此方法中过早实例化Bean
     * - 确保异常处理，避免影响整个应用上下文的初始化
     */
    void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;

}

2. BeanDefinitionRegistryPostProcessor接口

/*
 * BeanDefinitionRegistryPostProcessor接口扩展了BeanFactoryPostProcessor
 * 提供了在Bean定义注册阶段的额外扩展点
 * 是Spring框架中更早期的扩展点
 */
package org.springframework.beans.factory.support;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;

/**
 * 允许在常规的BeanFactoryPostProcessor检测开始之前注册更多的Bean定义
 * 
 * BeanDefinitionRegistryPostProcessor在Bean定义注册阶段执行
 * 比普通的BeanFactoryPostProcessor更早执行
 * 
 * 执行顺序：
 * 1. BeanDefinitionRegistryPostProcessor.postProcessBeanDefinitionRegistry
 * 2. BeanFactoryPostProcessor.postProcessBeanFactory
 * 3. Bean实例化
 * 
 * 主要用途：
 * - 动态注册Bean定义
 * - 扫描和注册组件
 * - 处理注解驱动的Bean定义
 */
public interface BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor {

    /**
     * 在其标准初始化之后修改应用程序上下文的内部Bean定义注册表
     * 
     * 此时所有的常规Bean定义还没有被加载，但Bean定义注册表已经初始化完成
     * 可以在这个阶段添加更多的Bean定义到注册表中
     * 
     * @param registry Bean定义注册表
     * @throws BeansException 如果后处理过程中发生错误
     * 
     * 使用场景：
     * - 动态注册Bean定义
     * - 组件扫描
     * - 注解处理
     * - 配置类解析
     */
    void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException;

}

3. AbstractApplicationContext中BeanFactoryPostProcessor的处理

/*
 * AbstractApplicationContext中BeanFactoryPostProcessor的处理逻辑
 */
public abstract class AbstractApplicationContext extends DefaultResourceLoader
        implements ConfigurableApplicationContext {
    
    /**
     * 刷新上下文的核心方法
     * 包含BeanFactoryPostProcessor的调用
     */
    @Override
    public void refresh() throws BeansException, IllegalStateException {
        synchronized (this.startupShutdownMonitor) {
            // 准备刷新上下文
            prepareRefresh();

            // 告诉子类刷新内部Bean工厂
            ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

            // 准备Bean工厂用于在此上下文中使用
            prepareBeanFactory(beanFactory);

            try {
                // 允许上下文子类对Bean工厂进行后处理
                postProcessBeanFactory(beanFactory);

                // 调用BeanFactoryPostProcessor
                invokeBeanFactoryPostProcessors(beanFactory);

                // 注册BeanPostProcessor
                registerBeanPostProcessors(beanFactory);

                // 初始化消息源
                initMessageSource();

                // 初始化应用事件广播器
                initApplicationEventMulticaster();

                // 初始化其他特殊Bean
                onRefresh();

                // 检查并注册监听器Bean
                registerListeners();

                // 实例化所有剩余的(非延迟初始化的)单例Bean
                finishBeanFactoryInitialization(beanFactory);

                // 最后一步：发布相应的事件
                finishRefresh();
            }
            catch (BeansException ex) {
                if (logger.isWarnEnabled()) {
                    logger.warn("Exception encountered during context initialization - " +
                            "cancelling refresh attempt: " + ex);
                }

                // 销毁已经创建的单例Bean以避免悬空资源
                destroyBeans();

                // 重置'active'标志
                cancelRefresh(ex);

                // 传播异常到调用者
                throw ex;
            }

            finally {
                // 重置Spring核心中的常见内省缓存
                resetCommonCaches();
            }
        }
    }
    
    /**
     * 调用BeanFactoryPostProcessor的核心方法
     * 这是处理BeanFactoryPostProcessor的关键方法
     * 
     * @param beanFactory Bean工厂
     */
    protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
        // 调用BeanDefinitionRegistryPostProcessor和BeanFactoryPostProcessor
        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()));
        }
    }
    
    /**
     * 允许上下文子类对Bean工厂进行后处理
     * 子类可以重写此方法添加额外的BeanFactoryPostProcessor
     * 
     * @param beanFactory Bean工厂
     */
    protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        // 默认实现为空，子类可以重写
    }
    
    /**
     * 获取已注册的BeanFactoryPostProcessor
     * 
     * @return BeanFactoryPostProcessor列表
     */
    public List<BeanFactoryPostProcessor> getBeanFactoryPostProcessors() {
        return this.beanFactoryPostProcessors;
    }
}

4. PostProcessorRegistrationDelegate委托类

/*
 * PostProcessorRegistrationDelegate是处理BeanFactoryPostProcessor的委托类
 * 负责按正确顺序调用各种后处理器
 */
class PostProcessorRegistrationDelegate {

    /**
     * 调用BeanFactoryPostProcessor的核心实现
     * 
     * @param beanFactory Bean工厂
     * @param beanFactoryPostProcessors 已注册的BeanFactoryPostProcessor
     */
    public static void invokeBeanFactoryPostProcessors(
            ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {

        // 已处理的BeanFactoryPostProcessor名称集合
        Set<String> processedBeans = new HashSet<>();

        // 如果Bean工厂是BeanDefinitionRegistry类型
        if (beanFactory instanceof BeanDefinitionRegistry) {
            BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
            List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
            List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();

            // 分离BeanFactoryPostProcessor和BeanDefinitionRegistryPostProcessor
            for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
                if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
                    BeanDefinitionRegistryPostProcessor registryProcessor =
                            (BeanDefinitionRegistryPostProcessor) postProcessor;
                    // 先调用BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry方法
                    registryProcessor.postProcessBeanDefinitionRegistry(registry);
                    registryProcessors.add(registryProcessor);
                }
                else {
                    regularPostProcessors.add(postProcessor);
                }
            }

            // 不要在这里初始化FactoryBeans：我们需要保留所有常规BeanDefinitionRegistryPostProcessor Bean，
            // 将首先对其中的Bean进行实例化，然后再调用其中的postProcessBeanDefinitionRegistry方法
            List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();

            // 首先，调用实现PriorityOrdered接口的BeanDefinitionRegistryPostProcessor
            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接口的BeanDefinitionRegistryPostProcessor
            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();

            // 最后，调用所有其他的BeanDefinitionRegistryPostProcessor，直到不再发现为止
            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();
            }

            // 现在，调用到目前为止处理过的所有处理器的postProcessBeanFactory回调
            invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
            invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
        }

        else {
            // 调用在上下文实例中注册的工厂处理器
            invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
        }

        // 不要在这里初始化FactoryBeans：我们需要保留所有常规BeanFactoryPostProcessor Bean，
        // 将首先对其中的Bean进行实例化，然后再调用其中的postProcessBeanFactory方法
        String[] postProcessorNames =
                beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

        // 分离实现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
            }
            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接口的BeanFactoryPostProcessor
        sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
        invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

        // 接下来，调用实现Ordered接口的BeanFactoryPostProcessor
        List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
        for (String postProcessorName : orderedPostProcessorNames) {
            orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
        }
        sortPostProcessors(orderedPostProcessors, beanFactory);
        invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

        // 最后，调用所有其他的BeanFactoryPostProcessor
        List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
        for (String postProcessorName : nonOrderedPostProcessorNames) {
            nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
        }
        invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);

        // 清除合并的Bean定义缓存，因为后处理器可能已经修改了原始元数据（例如，替换占位符）
        beanFactory.clearMetadataCache();
    }
    
    /**
     * 调用BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry方法
     */
    private static void invokeBeanDefinitionRegistryPostProcessors(
            Collection<? extends BeanDefinitionRegistryPostProcessor> postProcessors, BeanDefinitionRegistry registry) {

        for (BeanDefinitionRegistryPostProcessor postProcessor : postProcessors) {
            postProcessor.postProcessBeanDefinitionRegistry(registry);
        }
    }
    
    /**
     * 调用BeanFactoryPostProcessor的postProcessBeanFactory方法
     */
    private static void invokeBeanFactoryPostProcessors(
            Collection<? extends BeanFactoryPostProcessor> postProcessors, ConfigurableListableBeanFactory beanFactory) {

        for (BeanFactoryPostProcessor postProcessor : postProcessors) {
            postProcessor.postProcessBeanFactory(beanFactory);
        }
    }
    
    /**
     * 对后处理器进行排序
     */
    private static void sortPostProcessors(List<?> postProcessors, ConfigurableListableBeanFactory beanFactory) {
        Comparator<Object> comparatorToUse = null;
        if (beanFactory instanceof DefaultListableBeanFactory) {
            comparatorToUse = ((DefaultListableBeanFactory) beanFactory).getDependencyComparator();
        }
        if (comparatorToUse == null) {
            comparatorToUse = OrderComparator.INSTANCE;
        }
        postProcessors.sort(comparatorToUse);
    }
}

5. 常见的BeanFactoryPostProcessor实现

/*
 * Spring框架中常见的BeanFactoryPostProcessor实现
 */

/**
 * PropertyPlaceholderConfigurer
 * 处理配置文件中的占位符
 */
public class PropertyPlaceholderConfigurer extends PlaceholderConfigurerSupport {
    
    // 系统属性模式
    public static final int SYSTEM_PROPERTIES_MODE_NEVER = 0;
    public static final int SYSTEM_PROPERTIES_MODE_FALLBACK = 1;
    public static final int SYSTEM_PROPERTIES_MODE_OVERRIDE = 2;
    
    // 系统属性模式，默认为回退模式
    private int systemPropertiesMode = SYSTEM_PROPERTIES_MODE_FALLBACK;
    
    // 本地属性
    @Nullable
    private Properties[] localProperties;
    
    // 设置本地属性
    public void setLocalProperties(Properties[] localProperties) {
        this.localProperties = localProperties;
    }
    
    // 设置系统属性模式
    public void setSystemPropertiesMode(int systemPropertiesMode) {
        this.systemPropertiesMode = systemPropertiesMode;
    }
    
    /**
     * 处理Bean工厂中的占位符
     */
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        try {
            // 加载属性
            Properties mergedProps = new Properties();
            
            // 加载本地属性
            if (this.localProperties != null) {
                for (Properties localProp : this.localProperties) {
                    mergedProps.putAll(localProp);
                }
            }
            
            // 处理Bean定义中的占位符
            processProperties(beanFactory, mergedProps);
        }
        catch (IOException ex) {
            throw new BeanInitializationException("Could not load properties", ex);
        }
    }
    
    /**
     * 处理属性
     */
    protected void processProperties(ConfigurableListableBeanFactory beanFactoryToProcess, Properties props)
            throws BeansException {

        // 创建占位符解析器
        StringValueResolver valueResolver = new PlaceholderResolvingStringValueResolver(props);
        
        // 处理所有Bean定义
        doProcessProperties(beanFactoryToProcess, valueResolver);
    }
    
    /**
     * 占位符解析器
     */
    private class PlaceholderResolvingStringValueResolver implements StringValueResolver {
        
        private final PropertyPlaceholderHelper helper;
        private final PropertyPlaceholderHelper.PlaceholderResolver resolver;
        
        public PlaceholderResolvingStringValueResolver(Properties props) {
            this.helper = new PropertyPlaceholderHelper(
                    placeholderPrefix, placeholderSuffix, valueSeparator, ignoreUnresolvablePlaceholders);
            this.resolver = new PropertyPlaceholderConfigurerResolver(props);
        }
        
        @Override
        @Nullable
        public String resolveStringValue(String strVal) throws BeansException {
            String resolved = this.helper.replacePlaceholders(strVal, this.resolver);
            if (trimValues) {
                resolved = resolved.trim();
            }
            return (resolved.equals(nullValue) ? null : resolved);
        }
    }
    
    /**
     * 属性解析器
     */
    private class PropertyPlaceholderConfigurerResolver implements PropertyPlaceholderHelper.PlaceholderResolver {
        
        private final Properties properties;
        
        public PropertyPlaceholderConfigurerResolver(Properties properties) {
            this.properties = properties;
        }
        
        @Override
        @Nullable
        public String resolvePlaceholder(String placeholderName) {
            return PropertyPlaceholderConfigurer.this.resolvePlaceholder(placeholderName, this.properties);
        }
    }
}

/**
 * PropertyOverrideConfigurer
 * 覆盖Bean定义中的属性值
 */
public class PropertyOverrideConfigurer extends PropertyResourceConfigurer {
    
    // 忽略无效键
    private boolean ignoreInvalidKeys = false;
    
    /**
     * 处理属性覆盖
     */
    @Override
    protected void processProperties(ConfigurableListableBeanFactory beanFactory, Properties props)
            throws BeansException {

        for (Enumeration<?> names = props.propertyNames(); names.hasMoreElements();) {
            String key = (String) names.nextElement();
            try {
                processKey(beanFactory, key, props.getProperty(key));
            }
            catch (BeansException ex) {
                String msg = "Could not process key '" + key + "' in PropertyOverrideConfigurer";
                if (!ignoreInvalidKeys) {
                    throw new BeanInitializationException(msg, ex);
                }
                if (logger.isDebugEnabled()) {
                    logger.debug(msg, ex);
                }
            }
        }
    }
    
    /**
     * 处理单个键
     */
    protected void processKey(ConfigurableListableBeanFactory factory, String key, String value)
            throws BeansException {

        // 分离Bean名称和属性路径
        int separatorIndex = key.indexOf('.');
        if (separatorIndex == -1) {
            throw new BeanInitializationException("Invalid key '" + key +
                    "': expected 'beanName.property' format");
        }
        
        String beanName = key.substring(0, separatorIndex);
        String beanProperty = key.substring(separatorIndex + 1);
        
        // 获取Bean定义
        BeanDefinition bd = factory.getBeanDefinition(beanName);
        
        // 应用属性值
        applyPropertyValue(factory, beanName, bd, beanProperty, value);
    }
    
    /**
     * 应用属性值
     */
    protected void applyPropertyValue(
            ConfigurableListableBeanFactory factory, String beanName, BeanDefinition bd,
            String property, String value) {

        // 创建属性值
        PropertyValue pv = new PropertyValue(property, value);
        
        // 应用到Bean定义
        bd.getPropertyValues().addPropertyValue(pv);
        
        if (logger.isDebugEnabled()) {
            logger.debug("Property '" + property + "' set to value '" + value + "' on bean '" + beanName + "'");
        }
    }
}

/**
 * CustomEditorConfigurer
 * 注册自定义属性编辑器
 */
public class CustomEditorConfigurer implements BeanFactoryPostProcessor, Ordered {
    
    // 自定义编辑器
    @Nullable
    private Map<Class<?>, Class<? extends PropertyEditor>> customEditors;
    
    // 优先级
    private int order = Ordered.LOWEST_PRECEDENCE;  // default: same as non-Ordered
    
    /**
     * 设置自定义编辑器
     */
    public void setCustomEditors(Map<Class<?>, Class<? extends PropertyEditor>> customEditors) {
        this.customEditors = customEditors;
    }
    
    /**
     * 设置优先级
     */
    public void setOrder(int order) {
        this.order = order;
    }
    
    @Override
    public int getOrder() {
        return this.order;
    }
    
    /**
     * 注册自定义属性编辑器
     */
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        if (this.customEditors != null) {
            // 获取Bean工厂的类型转换器
            ConfigurableBeanFactory cbf = (beanFactory instanceof ConfigurableBeanFactory ?
                    (ConfigurableBeanFactory) beanFactory : null);

            if (cbf != null) {
                TypeConverter tc = cbf.getTypeConverter();
                if (tc instanceof ConfigurableTypeConverter) {
                    // 注册自定义编辑器
                    for (Map.Entry<Class<?>, Class<? extends PropertyEditor>> entry : this.customEditors.entrySet()) {
                        Class<?> requiredType = entry.getKey();
                        Class<? extends PropertyEditor> propertyEditorClass = entry.getValue();
                        ConfigurableTypeConverter converter = (ConfigurableTypeConverter) tc;
                        converter.registerCustomEditor(requiredType, propertyEditorClass);
                    }
                }
            }
        }
    }
}

/**
 * ConfigurationClassPostProcessor
 * 处理@Configuration注解的配置类
 */
public class ConfigurationClassPostProcessor implements BeanDefinitionRegistryPostProcessor, 
        PriorityOrdered, ResourceLoaderAware, BeanClassLoaderAware, EnvironmentAware {
    
    // 日志记录器
    private static final Log logger = LogFactory.getLog(ConfigurationClassPostProcessor.class);
    
    // 优先级
    private static final int ORDER = Ordered.LOWEST_PRECEDENCE - 1;
    
    // Bean名称生成器
    private BeanNameGenerator componentScanBeanNameGenerator = new AnnotationBeanNameGenerator();
    
    // 资源加载器
    private ResourceLoader resourceLoader = new DefaultResourceLoader();
    
    // 类加载器
    @Nullable
    private ClassLoader beanClassLoader;
    
    // 环境
    private Environment environment;
    
    // 应用上下文
    @Nullable
    private ConfigurableApplicationContext applicationContext;
    
    /**
     * 设置BeanClassLoader
     */
    @Override
    public void setBeanClassLoader(ClassLoader beanClassLoader) {
        this.beanClassLoader = beanClassLoader;
    }
    
    /**
     * 设置环境
     */
    @Override
    public void setEnvironment(Environment environment) {
        this.environment = environment;
    }
    
    /**
     * 设置资源加载器
     */
    @Override
    public void setResourceLoader(ResourceLoader resourceLoader) {
        this.resourceLoader = resourceLoader;
    }
    
    /**
     * 获取优先级
     */
    @Override
    public int getOrder() {
        return ORDER;
    }
    
    /**
     * 处理Bean定义注册
     * 这是处理@Configuration类的主要方法
     */
    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
        // 获取Bean定义注册器
        BeanDefinitionRegistry registryToUse = registry;
        if (registry instanceof DefaultListableBeanFactory) {
            registryToUse = ((DefaultListableBeanFactory) registry).getInternalConfigurationAnnotationProcessor();
        }
        
        // 处理配置类
        processConfigBeanDefinitions(registryToUse);
    }
    
    /**
     * 处理Bean工厂
     */
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        // 增强配置类
        enhanceConfigurationClasses(beanFactory);
        // 添加导入注册器为Bean后处理器
        beanFactory.addBeanPostProcessor(new ImportAwareBeanPostProcessor(beanFactory));
    }
    
    /**
     * 处理配置Bean定义
     */
    public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
        List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
        String[] candidateNames = registry.getBeanDefinitionNames();
        
        // 查找配置候选类
        for (String beanName : candidateNames) {
            BeanDefinition beanDef = registry.getBeanDefinition(beanName);
            if (beanDef.getAttribute(ConfigurationClassUtils.CONFIGURATION_CLASS_ATTRIBUTE) != null) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
                }
            }
            else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
                configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
            }
        }
        
        // 如果没有配置候选类，直接返回
        if (configCandidates.isEmpty()) {
            return;
        }
        
        // 按照@Order注解排序
        configCandidates.sort((bd1, bd2) -> {
            int i1 = ConfigurationClassUtils.getOrder(bd1.getBeanDefinition());
            int i2 = ConfigurationClassUtils.getOrder(bd2.getBeanDefinition());
            return Integer.compare(i1, i2);
        });
        
        // 检测是否有自定义的BeanNameGenerator
        SingletonBeanRegistry sbr = null;
        if (registry instanceof SingletonBeanRegistry) {
            sbr = (SingletonBeanRegistry) registry;
            if (!this.localBeanNameGeneratorSet) {
                BeanNameGenerator generator = (BeanNameGenerator) sbr.getSingleton(
                        AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR);
                if (generator != null) {
                    this.componentScanBeanNameGenerator = generator;
                }
            }
        }
        
        if (this.environment == null) {
            this.environment = new StandardEnvironment();
        }
        
        // 创建配置类解析器
        ConfigurationClassParser parser = new ConfigurationClassParser(
                this.metadataReaderFactory, this.problemReporter, this.environment,
                this.resourceLoader, this.componentScanBeanNameGenerator, registry);
        
        Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
        Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());
        do {
            // 解析配置类
            parser.parse(candidates);
            parser.validate();
            
            Set<ConfigurationClass> configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());
            configClasses.removeAll(alreadyParsed);
            
            // 读取配置类并注册Bean定义
            if (registry instanceof BeanDefinitionRegistryPostProcessor) {
                BeanDefinitionRegistryPostProcessor registryPostProcessor = 
                        (BeanDefinitionRegistryPostProcessor) registry;
                for (ConfigurationClass configClass : configClasses) {
                    // 处理导入的Bean定义
                    parser.processImports(configClass, null, Collections.emptySet(), false);
                    // 处理Bean方法
                    parser.processBeanMethods(configClass);
                    // 处理导入的资源
                    parser.processImportedResources(configClass.getImportedResources());
                    // 处理导入的Bean定义注册器
                    parser.processInterfaces(configClass, configClass.getImportedResources());
                }
            }
            
            alreadyParsed.addAll(configClasses);
            
            candidates.clear();
            if (registry.getBeanDefinitionCount() > candidateNames.length) {
                String[] newCandidateNames = registry.getBeanDefinitionNames();
                Set<String> oldCandidateNames = new HashSet<>(Arrays.asList(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());
        
        // 注册ImportRegistry为Bean后处理器
        if (sbr != null && !sbr.containsSingleton(IMPORT_REGISTRY_BEAN_NAME)) {
            sbr.registerSingleton(IMPORT_REGISTRY_BEAN_NAME, parser.getImportRegistry());
        }
        
        if (this.metadataReaderFactory instanceof CachingMetadataReaderFactory) {
            // 清除缓存以释放内存
            ((CachingMetadataReaderFactory) this.metadataReaderFactory).clearCache();
        }
    }
}

6. 自定义BeanFactoryPostProcessor示例

/*
 * 自定义BeanFactoryPostProcessor实现示例
 */

/**
 * 数据库配置BeanFactoryPostProcessor
 * 根据环境动态配置数据库连接
 */
@Component
public class DatabaseConfigBeanFactoryPostProcessor implements BeanFactoryPostProcessor, Ordered {
    
    private static final Logger logger = LoggerFactory.getLogger(DatabaseConfigBeanFactoryPostProcessor.class);
    
    @Autowired
    private Environment environment;
    
    @Override
    public int getOrder() {
        return Ordered.HIGHEST_PRECEDENCE + 10; // 在PropertyPlaceholderConfigurer之后执行
    }
    
    /**
     * 处理Bean工厂，动态配置数据库连接
     */
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        // 获取所有数据源Bean定义
        String[] beanNames = beanFactory.getBeanDefinitionNames();
        
        for (String beanName : beanNames) {
            BeanDefinition beanDefinition = beanFactory.getBeanDefinition(beanName);
            
            // 检查是否为数据源Bean
            if (isDataSourceBean(beanDefinition)) {
                configureDataSource(beanDefinition, beanName);
            }
        }
    }
    
    /**
     * 判断是否为数据源Bean
     */
    private boolean isDataSourceBean(BeanDefinition beanDefinition) {
        String beanClassName = beanDefinition.getBeanClassName();
        if (beanClassName == null) {
            return false;
        }
        
        return beanClassName.contains("DataSource") || 
               beanClassName.contains("Hikari") ||
               beanClassName.contains("Druid");
    }
    
    /**
     * 配置数据源
     */
    private void configureDataSource(BeanDefinition beanDefinition, String beanName) {
        try {
            // 获取当前环境
            String activeProfile = environment.getActiveProfiles().length > 0 ? 
                environment.getActiveProfiles()[0] : "default";
            
            // 根据环境设置不同的配置
            String urlProperty = "spring.datasource." + activeProfile + ".url";
            String usernameProperty = "spring.datasource." + activeProfile + ".username";
            String passwordProperty = "spring.datasource." + activeProfile + ".password";
            
            String url = environment.getProperty(urlProperty);
            String username = environment.getProperty(usernameProperty);
            String password = environment.getProperty(passwordProperty);
            
            if (url != null) {
                // 设置URL属性
                MutablePropertyValues propertyValues = beanDefinition.getPropertyValues();
                propertyValues.addPropertyValue("url", url);
                propertyValues.addPropertyValue("username", username);
                propertyValues.addPropertyValue("password", password);
                
                logger.info("为Bean '{}' 配置数据源: {}", beanName, url);
            }
        } catch (Exception e) {
            logger.warn("配置数据源时出错: " + e.getMessage(), e);
        }
    }
}

/**
 * 条件化Bean注册BeanFactoryPostProcessor
 * 根据条件动态注册Bean
 */
@Component
public class ConditionalBeanRegistrationPostProcessor implements BeanDefinitionRegistryPostProcessor, Ordered {
    
    private static final Logger logger = LoggerFactory.getLogger(ConditionalBeanRegistrationPostProcessor.class);
    
    @Autowired
    private Environment environment;
    
    @Override
    public int getOrder() {
        return Ordered.HIGHEST_PRECEDENCE;
    }
    
    /**
     * 处理Bean定义注册
     */
    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
        // 根据条件注册不同的Bean
        registerConditionalBeans(registry);
    }
    
    /**
     * 处理Bean工厂
     */
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        // 这里可以进行额外的处理
    }
    
    /**
     * 注册条件化Bean
     */
    private void registerConditionalBeans(BeanDefinitionRegistry registry) {
        // 根据环境注册不同的缓存实现
        String cacheType = environment.getProperty("app.cache.type", "default");
        
        switch (cacheType) {
            case "redis":
                registerRedisCache(registry);
                break;
            case "ehcache":
                registerEhCache(registry);
                break;
            default:
                registerDefaultCache(registry);
                break;
        }
        
        // 根据特性开关注册监控Bean
        if (environment.getProperty("app.monitoring.enabled", Boolean.class, false)) {
            registerMonitoringBeans(registry);
        }
        
        // 根据部署环境注册不同的安全配置
        String deploymentEnv = environment.getProperty("app.deployment.env", "development");
        registerSecurityConfiguration(registry, deploymentEnv);
    }
    
    /**
     * 注册Redis缓存
     */
    private void registerRedisCache(BeanDefinitionRegistry registry) {
        GenericBeanDefinition beanDefinition = new GenericBeanDefinition();
        beanDefinition.setBeanClass(RedisCacheManager.class);
        beanDefinition.setScope(BeanDefinition.SCOPE_SINGLETON);
        
        // 设置属性
        MutablePropertyValues propertyValues = new MutablePropertyValues();
        propertyValues.addPropertyValue("redisHost", 
            environment.getProperty("redis.host", "localhost"));
        propertyValues.addPropertyValue("redisPort", 
            environment.getProperty("redis.port", Integer.class, 6379));
        beanDefinition.setPropertyValues(propertyValues);
        
        registry.registerBeanDefinition("cacheManager", beanDefinition);
        logger.info("注册Redis缓存管理器");
    }
    
    /**
     * 注册EhCache
     */
    private void registerEhCache(BeanDefinitionRegistry registry) {
        GenericBeanDefinition beanDefinition = new GenericBeanDefinition();
        beanDefinition.setBeanClass(EhCacheManager.class);
        beanDefinition.setScope(BeanDefinition.SCOPE_SINGLETON);
        
        registry.registerBeanDefinition("cacheManager", beanDefinition);
        logger.info("注册EhCache管理器");
    }
    
    /**
     * 注册默认缓存
     */
    private void registerDefaultCache(BeanDefinitionRegistry registry) {
        GenericBeanDefinition beanDefinition = new GenericBeanDefinition();
        beanDefinition.setBeanClass(ConcurrentMapCacheManager.class);
        beanDefinition.setScope(BeanDefinition.SCOPE_SINGLETON);
        
        registry.registerBeanDefinition("cacheManager", beanDefinition);
        logger.info("注册默认缓存管理器");
    }
    
    /**
     * 注册监控Bean
     */
    private void registerMonitoringBeans(BeanDefinitionRegistry registry) {
        // 注册性能监控Bean
        GenericBeanDefinition perfBeanDefinition = new GenericBeanDefinition();
        perfBeanDefinition.setBeanClass(PerformanceMonitor.class);
        perfBeanDefinition.setScope(BeanDefinition.SCOPE_SINGLETON);
        registry.registerBeanDefinition("performanceMonitor", perfBeanDefinition);
        
        // 注册日志监控Bean
        GenericBeanDefinition logBeanDefinition = new GenericBeanDefinition();
        logBeanDefinition.setBeanClass(LoggingMonitor.class);
        logBeanDefinition.setScope(BeanDefinition.SCOPE_SINGLETON);
        registry.registerBeanDefinition("loggingMonitor", logBeanDefinition);
        
        logger.info("注册监控Bean");
    }
    
    /**
     * 注册安全配置
     */
    private void registerSecurityConfiguration(BeanDefinitionRegistry registry, String environment) {
        GenericBeanDefinition beanDefinition = new GenericBeanDefinition();
        
        switch (environment) {
            case "production":
                beanDefinition.setBeanClass(ProductionSecurityConfig.class);
                break;
            case "staging":
                beanDefinition.setBeanClass(StagingSecurityConfig.class);
                break;
            default:
                beanDefinition.setBeanClass(DevelopmentSecurityConfig.class);
                break;
        }
        
        beanDefinition.setScope(BeanDefinition.SCOPE_SINGLETON);
        registry.registerBeanDefinition("securityConfig", beanDefinition);
        logger.info("注册{}环境的安全配置", environment);
    }
}

/**
 * 属性加密解密BeanFactoryPostProcessor
 * 处理加密的配置属性
 */
@Component
public class EncryptedPropertyBeanFactoryPostProcessor implements BeanFactoryPostProcessor, Ordered {
    
    private static final Logger logger = LoggerFactory.getLogger(EncryptedPropertyBeanFactoryPostProcessor.class);
    
    // 加密前缀
    private static final String ENCRYPTED_PREFIX = "{cipher}";
    
    @Autowired
    private TextEncryptor textEncryptor;
    
    @Override
    public int getOrder() {
        return Ordered.HIGHEST_PRECEDENCE + 5;
    }
    
    /**
     * 处理加密属性
     */
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        // 遍历所有Bean定义
        String[] beanNames = beanFactory.getBeanDefinitionNames();
        
        for (String beanName : beanNames) {
            BeanDefinition beanDefinition = beanFactory.getBeanDefinition(beanName);
            
            // 处理属性值
            PropertyValues propertyValues = beanDefinition.getPropertyValues();
            PropertyValue[] propertyArray = propertyValues.getPropertyValues();
            
            for (PropertyValue propertyValue : propertyArray) {
                Object value = propertyValue.getValue();
                if (value instanceof TypedStringValue) {
                    TypedStringValue typedStringValue = (TypedStringValue) value;
                    String stringValue = typedStringValue.getValue();
                    
                    // 检查是否为加密属性
                    if (stringValue != null && stringValue.startsWith(ENCRYPTED_PREFIX)) {
                        try {
                            // 解密属性值
                            String encryptedValue = stringValue.substring(ENCRYPTED_PREFIX.length());
                            String decryptedValue = textEncryptor.decrypt(encryptedValue);
                            
                            // 更新属性值
                            propertyValues.addPropertyValue(
                                new PropertyValue(propertyValue.getName(), decryptedValue));
                            
                            logger.debug("解密属性 '{}.{}'", beanName, propertyValue.getName());
                        } catch (Exception e) {
                            logger.error("解密属性 '{}.{}' 失败: {}", 
                                       beanName, propertyValue.getName(), e.getMessage());
                        }
                    }
                }
            }
        }
    }
}

/**
 * 版本控制BeanFactoryPostProcessor
 * 根据应用版本启用或禁用特定功能
 */
@Component
public class VersionControlBeanFactoryPostProcessor implements BeanDefinitionRegistryPostProcessor, Ordered {
    
    private static final Logger logger = LoggerFactory.getLogger(VersionControlBeanFactoryPostProcessor.class);
    
    @Autowired
    private Environment environment;
    
    @Override
    public int getOrder() {
        return Ordered.HIGHEST_PRECEDENCE + 20;
    }
    
    /**
     * 处理Bean定义注册
     */
    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
        String appVersion = environment.getProperty("app.version", "1.0.0");
        
        // 根据版本移除不兼容的Bean定义
        removeIncompatibleBeans(registry, appVersion);
        
        // 根据版本注册新的Bean定义
        registerVersionSpecificBeans(registry, appVersion);
    }
    
    /**
     * 处理Bean工厂
     */
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        // 可以在这里进行额外的处理
    }
    
    /**
     * 移除不兼容的Bean
     */
    private void removeIncompatibleBeans(BeanDefinitionRegistry registry, String appVersion) {
        // 示例：移除v2.0.0之前的废弃Bean
        if (compareVersions(appVersion, "2.0.0") >= 0) {
            String[] deprecatedBeans = {"oldService", "legacyComponent"};
            for (String beanName : deprecatedBeans) {
                if (registry.containsBeanDefinition(beanName)) {
                    registry.removeBeanDefinition(beanName);
                    logger.info("移除废弃的Bean: {}", beanName);
                }
            }
        }
    }
    
    /**
     * 注册版本特定的Bean
     */
    private void registerVersionSpecificBeans(BeanDefinitionRegistry registry, String appVersion) {
        // 示例：v2.1.0及以上版本注册新功能Bean
        if (compareVersions(appVersion, "2.1.0") >= 0) {
            GenericBeanDefinition newFeatureBean = new GenericBeanDefinition();
            newFeatureBean.setBeanClass(NewFeatureService.class);
            newFeatureBean.setScope(BeanDefinition.SCOPE_SINGLETON);
            registry.registerBeanDefinition("newFeatureService", newFeatureBean);
            logger.info("注册新功能服务Bean");
        }
        
        // 示例：v3.0.0及以上版本注册高级功能Bean
        if (compareVersions(appVersion, "3.0.0") >= 0) {
            GenericBeanDefinition advancedFeatureBean = new GenericBeanDefinition();
            advancedFeatureBean.setBeanClass(AdvancedFeatureService.class);
            advancedFeatureBean.setScope(BeanDefinition.SCOPE_SINGLETON);
            registry.registerBeanDefinition("advancedFeatureService", advancedFeatureBean);
            logger.info("注册高级功能服务Bean");
        }
    }
    
    /**
     * 比较版本号
     */
    private int compareVersions(String version1, String version2) {
        String[] parts1 = version1.split("\\.");
        String[] parts2 = version2.split("\\.");
        
        int length = Math.max(parts1.length, parts2.length);
        for (int i = 0; i < length; i++) {
            int v1 = i < parts1.length ? Integer.parseInt(parts1[i]) : 0;
            int v2 = i < parts2.length ? Integer.parseInt(parts2[i]) : 0;
            
            if (v1 < v2) return -1;
            if (v1 > v2) return 1;
        }
        return 0;
    }
}

7. 实际使用示例

/*
 * BeanFactoryPostProcessor实际使用示例
 */

/**
 * 配置驱动的BeanFactoryPostProcessor
 * 根据外部配置动态创建Bean
 */
@Component
public class ConfigurationDrivenBeanFactoryPostProcessor implements BeanDefinitionRegistryPostProcessor {
    
    private static final Logger logger = LoggerFactory.getLogger(ConfigurationDrivenBeanFactoryPostProcessor.class);
    
    @Autowired
    private Environment environment;
    
    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
        // 从配置中读取动态Bean定义
        registerDynamicBeansFromConfiguration(registry);
    }
    
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        // 可以在这里进行额外处理
    }
    
    /**
     * 从配置注册动态Bean
     */
    private void registerDynamicBeansFromConfiguration(BeanDefinitionRegistry registry) {
        try {
            // 读取配置中的Bean定义
            String[] beanNames = environment.getProperty("dynamic.beans.names", String[].class, new String[0]);
            
            for (String beanName : beanNames) {
                registerDynamicBean(registry, beanName);
            }
        } catch (Exception e) {
            logger.error("注册动态Bean时出错", e);
        }
    }
    
    /**
     * 注册单个动态Bean
     */
    private void registerDynamicBean(BeanDefinitionRegistry registry, String beanName) {
        try {
            // 读取Bean配置
            String className = environment.getProperty("dynamic.beans." + beanName + ".class");
            String scope = environment.getProperty("dynamic.beans." + beanName + ".scope", "singleton");
            
            if (className == null || className.isEmpty()) {
                logger.warn("Bean '{}' 缺少类名配置", beanName);
                return;
            }
            
            // 创建Bean定义
            GenericBeanDefinition beanDefinition = new GenericBeanDefinition();
            beanDefinition.setBeanClassName(className);
            beanDefinition.setScope(scope);
            
            // 设置属性值
            setBeanProperties(beanDefinition, beanName);
            
            // 注册Bean定义
            registry.registerBeanDefinition(beanName, beanDefinition);
            
            logger.info("动态注册Bean: {} (class: {}, scope: {})", beanName, className, scope);
        } catch (Exception e) {
            logger.error("注册动态Bean '{}' 时出错: {}", beanName, e.getMessage(), e);
        }
    }
    
    /**
     * 设置Bean属性
     */
    private void setBeanProperties(GenericBeanDefinition beanDefinition, String beanName) {
        MutablePropertyValues propertyValues = new MutablePropertyValues();
        
        // 读取所有以dynamic.beans.{beanName}.property.开头的属性
        String propertyPrefix = "dynamic.beans." + beanName + ".property.";
        
        Properties properties = new Properties();
        for (String key : environment.getPropertyNames()) {
            if (key.startsWith(propertyPrefix)) {
                String propertyName = key.substring(propertyPrefix.length());
                String propertyValue = environment.getProperty(key);
                propertyValues.addPropertyValue(propertyName, propertyValue);
            }
        }
        
        beanDefinition.setPropertyValues(propertyValues);
    }
}

/**
 * 组件扫描扩展BeanFactoryPostProcessor
 * 扩展默认的组件扫描功能
 */
@Component
public class ExtendedComponentScanBeanFactoryPostProcessor implements BeanDefinitionRegistryPostProcessor {
    
    private static final Logger logger = LoggerFactory.getLogger(ExtendedComponentScanBeanFactoryPostProcessor.class);
    
    @Autowired
    private Environment environment;
    
    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
        // 执行扩展的组件扫描
        performExtendedComponentScan(registry);
    }
    
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        // 可以在这里进行额外处理
    }
    
    /**
     * 执行扩展的组件扫描
     */
    private void performExtendedComponentScan(BeanDefinitionRegistry registry) {
        try {
            // 读取自定义扫描包
            String[] basePackages = environment.getProperty("app.scan.packages", String[].class, 
                new String[]{"com.example"});
            
            // 读取排除的类模式
            String[] excludePatterns = environment.getProperty("app.scan.exclude.patterns", String[].class, 
                new String[]{});
            
            // 执行扫描
            ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(registry, false);
            
            // 设置排除过滤器
            for (String pattern : excludePatterns) {
                scanner.addExcludeFilter(new RegexPatternTypeFilter(Pattern.compile(pattern)));
            }
            
            // 添加自定义注解过滤器
            scanner.addIncludeFilter(new AnnotationTypeFilter(CustomComponent.class));
            
            // 执行扫描
            int beanCount = scanner.scan(basePackages);
            logger.info("扩展组件扫描完成，注册了 {} 个Bean", beanCount);
            
        } catch (Exception e) {
            logger.error("执行扩展组件扫描时出错", e);
        }
    }
    
    /**
     * 自定义组件注解
     */
    @Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @Component
    public @interface CustomComponent {
        String value() default "";
    }
}

/**
 * 配置验证BeanFactoryPostProcessor
 * 验证配置的有效性
 */
@Component
public class ConfigurationValidationBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    
    private static final Logger logger = LoggerFactory.getLogger(ConfigurationValidationBeanFactoryPostProcessor.class);
    
    @Autowired
    private Environment environment;
    
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        // 验证配置
        validateConfiguration();
    }
    
    /**
     * 验证配置
     */
    private void validateConfiguration() {
        List<String> errors = new ArrayList<>();
        
        // 验证必需的配置项
        validateRequiredProperties(errors);
        
        // 验证数值范围
        validateNumericRanges(errors);
        
        // 验证格式
        validateFormats(errors);
        
        // 如果有错误，抛出异常
        if (!errors.isEmpty()) {
            StringBuilder errorMessage = new StringBuilder("配置验证失败:\n");
            for (String error : errors) {
                errorMessage.append("  - ").append(error).append("\n");
            }
            throw new IllegalStateException(errorMessage.toString());
        }
        
        logger.info("配置验证通过");
    }
    
    /**
     * 验证必需的属性
     */
    private void validateRequiredProperties(List<String> errors) {
        String[] requiredProperties = {
            "app.name",
            "app.version",
            "database.url",
            "database.username"
        };
        
        for (String property : requiredProperties) {
            if (!environment.containsProperty(property)) {
                errors.add("必需的配置项缺失: " + property);
            }
        }
    }
    
    /**
     * 验证数值范围
     */
    private void validateNumericRanges(List<String> errors) {
        // 验证线程池大小
        Integer threadPoolSize = environment.getProperty("app.thread.pool.size", Integer.class);
        if (threadPoolSize != null && (threadPoolSize < 1 || threadPoolSize > 1000)) {
            errors.add("线程池大小必须在1-1000之间: " + threadPoolSize);
        }
        
        // 验证超时时间
        Integer timeout = environment.getProperty("app.timeout.seconds", Integer.class);
        if (timeout != null && timeout < 0) {
            errors.add("超时时间不能为负数: " + timeout);
        }
    }
    
    /**
     * 验证格式
     */
    private void validateFormats(List<String> errors) {
        // 验证邮箱格式
        String email = environment.getProperty("app.admin.email");
        if (email != null && !isValidEmail(email)) {
            errors.add("邮箱格式不正确: " + email);
        }
        
        // 验证URL格式
        String url = environment.getProperty("database.url");
        if (url != null && !isValidUrl(url)) {
            errors.add("URL格式不正确: " + url);
        }
    }
    
    /**
     * 验证邮箱格式
     */
    private boolean isValidEmail(String email) {
        return email.matches("^[A-Za-z0-9+_.-]+@([A-Za-z0-9.-]+\\.[A-Za-z]{2,})$");
    }
    
    /**
     * 验证URL格式
     */
    private boolean isValidUrl(String url) {
        try {
            new URL(url);
            return true;
        } catch (MalformedURLException e) {
            return false;
        }
    }
}

8. 最佳实践和注意事项

/*
 * BeanFactoryPostProcessor最佳实践
 */

/**
 * 正确的实现方式
 */
@Component
public class GoodBeanFactoryPostProcessor implements BeanFactoryPostProcessor, Ordered {
    
    private static final Logger logger = LoggerFactory.getLogger(GoodBeanFactoryPostProcessor.class);
    
    @Autowired
    private Environment environment;
    
    @Override
    public int getOrder() {
        return Ordered.HIGHEST_PRECEDENCE + 100;
    }
    
    /**
     * 正确的实现方式
     */
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        try {
            // 记录开始日志
            logger.info("开始处理Bean工厂");
            
            // 执行具体的处理逻辑
            processBeanDefinitions(beanFactory);
            
            // 记录完成日志
            logger.info("Bean工厂处理完成");
        } catch (Exception e) {
            // 适当的异常处理
            logger.error("处理Bean工厂时出错", e);
            throw new BeanInitializationException("BeanFactoryPostProcessor处理失败", e);
        }
    }
    
    /**
     * 处理Bean定义
     */
    private void processBeanDefinitions(ConfigurableListableBeanFactory beanFactory) {
        // 获取所有Bean定义名称
        String[] beanNames = beanFactory.getBeanDefinitionNames();
        
        for (String beanName : beanNames) {
            try {
                BeanDefinition beanDefinition = beanFactory.getBeanDefinition(beanName);
                
                // 执行具体的处理逻辑
                processBeanDefinition(beanDefinition, beanName);
                
            } catch (Exception e) {
                // 单个Bean处理失败不应影响整体流程
                logger.warn("处理Bean定义 '{}' 时出错: {}", beanName, e.getMessage());
            }
        }
    }
    
    /**
     * 处理单个Bean定义
     */
    private void processBeanDefinition(BeanDefinition beanDefinition, String beanName) {
        // 检查是否需要处理
        if (shouldProcessBeanDefinition(beanDefinition)) {
            // 执行处理逻辑
            modifyBeanDefinition(beanDefinition, beanName);
        }
    }
    
    /**
     * 判断是否需要处理Bean定义
     */
    private boolean shouldProcessBeanDefinition(BeanDefinition beanDefinition) {
        // 实现具体的判断逻辑
        return true;
    }
    
    /**
     * 修改Bean定义
     */
    private void modifyBeanDefinition(BeanDefinition beanDefinition, String beanName) {
        // 实现具体的修改逻辑
        logger.debug("处理Bean定义: {}", beanName);
    }
}

/**
 * 避免的错误实现
 */
@Component
public class BadBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    
    @Autowired
    private SomeService someService; // 错误：不应该在此阶段注入Bean
    
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        // 错误1: 过早实例化Bean
        SomeService service = beanFactory.getBean(SomeService.class); // 应该避免
        
        // 错误2: 执行复杂业务逻辑
        performComplexBusinessLogic(); // 应该避免
        
        // 错误3: 不处理异常
        // 可能抛出异常的代码
        
        // 错误4: 修改已经实例化的Bean
        // 这个阶段不应该修改Bean实例
    }
    
    private void performComplexBusinessLogic() {
        // 复杂的业务逻辑不应该在这里执行
    }
}

/**
 * 线程安全的实现
 */
@Component
public class ThreadSafeBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    
    // 使用线程安全的集合
    private final Set<String> processedBeans = ConcurrentHashMap.newKeySet();
    private final Object lock = new Object();
    
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        // 线程安全的处理逻辑
        synchronized (lock) {
            processBeanDefinitions(beanFactory);
        }
    }
    
    private void processBeanDefinitions(ConfigurableListableBeanFactory beanFactory) {
        String[] beanNames = beanFactory.getBeanDefinitionNames();
        
        for (String beanName : beanNames) {
            if (processedBeans.add(beanName)) { // 线程安全的集合操作
                // 处理Bean定义
                BeanDefinition beanDefinition = beanFactory.getBeanDefinition(beanName);
                modifyBeanDefinition(beanDefinition, beanName);
            }
        }
    }
    
    private void modifyBeanDefinition(BeanDefinition beanDefinition, String beanName) {
        // 修改Bean定义的逻辑
    }
}

/**
 * 使用泛型的类型安全实现
 */
@Component
public class GenericTypeSafeBeanFactoryPostProcessor<T extends BeanDefinition> 
        implements BeanFactoryPostProcessor {
    
    private final Class<T> targetBeanDefinitionType;
    
    public GenericTypeSafeBeanFactoryPostProcessor(Class<T> targetBeanDefinitionType) {
        this.targetBeanDefinitionType = Assert.notNull(targetBeanDefinitionType, 
            "目标Bean定义类型不能为空");
    }
    
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        processBeanDefinitionsOfType(beanFactory, targetBeanDefinitionType);
    }
    
    /**
     * 处理指定类型的Bean定义
     */
    private <BD extends BeanDefinition> void processBeanDefinitionsOfType(
            ConfigurableListableBeanFactory beanFactory, Class<BD> beanDefinitionType) {
        
        String[] beanNames = beanFactory.getBeanDefinitionNames();
        
        for (String beanName : beanNames) {
            BeanDefinition beanDefinition = beanFactory.getBeanDefinition(beanName);
            
            if (beanDefinitionType.isInstance(beanDefinition)) {
                BD typedBeanDefinition = beanDefinitionType.cast(beanDefinition);
                processTypedBeanDefinition(typedBeanDefinition, beanName);
            }
        }
    }
    
    /**
     * 处理类型化的Bean定义
     */
    private void processTypedBeanDefinition(T beanDefinition, String beanName) {
        // 处理具体类型的Bean定义
    }
}