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

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

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

3 ·

CC 4.0 BY-SA版权

文章标签：

#spring #java #Instantiation #Aware #BeanPost #Processor #源码

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

118 篇文章

订阅专栏

Spring

47 篇文章

订阅专栏

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

1. InstantiationAwareBeanPostProcessor接口源码

/*
 * InstantiationAwareBeanPostProcessor接口是Spring框架中重要的BeanPostProcessor扩展
 * 提供了在Bean实例化过程中的回调方法
 * 允许在Bean实例化前后进行干预，是实现AOP代理等高级功能的基础
 * 
 * InstantiationAwareBeanPostProcessor的作用：
 * 1. 在Bean实例化前进行干预（返回代理对象）
 * 2. 在Bean实例化后、属性注入前进行控制
 * 3. 在属性注入时修改属性值
 * 4. 实现AOP代理、依赖注入等功能
 * 
 * 注意事项：
 * - 实现此接口会影响所有Bean的创建过程
 * - 需要谨慎实现，避免影响正常的Bean创建流程
 * - 性能开销较大，应避免在生产环境中过度使用
 */
package org.springframework.beans.factory.config;

import org.springframework.beans.BeansException;
import org.springframework.beans.PropertyValues;

/**
 * BeanPostProcessor的子接口，添加了实例化前后的回调方法
 * 
 * InstantiationAwareBeanPostProcessor在Bean生命周期的关键节点提供回调：
 * 1. postProcessBeforeInstantiation: Bean实例化前
 * 2. postProcessAfterInstantiation: Bean实例化后，属性注入前
 * 3. postProcessProperties: 属性注入时
 * 
 * 执行时机：
 * 1. postProcessBeforeInstantiation(实例化前)
 * 2. Bean实例化
 * 3. postProcessAfterInstantiation(实例化后)
 * 4. postProcessProperties(属性处理)
 * 5. 属性注入
 * 6. postProcessBeforeInitialization(初始化前)
 * 7. InitializingBean.afterPropertiesSet()
 * 8. 自定义init-method
 * 9. postProcessAfterInitialization(初始化后)
 * 
 * 常见实现：
 * - AbstractAutoProxyCreator: AOP代理创建
 * - AutowiredAnnotationBeanPostProcessor: @Autowired处理
 * - CommonAnnotationBeanPostProcessor: @Resource等注解处理
 * 
 * 注意：实现类应该声明为@Component或通过配置注册
 */
public interface InstantiationAwareBeanPostProcessor extends BeanPostProcessor {

    /**
     * 在目标Bean被实例化之前应用此BeanPostProcessor
     * 
     * 此方法在目标Bean的构造函数执行之前调用
     * 可以返回一个代理对象来替代实际的Bean实例化
     * 如果返回非null值，后续的实例化步骤将被跳过
     * 
     * @param beanClass 要实例化的Bean的类
     * @param beanName Bean的名称
     * @return 要使用的Bean实例，如果返回null则继续正常的实例化过程
     * @throws BeansException 如果处理过程中发生错误
     * 
     * 使用场景：
     * - 返回AOP代理对象
     * - 阻止Bean的实例化
     * - 提供特殊的Bean实例
     * - 实现懒加载代理
     */
    @Nullable
    default Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        return null;
    }

    /**
     * 在目标Bean被实例化之后应用此BeanPostProcessor
     * 
     * 此方法在Bean实例化之后、属性注入之前调用
     * 可以返回false来阻止后续的属性填充过程
     * 
     * @param bean 已经实例化的Bean实例
     * @param beanName Bean的名称
     * @return 如果应该继续使用属性填充和后续的初始化过程返回true，否则返回false
     * @throws BeansException 如果处理过程中发生错误
     * 
     * 使用场景：
     * - 跳过属性填充过程
     * - 对实例化后的Bean进行特殊处理
     * - 实现自定义的属性注入逻辑
     */
    default boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        return true;
    }

    /**
     * 在工厂将给定的属性值应用到给定的Bean之前，对它们进行后处理
     * 
     * 此方法在属性注入之前调用，可以修改、添加或删除属性值
     * 
     * @param pvs 要应用到Bean的属性值
     * @param bean 已经实例化的Bean实例
     * @param beanName Bean的名称
     * @return 要应用到Bean的属性值（永远不要为null）
     * @throws BeansException 如果处理过程中发生错误
     * 
     * 使用场景：
     * - 修改属性值
     * - 添加额外的属性
     * - 过滤属性值
     * - 实现复杂的属性注入逻辑
     */
    @Nullable
    default PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName)
            throws BeansException {

        return pvs;
    }

    /**
     * 已废弃的方法，使用postProcessProperties替代
     * 
     * @deprecated 从Spring 5.1开始废弃，使用postProcessProperties替代
     */
    @Deprecated
    @Nullable
    default PropertyValues postProcessPropertyValues(
            PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {

        return pvs;
    }

}

2. SmartInstantiationAwareBeanPostProcessor接口

/*
 * SmartInstantiationAwareBeanPostProcessor接口扩展了InstantiationAwareBeanPostProcessor
 * 提供了更智能的实例化感知能力
 */
package org.springframework.beans.factory.config;

import java.lang.reflect.Constructor;

import org.springframework.beans.BeansException;
import org.springframework.lang.Nullable;

/**
 * InstantiationAwareBeanPostProcessor的子接口，添加了类型预测和构造函数确定的能力
 * 
 * 提供了更高级的Bean实例化控制能力：
 * 1. predictBeanType: 预测Bean类型
 * 2. determineCandidateConstructors: 确定候选构造函数
 * 3. getEarlyBeanReference: 获取早期Bean引用（解决循环依赖）
 * 
 * 执行时机：
 * 1. predictBeanType(类型预测)
 * 2. determineCandidateConstructors(构造函数确定)
 * 3. postProcessBeforeInstantiation(实例化前)
 * 4. Bean实例化
 * 5. getEarlyBeanReference(早期引用)
 * 6. postProcessAfterInstantiation(实例化后)
 * 7. postProcessProperties(属性处理)
 */
public interface SmartInstantiationAwareBeanPostProcessor extends InstantiationAwareBeanPostProcessor {

    /**
     * 预测Bean的类型
     * 
     * 在Bean实例化之前调用，用于预测最终的Bean类型
     * 主要用于类型匹配和自动装配
     * 
     * @param beanClass 原始Bean类
     * @param beanName Bean的名称
     * @return 预测的Bean类型，如果无法预测则返回null
     * @throws BeansException 如果处理过程中发生错误
     * 
     * 使用场景：
     * - AOP代理类型预测
     * - 泛型类型解析
     * - 条件化类型确定
     */
    @Nullable
    default Class<?> predictBeanType(Class<?> beanClass, String beanName) throws BeansException {
        return null;
    }

    /**
     * 确定用于给定Bean的候选构造函数
     * 
     * 在Bean实例化之前调用，用于确定应该使用哪个构造函数
     * 可以用于实现构造函数注入的智能选择
     * 
     * @param beanClass Bean的类
     * @param beanName Bean的名称
     * @return 候选构造函数数组，如果使用默认构造函数则返回null
     * @throws BeansException 如果处理过程中发生错误
     * 
     * 使用场景：
     * - 构造函数注入
     * - 智能构造函数选择
     * - 条件化构造函数确定
     */
    @Nullable
    default Constructor<?>[] determineCandidateConstructors(Class<?> beanClass, String beanName)
            throws BeansException {

        return null;
    }

    /**
     * 获取对指定Bean的早期访问的引用，通常是为了解决循环引用
     * 
     * 在Bean实例化之后、完全初始化之前调用
     * 主要用于解决循环依赖问题，返回代理对象或原始对象
     * 
     * @param bean 原始Bean实例
     * @param beanName Bean的名称
     * @return 要暴露给其他Bean的Bean实例
     * @throws BeansException 如果处理过程中发生错误
     * 
     * 使用场景：
     * - AOP代理创建
     * - 循环依赖解决
     * - 延迟初始化代理
     */
    default Object getEarlyBeanReference(Object bean, String beanName) throws BeansException {
        return bean;
    }

}

3. AbstractAutowireCapableBeanFactory中InstantiationAwareBeanPostProcessor的处理

/*
 * AbstractAutowireCapableBeanFactory中InstantiationAwareBeanPostProcessor的处理逻辑
 */
public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
        implements AutowireCapableBeanFactory {
    
    /**
     * 创建Bean实例的核心方法
     * 包含InstantiationAwareBeanPostProcessor的调用
     * 
     * @param beanName Bean名称
     * @param mbd 合并的Bean定义
     * @param args 构造函数参数
     * @return Bean实例
     */
    protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
            throws BeanCreationException {

        if (logger.isTraceEnabled()) {
            logger.trace("Creating instance of bean '" + beanName + "'");
        }
        RootBeanDefinition mbdToUse = mbd;

        // 确保Bean类在此时实际解析
        Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
        if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
            mbdToUse = new RootBeanDefinition(mbd);
            mbdToUse.setBeanClass(resolvedClass);
        }

        // 准备方法覆盖
        try {
            mbdToUse.prepareMethodOverrides();
        }
        catch (BeanDefinitionValidationException ex) {
            throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
                    beanName, "Validation of method overrides failed", ex);
        }

        try {
            // 给BeanPostProcessors一个返回代理对象而不是目标Bean实例的机会
            Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
            if (bean != null) {
                return bean;
            }
        }
        catch (Throwable ex) {
            throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
                    "BeanPostProcessor before instantiation of bean failed", ex);
        }

        try {
            // 实际创建Bean实例
            Object beanInstance = doCreateBean(beanName, mbdToUse, args);
            if (logger.isTraceEnabled()) {
                logger.trace("Finished creating instance of bean '" + beanName + "'");
            }
            return beanInstance;
        }
        catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
            throw ex;
        }
        catch (Throwable ex) {
            throw new BeanCreationException(
                    mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
        }
    }
    
    /**
     * 在实例化之前解析Bean
     * 这是调用InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation的地方
     * 
     * @param beanName Bean名称
     * @param mbd Bean定义
     * @return 如果返回非null则使用返回的实例，否则继续正常实例化
     */
    @Nullable
    protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
        Object bean = null;
        if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
            // 确保Bean类型已经解析
            if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
                Class<?> targetType = determineTargetType(beanName, mbd);
                if (targetType != null) {
                    // 应用前置实例化处理
                    bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
                    if (bean != null) {
                        // 应用后置初始化处理
                        bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
                    }
                }
            }
            mbd.beforeInstantiationResolved = (bean != null);
        }
        return bean;
    }
    
    /**
     * 应用BeanPostProcessor的前置实例化处理
     * 调用InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation
     * 
     * @param beanClass Bean类
     * @param beanName Bean名称
     * @return 处理后的Bean实例或null
     */
    @Nullable
    protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {
        // 遍历所有InstantiationAwareBeanPostProcessor
        for (BeanPostProcessor bp : getBeanPostProcessors()) {
            if (bp instanceof InstantiationAwareBeanPostProcessor) {
                InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                // 调用前置实例化方法
                Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
                if (result != null) {
                    return result;
                }
            }
        }
        return null;
    }
    
    /**
     * 实际创建Bean的核心方法
     * 
     * @param beanName Bean名称
     * @param mbd Bean定义
     * @param args 构造函数参数
     * @return Bean实例
     */
    protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
            throws BeanCreationException {

        // 实例化Bean包装器
        BeanWrapper instanceWrapper = null;
        if (mbd.isSingleton()) {
            instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
        }
        if (instanceWrapper == null) {
            // 实际创建Bean实例
            instanceWrapper = createBeanInstance(beanName, mbd, args);
        }
        final Object bean = instanceWrapper.getWrappedInstance();
        Class<?> beanType = instanceWrapper.getWrappedClass();
        if (beanType != NullBean.class) {
            mbd.resolvedTargetType = beanType;
        }

        // 允许后处理器修改Bean定义的属性值
        synchronized (mbd.postProcessingLock) {
            if (!mbd.postProcessed) {
                try {
                    // 应用MergedBeanDefinitionPostProcessor
                    applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
                }
                catch (Throwable ex) {
                    throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                            "Post-processing of merged bean definition failed", ex);
                }
                mbd.postProcessed = true;
            }
        }

        // 提前暴露单例Bean以解决循环引用，必要时创建早期Bean引用
        boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
                isSingletonCurrentlyInCreation(beanName));
        if (earlySingletonExposure) {
            if (logger.isTraceEnabled()) {
                logger.trace("Eagerly caching bean '" + beanName +
                        "' to allow for resolving potential circular references");
            }
            // 添加早期单例对象
            addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
        }

        // 初始化Bean实例
        Object exposedObject = bean;
        try {
            // 填充Bean属性
            populateBean(beanName, mbd, instanceWrapper);
            // 初始化Bean
            exposedObject = initializeBean(beanName, exposedObject, mbd);
        }
        catch (Throwable ex) {
            if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
                throw (BeanCreationException) ex;
            }
            else {
                throw new BeanCreationException(
                        mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
            }
        }

        if (earlySingletonExposure) {
            Object earlySingletonReference = getSingleton(beanName, false);
            if (earlySingletonReference != null) {
                if (exposedObject == bean) {
                    exposedObject = earlySingletonReference;
                }
                else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
                    String[] dependentBeans = getDependentBeans(beanName);
                    Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
                    for (String dependentBean : dependentBeans) {
                        if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
                            actualDependentBeans.add(dependentBean);
                        }
                    }
                    if (!actualDependentBeans.isEmpty()) {
                        throw new BeanCurrentlyInCreationException(beanName,
                                "Bean with name '" + beanName + "' has been injected into other beans [" +
                                StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
                                "] in its raw version as part of a circular reference, but has eventually been " +
                                "wrapped. This means that said other beans do not use the final version of the " +
                                "bean. This is often the result of over-eager type matching - consider using " +
                                "'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.");
                    }
                }
            }
        }

        // 注册可销毁的Bean
        try {
            registerDisposableBeanIfNecessary(beanName, bean, mbd);
        }
        catch (BeanDefinitionValidationException ex) {
            throw new BeanCreationException(
                    mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
        }

        return exposedObject;
    }
    
    /**
     * 填充Bean属性
     * 这里调用InstantiationAwareBeanPostProcessor的属性处理方法
     * 
     * @param beanName Bean名称
     * @param mbd Bean定义
     * @param bw Bean包装器
     */
    @SuppressWarnings("deprecation")  // for postProcessPropertyValues
    protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
        if (bw == null) {
            if (mbd.hasPropertyValues()) {
                throw new BeanCreationException(
                        mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
            }
            else {
                // 跳过属性填充
                return;
            }
        }

        // 在设置属性之前给InstantiationAwareBeanPostProcessors最后一次修改Bean的机会
        if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
            for (BeanPostProcessor bp : getBeanPostProcessors()) {
                if (bp instanceof InstantiationAwareBeanPostProcessor) {
                    InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                    // 调用后置实例化方法
                    if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
                        return;
                    }
                }
            }
        }

        PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);

        int resolvedAutowireMode = mbd.getResolvedAutowireMode();
        if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
            MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
            // 按名称自动装配
            if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
                autowireByName(beanName, mbd, bw, newPvs);
            }
            // 按类型自动装配
            if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
                autowireByType(beanName, mbd, bw, newPvs);
            }
            pvs = newPvs;
        }

        boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
        boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);

        PropertyDescriptor[] filteredPds = null;
        if (hasInstAwareBpps) {
            if (pvs == null) {
                pvs = mbd.getPropertyValues();
            }
            // 应用InstantiationAwareBeanPostProcessor的属性处理
            for (BeanPostProcessor bp : getBeanPostProcessors()) {
                if (bp instanceof InstantiationAwareBeanPostProcessor) {
                    InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                    // 调用属性处理方法
                    PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
                    if (pvsToUse == null) {
                        if (filteredPds == null) {
                            filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
                        }
                        pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
                        if (pvsToUse == null) {
                            return;
                        }
                    }
                    pvs = pvsToUse;
                }
            }
        }
        if (needsDepCheck) {
            if (filteredPds == null) {
                filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
            }
            checkDependencies(beanName, mbd, filteredPds, pvs);
        }

        if (pvs != null) {
            // 应用属性值到Bean实例
            applyPropertyValues(beanName, mbd, bw, pvs);
        }
    }
    
    /**
     * 获取早期Bean引用
     * 调用SmartInstantiationAwareBeanPostProcessor.getEarlyBeanReference
     * 
     * @param beanName Bean名称
     * @param mbd Bean定义
     * @param bean Bean实例
     * @return 早期Bean引用
     */
    protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
        Object exposedObject = bean;
        if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
            for (BeanPostProcessor bp : getBeanPostProcessors()) {
                if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
                    SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
                    // 调用获取早期引用方法
                    exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
                }
            }
        }
        return exposedObject;
    }
}

4. 常见的InstantiationAwareBeanPostProcessor实现

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

/**
 * AbstractAutoProxyCreator
 * AOP代理创建的核心实现
 */
public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport
        implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware {
    
    // 代理创建缓存
    private final Map<Object, Object> earlyProxyReferences = new ConcurrentHashMap<>(16);
    
    // 代理目标类集合
    private final Set<String> proxyTypes = Collections.newSetFromMap(new ConcurrentHashMap<>(16));
    
    // BeanFactory引用
    private ConfigurableListableBeanFactory beanFactory;
    
    /**
     * 实例化前处理 - 创建AOP代理
     */
    @Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) {
        Object cacheKey = getCacheKey(beanClass, beanName);

        if (!StringUtils.hasLength(beanName) || !this.targetSourcedBeans.contains(beanName)) {
            if (this.advisedBeans.containsKey(cacheKey)) {
                return null;
            }
            if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {
                this.advisedBeans.put(cacheKey, Boolean.FALSE);
                return null;
            }
        }

        // 创建代理
        Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(beanClass, beanName, null);
        if (specificInterceptors != DO_NOT_PROXY) {
            this.advisedBeans.put(cacheKey, Boolean.TRUE);
            Object proxy = createProxy(
                    beanClass, beanName, specificInterceptors, new TargetSource() {
                        @Override
                        public Class<?> getTargetClass() {
                            return beanClass;
                        }
                        @Override
                        public boolean isStatic() {
                            return false;
                        }
                        @Override
                        public Object getTarget() {
                            return null;
                        }
                        @Override
                        public void releaseTarget(Object target) {
                        }
                    });
            this.proxyTypes.put(cacheKey, proxy.getClass());
            return proxy;
        }

        this.advisedBeans.put(cacheKey, Boolean.FALSE);
        return null;
    }
    
    /**
     * 实例化后处理
     */
    @Override
    public boolean postProcessAfterInstantiation(Object bean, String beanName) {
        return true; // 继续正常的属性填充过程
    }
    
    /**
     * 属性处理
     */
    @Override
    public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
        return pvs; // 不修改属性值
    }
    
    /**
     * 获取早期Bean引用 - 解决循环依赖时创建代理
     */
    @Override
    public Object getEarlyBeanReference(Object bean, String beanName) {
        Object cacheKey = getCacheKey(bean.getClass(), beanName);
        this.earlyProxyReferences.put(cacheKey, bean);
        return wrapIfNecessary(bean, beanName, cacheKey);
    }
    
    /**
     * 初始化后处理 - 创建代理
     */
    @Override
    public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
        if (bean != null) {
            Object cacheKey = getCacheKey(bean.getClass(), beanName);
            if (this.earlyProxyReferences.remove(cacheKey) != bean) {
                return wrapIfNecessary(bean, beanName, cacheKey);
            }
        }
        return bean;
    }
    
    /**
     * 包装Bean如果必要
     */
    protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
        if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
            return bean;
        }
        if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
            return bean;
        }
        if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
            this.advisedBeans.put(cacheKey, Boolean.FALSE);
            return bean;
        }

        // 创建AOP代理
        Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
        if (specificInterceptors != DO_NOT_PROXY) {
            this.advisedBeans.put(cacheKey, Boolean.TRUE);
            Object proxy = createProxy(
                    bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
            this.proxyTypes.put(cacheKey, proxy.getClass());
            return proxy;
        }

        this.advisedBeans.put(cacheKey, Boolean.FALSE);
        return bean;
    }
    
    /**
     * 创建代理
     */
    protected Object createProxy(Class<?> beanClass, @Nullable String beanName,
            @Nullable Object[] specificInterceptors, TargetSource targetSource) {

        if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
            AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
        }

        ProxyFactory proxyFactory = new ProxyFactory();
        proxyFactory.copyFrom(this);

        if (!proxyFactory.isProxyTargetClass()) {
            if (shouldProxyTargetClass(beanClass, beanName)) {
                proxyFactory.setProxyTargetClass(true);
            }
            else {
                evaluateProxyInterfaces(beanClass, proxyFactory);
            }
        }

        Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
        proxyFactory.addAdvisors(advisors);
        proxyFactory.setTargetSource(targetSource);
        customizeProxyFactory(proxyFactory);

        proxyFactory.setFrozen(this.freezeProxy);
        if (advisorsPreFiltered()) {
            proxyFactory.setPreFiltered(true);
        }

        return proxyFactory.getProxy(getProxyClassLoader());
    }
}

/**
 * AutowiredAnnotationBeanPostProcessor
 * 处理@Autowired和@Value注解
 */
public class AutowiredAnnotationBeanPostProcessor implements SmartInstantiationAwareBeanPostProcessor {
    
    // 要处理的注解类型
    private final Set<Class<? extends Annotation>> autowiredAnnotationTypes = new LinkedHashSet<>();
    
    // BeanFactory引用
    private ConfigurableListableBeanFactory beanFactory;
    
    public AutowiredAnnotationBeanPostProcessor() {
        this.autowiredAnnotationTypes.add(Autowired.class);
        this.autowiredAnnotationTypes.add(Value.class);
        try {
            this.autowiredAnnotationTypes.add((Class<? extends Annotation>)
                    ClassUtils.forName("javax.inject.Inject", AutowiredAnnotationBeanPostProcessor.class.getClassLoader()));
        }
        catch (ClassNotFoundException ex) {
            // JSR-330 API not available - simply skip.
        }
    }
    
    /**
     * 设置BeanFactory
     */
    @Override
    public void setBeanFactory(BeanFactory beanFactory) {
        if (!(beanFactory instanceof ConfigurableListableBeanFactory)) {
            throw new IllegalArgumentException(
                    "AutowiredAnnotationBeanPostProcessor requires a ConfigurableListableBeanFactory: " + beanFactory);
        }
        this.beanFactory = (ConfigurableListableBeanFactory) beanFactory;
    }
    
    /**
     * 实例化后处理
     */
    @Override
    public boolean postProcessAfterInstantiation(Object bean, String beanName) {
        return true; // 继续正常的属性填充过程
    }
    
    /**
     * 属性处理 - 处理@Autowired和@Value注解
     */
    @Override
    public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
        // 查找自动装配元数据
        InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);
        try {
            // 注入依赖
            metadata.inject(bean, beanName, pvs);
        }
        catch (BeanCreationException ex) {
            throw ex;
        }
        catch (Throwable ex) {
            throw new BeanCreationException(beanName, "Injection of autowired dependencies failed", ex);
        }
        return pvs;
    }
    
    /**
     * 查找自动装配元数据
     */
    private InjectionMetadata findAutowiringMetadata(String beanName, Class<?> clazz, @Nullable PropertyValues pvs) {
        // 缓存键
        String cacheKey = (StringUtils.hasLength(beanName) ? beanName : clazz.getName());
        // 从缓存中获取或构建元数据
        InjectionMetadata metadata = this.injectionMetadataCache.get(cacheKey);
        if (InjectionMetadata.needsRefresh(metadata, clazz)) {
            synchronized (this.injectionMetadataCache) {
                metadata = this.injectionMetadataCache.get(cacheKey);
                if (InjectionMetadata.needsRefresh(metadata, clazz)) {
                    if (metadata != null) {
                        metadata.clear(pvs);
                    }
                    metadata = buildAutowiringMetadata(clazz);
                    this.injectionMetadataCache.put(cacheKey, metadata);
                }
            }
        }
        return metadata;
    }
    
    /**
     * 构建自动装配元数据
     */
    private InjectionMetadata buildAutowiringMetadata(final Class<?> clazz) {
        if (!AnnotationUtils.isCandidateClass(clazz, this.autowiredAnnotationTypes)) {
            return InjectionMetadata.EMPTY;
        }

        List<InjectionMetadata.InjectedElement> elements = new ArrayList<>();
        Class<?> targetClass = clazz;

        do {
            final List<InjectionMetadata.InjectedElement> currElements = new ArrayList<>();

            // 处理字段
            ReflectionUtils.doWithLocalFields(targetClass, field -> {
                AnnotationAttributes ann = findAutowiredAnnotation(field);
                if (ann != null) {
                    if (Modifier.isStatic(field.getModifiers())) {
                        if (logger.isInfoEnabled()) {
                            logger.info("Autowired annotation is not supported on static fields: " + field);
                        }
                        return;
                    }
                    boolean required = determineRequiredStatus(ann);
                    currElements.add(new AutowiredFieldElement(field, required));
                }
            });

            // 处理方法
            ReflectionUtils.doWithLocalMethods(targetClass, method -> {
                Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);
                if (!BridgeMethodResolver.isVisibilityBridgeMethodPair(method, bridgedMethod)) {
                    return;
                }
                AnnotationAttributes ann = findAutowiredAnnotation(bridgedMethod);
                if (ann != null && method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) {
                    if (Modifier.isStatic(method.getModifiers())) {
                        if (logger.isInfoEnabled()) {
                            logger.info("Autowired annotation is not supported on static methods: " + method);
                        }
                        return;
                    }
                    if (method.getParameterCount() == 0) {
                        if (logger.isInfoEnabled()) {
                            logger.info("Autowired annotation should only be used on methods with parameters: " +
                                    method);
                        }
                    }
                    boolean required = determineRequiredStatus(ann);
                    PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
                    currElements.add(new AutowiredMethodElement(method, required, pd));
                }
            });

            elements.addAll(0, currElements);
            targetClass = targetClass.getSuperclass();
        }
        while (targetClass != null && targetClass != Object.class);

        return new InjectionMetadata(clazz, elements);
    }
    
    /**
     * 自动装配字段元素
     */
    private class AutowiredFieldElement extends InjectionMetadata.InjectedElement {
        
        private final boolean required;
        private volatile boolean cached = false;
        @Nullable
        private volatile Object cachedFieldValue;
        
        public AutowiredFieldElement(Field field, boolean required) {
            super(field, null);
            this.required = required;
        }
        
        @Override
        protected void inject(Object bean, @Nullable String beanName, @Nullable PropertyValues pvs) {
            Field field = (Field) this.member;
            Object value;
            if (this.cached) {
                value = resolvedCachedArgument(beanName, this.cachedFieldValue);
            }
            else {
                DependencyDescriptor desc = new DependencyDescriptor(field, this.required);
                desc.setContainingClass(bean.getClass());
                Set<String> autowiredBeanNames = new LinkedHashSet<>(1);
                Assert.state(beanFactory != null, "No BeanFactory available");
                TypeConverter typeConverter = beanFactory.getTypeConverter();
                try {
                    value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);
                }
                catch (BeansException ex) {
                    throw new UnsatisfiedDependencyException(null, beanName, new InjectionPoint(field), ex);
                }
                synchronized (this) {
                    if (!this.cached) {
                        if (value != null || this.required) {
                            this.cachedFieldValue = value;
                        }
                        else {
                            this.cachedFieldValue = null;
                        }
                        this.cached = true;
                    }
                }
            }
            if (value != null) {
                ReflectionUtils.makeAccessible(field);
                field.set(bean, value);
            }
        }
    }
    
    /**
     * 自动装配方法元素
     */
    private class AutowiredMethodElement extends InjectionMetadata.InjectedElement {
        
        private final boolean required;
        private volatile boolean cached = false;
        @Nullable
        private volatile Object[] cachedMethodArguments;
        
        public AutowiredMethodElement(Method method, boolean required, @Nullable PropertyDescriptor pd) {
            super(method, pd);
            this.required = required;
        }
        
        @Override
        protected void inject(Object bean, @Nullable String beanName, @Nullable PropertyValues pvs) {
            if (checkPropertySkipping(pvs)) {
                return;
            }
            Method method = (Method) this.member;
            Object[] arguments;
            if (this.cached) {
                // Shortcut for avoiding synchronization...
                arguments = resolveCachedArguments(beanName);
            }
            else {
                int argumentCount = method.getParameterCount();
                arguments = new Object[argumentCount];
                DependencyDescriptor[] descriptors = new DependencyDescriptor[argumentCount];
                Set<String> autowiredBeans = new LinkedHashSet<>(argumentCount);
                Assert.state(beanFactory != null, "No BeanFactory available");
                TypeConverter typeConverter = beanFactory.getTypeConverter();
                for (int i = 0; i < arguments.length; i++) {
                    MethodParameter methodParam = new MethodParameter(method, i);
                    DependencyDescriptor desc = new DependencyDescriptor(methodParam, this.required);
                    desc.setContainingClass(bean.getClass());
                    descriptors[i] = desc;
                    try {
                        Object arg = beanFactory.resolveDependency(desc, beanName, autowiredBeans, typeConverter);
                        if (arg == null && !this.required) {
                            arguments = null;
                            break;
                        }
                        arguments[i] = arg;
                    }
                    catch (BeansException ex) {
                        throw new UnsatisfiedDependencyException(null, beanName, new InjectionPoint(methodParam), ex);
                    }
                }
                synchronized (this) {
                    if (!this.cached) {
                        if (arguments != null) {
                            Object[] cachedMethodArguments = new Object[parameterCount];
                            System.arraycopy(arguments, 0, cachedMethodArguments, 0, arguments.length);
                            this.cachedMethodArguments = cachedMethodArguments;
                        }
                        else {
                            this.cachedMethodArguments = null;
                        }
                        this.cached = true;
                    }
                }
            }
            if (arguments != null) {
                try {
                    ReflectionUtils.makeAccessible(method);
                    method.invoke(bean, arguments);
                }
                catch (InvocationTargetException ex) {
                    throw new BeanCreationException("Error invoking method", ex.getTargetException());
                }
                catch (IllegalArgumentException ex) {
                    throw new BeanCreationException("Illegal argument", ex);
                }
            }
        }
    }
}

/**
 * CommonAnnotationBeanPostProcessor
 * 处理JSR-250注解（如@PostConstruct、@PreDestroy、@Resource等）
 */
public class CommonAnnotationBeanPostProcessor extends InitDestroyAnnotationBeanPostProcessor
        implements InstantiationAwareBeanPostProcessor, BeanFactoryAware, Serializable {
    
    @Nullable
    private transient BeanFactory beanFactory;
    
    public CommonAnnotationBeanPostProcessor() {
        setOrder(Ordered.LOWEST_PRECEDENCE - 3);
    }
    
    @Override
    public void setBeanFactory(BeanFactory beanFactory) {
        if (beanFactory instanceof ConfigurableListableBeanFactory) {
            this.beanFactory = beanFactory;
        }
    }
    
    /**
     * 属性处理 - 处理@Resource注解
     */
    @Override
    public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
        // 处理@Resource注解的字段和方法
        InjectionMetadata metadata = findResourceMetadata(beanName, bean.getClass(), pvs);
        try {
            metadata.inject(bean, beanName, pvs);
        }
        catch (Throwable ex) {
            throw new BeanCreationException(beanName, "Injection of resource dependencies failed", ex);
        }
        return pvs;
    }
    
    /**
     * 查找资源元数据
     */
    private InjectionMetadata findResourceMetadata(String beanName, Class<?> clazz, @Nullable PropertyValues pvs) {
        // 缓存键
        String cacheKey = (StringUtils.hasLength(beanName) ? beanName : clazz.getName());
        // 从缓存中获取或构建元数据
        InjectionMetadata metadata = this.injectionMetadataCache.get(cacheKey);
        if (InjectionMetadata.needsRefresh(metadata, clazz)) {
            synchronized (this.injectionMetadataCache) {
                metadata = this.injectionMetadataCache.get(cacheKey);
                if (InjectionMetadata.needsRefresh(metadata, clazz)) {
                    if (metadata != null) {
                        metadata.clear(pvs);
                    }
                    metadata = buildResourceMetadata(clazz);
                    this.injectionMetadataCache.put(cacheKey, metadata);
                }
            }
        }
        return metadata;
    }
    
    /**
     * 构建资源元数据
     */
    private InjectionMetadata buildResourceMetadata(final Class<?> clazz) {
        if (!AnnotationUtils.isCandidateClass(clazz, resourceAnnotationTypes)) {
            return InjectionMetadata.EMPTY;
        }

        List<InjectionMetadata.InjectedElement> elements = new ArrayList<>();
        Class<?> targetClass = clazz;

        do {
            final List<InjectionMetadata.InjectedElement> currElements = new ArrayList<>();

            // 处理字段
            ReflectionUtils.doWithLocalFields(targetClass, field -> {
                if (field.isAnnotationPresent(Resource.class)) {
                    if (Modifier.isStatic(field.getModifiers())) {
                        throw new IllegalStateException("@Resource annotation is not supported on static fields");
                    }
                    if (!this.ignoredResourceTypes.contains(field.getType().getName())) {
                        currElements.add(new ResourceElement(field, field, null));
                    }
                }
            });

            // 处理方法
            ReflectionUtils.doWithLocalMethods(targetClass, method -> {
                Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);
                if (!BridgeMethodResolver.isVisibilityBridgeMethodPair(method, bridgedMethod)) {
                    return;
                }
                if (method.isAnnotationPresent(Resource.class) &&
                        method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) {
                    if (Modifier.isStatic(method.getModifiers())) {
                        throw new IllegalStateException("@Resource annotation is not supported on static methods");
                    }
                    if (method.getParameterCount() != 1) {
                        throw new IllegalStateException("@Resource annotation requires a single-arg method: " + method);
                    }
                    if (!this.ignoredResourceTypes.contains(method.getParameterTypes()[0].getName())) {
                        PropertyDescriptor pd = BeanUtils.findPropertyForMethod(method, clazz);
                        currElements.add(new ResourceElement(method, pd, null));
                    }
                }
            });

            elements.addAll(0, currElements);
            targetClass = targetClass.getSuperclass();
        }
        while (targetClass != null && targetClass != Object.class);

        return new InjectionMetadata(clazz, elements);
    }
}

5. 自定义InstantiationAwareBeanPostProcessor示例

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

/**
 * 性能监控InstantiationAwareBeanPostProcessor
 * 为Bean添加性能监控功能
 */
@Component
public class PerformanceMonitorBeanPostProcessor implements SmartInstantiationAwareBeanPostProcessor {
    
    private static final Logger logger = LoggerFactory.getLogger(PerformanceMonitorBeanPostProcessor.class);
    
    // 监控代理缓存
    private final Map<String, Object> proxyCache = new ConcurrentHashMap<>();
    
    /**
     * 实例化前处理 - 创建性能监控代理
     */
    @Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        // 不在实例化前创建代理，让正常实例化过程进行
        return null;
    }
    
    /**
     * 实例化后处理
     */
    @Override
    public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        // 继续正常的属性填充过程
        return true;
    }
    
    /**
     * 属性处理
     */
    @Override
    public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {
        // 不修改属性值
        return pvs;
    }
    
    /**
     * 初始化后处理 - 添加性能监控
     */
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        // 检查是否需要添加性能监控
        if (shouldMonitor(bean, beanName)) {
            // 创建性能监控代理
            return createPerformanceProxy(bean, beanName);
        }
        return bean;
    }
    
    /**
     * 判断是否需要监控
     */
    private boolean shouldMonitor(Object bean, String beanName) {
        // 监控所有Service层的Bean
        return bean.getClass().getName().contains("service") ||
               bean.getClass().isAnnotationPresent(Service.class) ||
               bean.getClass().isAnnotationPresent(Monitored.class);
    }
    
    /**
     * 创建性能监控代理
     */
    private Object createPerformanceProxy(Object target, String beanName) {
        // 检查缓存
        Object cachedProxy = proxyCache.get(beanName);
        if (cachedProxy != null) {
            return cachedProxy;
        }
        
        // 创建代理
        Object proxy = Proxy.newProxyInstance(
            target.getClass().getClassLoader(),
            target.getClass().getInterfaces(),
            new PerformanceInvocationHandler(target, beanName)
        );
        
        // 缓存代理
        proxyCache.put(beanName, proxy);
        
        logger.info("为Bean '{}' 创建性能监控代理", beanName);
        return proxy;
    }
    
    /**
     * 性能监控调用处理器
     */
    private static class PerformanceInvocationHandler implements InvocationHandler {
        
        private final Object target;
        private final String beanName;
        private final Logger logger = LoggerFactory.getLogger(PerformanceInvocationHandler.class);
        
        public PerformanceInvocationHandler(Object target, String beanName) {
            this.target = target;
            this.beanName = beanName;
        }
        
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            long startTime = System.currentTimeMillis();
            try {
                // 执行目标方法
                Object result = method.invoke(target, args);
                return result;
            } finally {
                long endTime = System.currentTimeMillis();
                long executionTime = endTime - startTime;
                
                // 记录性能日志
                if (executionTime > 1000) { // 超过1秒的方法调用
                    logger.warn("Bean '{}' method '{}' executed in {} ms", 
                               beanName, method.getName(), executionTime);
                } else {
                    logger.debug("Bean '{}' method '{}' executed in {} ms", 
                                beanName, method.getName(), executionTime);
                }
            }
        }
    }
    
    /**
     * 自定义注解，标记需要监控的类
     */
    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.TYPE)
    public @interface Monitored {
    }
}

/**
 * 配置验证InstantiationAwareBeanPostProcessor
 * 验证Bean的配置是否正确
 */
@Component
public class ConfigurationValidationBeanPostProcessor implements InstantiationAwareBeanPostProcessor {
    
    private static final Logger logger = LoggerFactory.getLogger(ConfigurationValidationBeanPostProcessor.class);
    
    /**
     * 实例化后处理 - 验证Bean配置
     */
    @Override
    public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        try {
            validateBeanConfiguration(bean, beanName);
            return true; // 继续正常的属性填充过程
        } catch (Exception e) {
            logger.error("Bean '{}' 配置验证失败: {}", beanName, e.getMessage());
            throw new BeanInitializationException("Bean配置验证失败: " + beanName, e);
        }
    }
    
    /**
     * 属性处理
     */
    @Override
    public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {
        // 不修改属性值
        return pvs;
    }
    
    /**
     * 验证Bean配置
     */
    private void validateBeanConfiguration(Object bean, String beanName) {
        // 获取Bean的所有字段
        Field[] fields = bean.getClass().getDeclaredFields();
        
        for (Field field : fields) {
            // 检查@NotNull注解
            if (field.isAnnotationPresent(NotNull.class)) {
                field.setAccessible(true);
                try {
                    Object value = field.get(bean);
                    if (value == null) {
                        throw new IllegalStateException(
                            String.format("Bean '%s' field '%s' cannot be null", 
                                        beanName, field.getName()));
                    }
                } catch (IllegalAccessException e) {
                    logger.warn("Cannot access field {} of bean {}", field.getName(), beanName);
                }
            }
            
            // 检查@Min注解
            if (field.isAnnotationPresent(Min.class)) {
                Min minAnnotation = field.getAnnotation(Min.class);
                long minValue = minAnnotation.value();
                
                field.setAccessible(true);
                try {
                    Object value = field.get(bean);
                    if (value instanceof Number) {
                        long actualValue = ((Number) value).longValue();
                        if (actualValue < minValue) {
                            throw new IllegalStateException(
                                String.format("Bean '%s' field '%s' value %d is less than minimum %d", 
                                            beanName, field.getName(), actualValue, minValue));
                        }
                    }
                } catch (IllegalAccessException e) {
                    logger.warn("Cannot access field {} of bean {}", field.getName(), beanName);
                }
            }
            
            // 检查@NotEmpty注解
            if (field.isAnnotationPresent(NotEmpty.class)) {
                field.setAccessible(true);
                try {
                    Object value = field.get(bean);
                    if (value instanceof String) {
                        String stringValue = (String) value;
                        if (stringValue == null || stringValue.trim().isEmpty()) {
                            throw new IllegalStateException(
                                String.format("Bean '%s' field '%s' cannot be empty", 
                                            beanName, field.getName()));
                        }
                    } else if (value instanceof Collection) {
                        Collection<?> collection = (Collection<?>) value;
                        if (collection == null || collection.isEmpty()) {
                            throw new IllegalStateException(
                                String.format("Bean '%s' field '%s' collection cannot be empty", 
                                            beanName, field.getName()));
                        }
                    }
                } catch (IllegalAccessException e) {
                    logger.warn("Cannot access field {} of bean {}", field.getName(), beanName);
                }
            }
        }
    }
}

/**
 * 日志增强InstantiationAwareBeanPostProcessor
 * 为Bean添加日志功能
 */
@Component
public class LoggingBeanPostProcessor implements SmartInstantiationAwareBeanPostProcessor {
    
    private static final Logger logger = LoggerFactory.getLogger(LoggingBeanPostProcessor.class);
    
    // 日志代理缓存
    private final Map<String, Object> logProxyCache = new ConcurrentHashMap<>();
    
    /**
     * 实例化前处理
     */
    @Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        return null; // 不干预实例化过程
    }
    
    /**
     * 实例化后处理
     */
    @Override
    public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        return true; // 继续正常的属性填充过程
    }
    
    /**
     * 属性处理
     */
    @Override
    public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {
        return pvs; // 不修改属性值
    }
    
    /**
     * 初始化后处理 - 添加日志功能
     */
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        // 为带有@Logged注解的Bean创建日志代理
        if (bean.getClass().isAnnotationPresent(Logged.class)) {
            return createLoggingProxy(bean, beanName);
        }
        return bean;
    }
    
    /**
     * 创建日志代理
     */
    private Object createLoggingProxy(Object target, String beanName) {
        // 检查缓存
        Object cachedProxy = logProxyCache.get(beanName);
        if (cachedProxy != null) {
            return cachedProxy;
        }
        
        Object proxy = Proxy.newProxyInstance(
            target.getClass().getClassLoader(),
            target.getClass().getInterfaces(),
            new LoggingInvocationHandler(target, beanName)
        );
        
        // 缓存代理
        logProxyCache.put(beanName, proxy);
        
        logger.info("为Bean '{}' 创建日志代理", beanName);
        return proxy;
    }
    
    /**
     * 日志调用处理器
     */
    private static class LoggingInvocationHandler implements InvocationHandler {
        
        private final Object target;
        private final String beanName;
        private final Logger logger = LoggerFactory.getLogger(LoggingInvocationHandler.class);
        
        public LoggingInvocationHandler(Object target, String beanName) {
            this.target = target;
            this.beanName = beanName;
        }
        
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            // 检查方法是否有@Logged注解
            Logged methodLogged = method.getAnnotation(Logged.class);
            if (methodLogged != null) {
                logger.info("调用Bean '{}' 的方法 '{}'，参数: {}", 
                           beanName, method.getName(), Arrays.toString(args));
            }
            
            try {
                Object result = method.invoke(target, args);
                
                if (methodLogged != null) {
                    logger.info("Bean '{}' 的方法 '{}' 执行完成，返回值: {}", 
                               beanName, method.getName(), result);
                }
                
                return result;
            } catch (Exception e) {
                if (methodLogged != null) {
                    logger.error("Bean '{}' 的方法 '{}' 执行异常: {}", 
                                beanName, method.getName(), e.getMessage(), e);
                }
                throw e;
            }
        }
    }
    
    /**
     * 自定义注解，标记需要日志记录的类或方法
     */
    @Retention(RetentionPolicy.RUNTIME)
    @Target({ElementType.TYPE, ElementType.METHOD})
    public @interface Logged {
    }
}

/**
 * 缓存增强InstantiationAwareBeanPostProcessor
 * 为Bean添加缓存功能
 */
@Component
public class CacheBeanPostProcessor implements SmartInstantiationAwareBeanPostProcessor {
    
    private static final Logger logger = LoggerFactory.getLogger(CacheBeanPostProcessor.class);
    
    // 缓存代理缓存
    private final Map<String, Object> cacheProxyCache = new ConcurrentHashMap<>();
    
    // 全局缓存
    private final Map<String, Object> globalCache = new ConcurrentHashMap<>();
    
    /**
     * 实例化前处理
     */
    @Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        return null; // 不干预实例化过程
    }
    
    /**
     * 实例化后处理
     */
    @Override
    public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        return true; // 继续正常的属性填充过程
    }
    
    /**
     * 属性处理
     */
    @Override
    public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {
        return pvs; // 不修改属性值
    }
    
    /**
     * 初始化后处理 - 添加缓存功能
     */
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        // 为带有@Cacheable注解的Bean创建缓存代理
        if (hasCacheableMethods(bean)) {
            return createCacheProxy(bean, beanName);
        }
        return bean;
    }
    
    /**
     * 检查Bean是否有可缓存的方法
     */
    private boolean hasCacheableMethods(Object bean) {
        Method[] methods = bean.getClass().getDeclaredMethods();
        for (Method method : methods) {
            if (method.isAnnotationPresent(Cacheable.class)) {
                return true;
            }
        }
        return false;
    }
    
    /**
     * 创建缓存代理
     */
    private Object createCacheProxy(Object target, String beanName) {
        // 检查缓存
        Object cachedProxy = cacheProxyCache.get(beanName);
        if (cachedProxy != null) {
            return cachedProxy;
        }
        
        Object proxy = Proxy.newProxyInstance(
            target.getClass().getClassLoader(),
            target.getClass().getInterfaces(),
            new CacheInvocationHandler(target, beanName, globalCache)
        );
        
        // 缓存代理
        cacheProxyCache.put(beanName, proxy);
        
        logger.info("为Bean '{}' 创建缓存代理", beanName);
        return proxy;
    }
    
    /**
     * 缓存调用处理器
     */
    private static class CacheInvocationHandler implements InvocationHandler {
        
        private final Object target;
        private final String beanName;
        private final Map<String, Object> cache;
        private final Logger logger = LoggerFactory.getLogger(CacheInvocationHandler.class);
        
        public CacheInvocationHandler(Object target, String beanName, Map<String, Object> cache) {
            this.target = target;
            this.beanName = beanName;
            this.cache = cache;
        }
        
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            Cacheable cacheable = method.getAnnotation(Cacheable.class);
            if (cacheable != null) {
                // 生成缓存键
                String cacheKey = generateCacheKey(method, args);
                
                // 检查缓存
                Object cachedResult = cache.get(cacheKey);
                if (cachedResult != null) {
                    logger.debug("缓存命中: {}#{}({})", beanName, method.getName(), cacheKey);
                    return cachedResult;
                }
                
                // 执行方法并缓存结果
                Object result = method.invoke(target, args);
                cache.put(cacheKey, result);
                logger.debug("缓存存储: {}#{}({})", beanName, method.getName(), cacheKey);
                return result;
            }
            
            // 非缓存方法直接执行
            return method.invoke(target, args);
        }
        
        /**
         * 生成缓存键
         */
        private String generateCacheKey(Method method, Object[] args) {
            StringBuilder keyBuilder = new StringBuilder();
            keyBuilder.append(beanName).append(":").append(method.getName());
            if (args != null) {
                for (Object arg : args) {
                    keyBuilder.append(":").append(arg);
                }
            }
            return keyBuilder.toString();
        }
    }
    
    /**
     * 自定义注解，标记可缓存的方法
     */
    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.METHOD)
    public @interface Cacheable {
    }
}

6. 实际使用示例

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

/**
 * 动态代理创建服务
 */
@Service
public class DynamicProxyService {
    
    /**
     * 业务方法1
     */
    public String processBusinessData(String data) {
        // 模拟业务处理
        try {
            Thread.sleep(100); // 模拟处理时间
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        return "Processed: " + data;
    }
    
    /**
     * 业务方法2
     */
    public int calculateValue(int a, int b) {
        return a + b;
    }
}

/**
 * 配置验证服务
 */
@Service
public class ConfigurationValidationService {
    
    @NotNull
    private String requiredConfig;
    
    @Min(1)
    private int minConfig = 5;
    
    @NotEmpty
    private List<String> listConfig = Arrays.asList("item1", "item2");
    
    // Getters and Setters
    public String getRequiredConfig() { return requiredConfig; }
    public void setRequiredConfig(String requiredConfig) { this.requiredConfig = requiredConfig; }
    
    public int getMinConfig() { return minConfig; }
    public void setMinConfig(int minConfig) { this.minConfig = minConfig; }
    
    public List<String> getListConfig() { return listConfig; }
    public void setListConfig(List<String> listConfig) { this.listConfig = listConfig; }
}

/**
 * 日志记录服务
 */
@Service
@Logged
public class LoggingService {
    
    /**
     * 业务方法
     */
    @Logged
    public String performOperation(String input) {
        return "Operation result for: " + input;
    }
    
    /**
     * 另一个业务方法
     */
    @Logged
    public int performCalculation(int value) {
        return value * 2;
    }
}

/**
 * 缓存服务
 */
@Service
public class CacheService {
    
    /**
     * 可缓存的方法
     */
    @Cacheable
    public String getExpensiveData(String key) {
        // 模拟耗时操作
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        return "Expensive data for: " + key + " at " + System.currentTimeMillis();
    }
    
    /**
     * 另一个可缓存的方法
     */
    @Cacheable
    public int getCalculatedValue(int input) {
        // 模拟计算
        return input * input + input;
    }
}

/**
 * 应用程序主类
 */
@SpringBootApplication
public class Application {
    
    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(Application.class, args);
        
        // 测试各种功能
        testPerformanceMonitoring(context);
        testConfigurationValidation(context);
        testLogging(context);
        testCaching(context);
    }
    
    /**
     * 测试性能监控
     */
    private static void testPerformanceMonitoring(ConfigurableApplicationContext context) {
        DynamicProxyService service = context.getBean(DynamicProxyService.class);
        
        System.out.println("=== 性能监控测试 ===");
        String result = service.processBusinessData("test data");
        System.out.println("结果: " + result);
        
        int value = service.calculateValue(10, 20);
        System.out.println("计算结果: " + value);
    }
    
    /**
     * 测试配置验证
     */
    private static void testConfigurationValidation(ConfigurableApplicationContext context) {
        ConfigurationValidationService service = context.getBean(ConfigurationValidationService.class);
        
        System.out.println("=== 配置验证测试 ===");
        service.setRequiredConfig("valid config");
        service.setMinConfig(10);
        service.setListConfig(Arrays.asList("item1", "item2", "item3"));
        
        System.out.println("配置验证通过");
    }
    
    /**
     * 测试日志记录
     */
    private static void testLogging(ConfigurableApplicationContext context) {
        LoggingService service = context.getBean(LoggingService.class);
        
        System.out.println("=== 日志记录测试 ===");
        String result = service.performOperation("test input");
        System.out.println("操作结果: " + result);
        
        int value = service.performCalculation(42);
        System.out.println("计算结果: " + value);
    }
    
    /**
     * 测试缓存功能
     */
    private static void testCaching(ConfigurableApplicationContext context) {
        CacheService service = context.getBean(CacheService.class);
        
        System.out.println("=== 缓存功能测试 ===");
        
        // 第一次调用
        long startTime = System.currentTimeMillis();
        String result1 = service.getExpensiveData("key1");
        long endTime = System.currentTimeMillis();
        System.out.println("第一次调用耗时: " + (endTime - startTime) + "ms, 结果: " + result1);
        
        // 第二次调用（应该从缓存获取）
        startTime = System.currentTimeMillis();
        String result2 = service.getExpensiveData("key1");
        endTime = System.currentTimeMillis();
        System.out.println("第二次调用耗时: " + (endTime - startTime) + "ms, 结果: " + result2);
        
        // 计算方法测试
        int calc1 = service.getCalculatedValue(5);
        int calc2 = service.getCalculatedValue(5);
        System.out.println("计算结果1: " + calc1 + ", 计算结果2: " + calc2);
    }
}

7. 最佳实践和注意事项

/*
 * InstantiationAwareBeanPostProcessor最佳实践
 */

/**
 * 正确的实现方式
 */
@Component
public class GoodInstantiationAwareBeanPostProcessor implements SmartInstantiationAwareBeanPostProcessor {
    
    private static final Logger logger = LoggerFactory.getLogger(GoodInstantiationAwareBeanPostProcessor.class);
    
    // 使用线程安全的缓存
    private final Map<String, Object> proxyCache = new ConcurrentHashMap<>();
    private final Object cacheLock = new Object();
    
    @Override
    public int getOrder() {
        return Ordered.HIGHEST_PRECEDENCE; // 设置合适的优先级
    }
    
    /**
     * 实例化前处理
     */
    @Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        try {
            // 记录开始日志
            if (logger.isDebugEnabled()) {
                logger.debug("开始处理Bean实例化前阶段: {}", beanName);
            }
            
            // 执行具体的处理逻辑
            Object result = processBeforeInstantiation(beanClass, beanName);
            
            // 记录完成日志
            if (logger.isDebugEnabled()) {
                logger.debug("完成Bean实例化前阶段: {}, 结果: {}", beanName, result != null);
            }
            
            return result;
        } catch (Exception e) {
            // 适当的异常处理
            logger.error("处理Bean实例化前阶段时出错: {}", beanName, e);
            throw new BeanInitializationException("实例化前处理失败: " + beanName, e);
        }
    }
    
    /**
     * 实例化后处理
     */
    @Override
    public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        try {
            // 记录开始日志
            if (logger.isDebugEnabled()) {
                logger.debug("开始处理Bean实例化后阶段: {}", beanName);
            }
            
            // 执行具体的处理逻辑
            boolean result = processAfterInstantiation(bean, beanName);
            
            // 记录完成日志
            if (logger.isDebugEnabled()) {
                logger.debug("完成Bean实例化后阶段: {}, 继续处理: {}", beanName, result);
            }
            
            return result;
        } catch (Exception e) {
            // 适当的异常处理
            logger.error("处理Bean实例化后阶段时出错: {}", beanName, e);
            throw new BeanInitializationException("实例化后处理失败: " + beanName, e);
        }
    }
    
    /**
     * 属性处理
     */
    @Override
    public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {
        try {
            // 记录开始日志
            if (logger.isDebugEnabled()) {
                logger.debug("开始处理Bean属性阶段: {}", beanName);
            }
            
            // 执行具体的处理逻辑
            PropertyValues result = processProperties(pvs, bean, beanName);
            
            // 记录完成日志
            if (logger.isDebugEnabled()) {
                logger.debug("完成Bean属性阶段: {}", beanName);
            }
            
            return result;
        } catch (Exception e) {
            // 适当的异常处理
            logger.error("处理Bean属性阶段时出错: {}", beanName, e);
            throw new BeanInitializationException("属性处理失败: " + beanName, e);
        }
    }
    
    /**
     * 初始化后处理
     */
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        try {
            // 记录开始日志
            if (logger.isDebugEnabled()) {
                logger.debug("开始处理Bean初始化后阶段: {}", beanName);
            }
            
            // 执行具体的处理逻辑
            Object result = processAfterInitialization(bean, beanName);
            
            // 记录完成日志
            if (logger.isDebugEnabled()) {
                logger.debug("完成Bean初始化后阶段: {}", beanName);
            }
            
            return result;
        } catch (Exception e) {
            // 适当的异常处理
            logger.error("处理Bean初始化后阶段时出错: {}", beanName, e);
            throw new BeanInitializationException("初始化后处理失败: " + beanName, e);
        }
    }
    
    /**
     * 实例化前处理的具体实现
     */
    private Object processBeforeInstantiation(Class<?> beanClass, String beanName) {
        // 实现具体的处理逻辑
        return null; // 返回null继续正常实例化
    }
    
    /**
     * 实例化后处理的具体实现
     */
    private boolean processAfterInstantiation(Object bean, String beanName) {
        // 实现具体的处理逻辑
        return true; // 返回true继续属性填充
    }
    
    /**
     * 属性处理的具体实现
     */
    private PropertyValues processProperties(PropertyValues pvs, Object bean, String beanName) {
        // 实现具体的处理逻辑
        return pvs; // 返回原始属性值
    }
    
    /**
     * 初始化后处理的具体实现
     */
    private Object processAfterInitialization(Object bean, String beanName) {
        // 实现具体的处理逻辑
        return bean; // 返回原始Bean实例
    }
}

/**
 * 避免的错误实现
 */
@Component
public class BadInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor {
    
    @Autowired
    private SomeService someService; // 错误：不应该在此阶段注入Bean
    
    /**
     * 错误的实例化前处理
     */
    @Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        // 错误1: 过早实例化Bean
        SomeService service = someService; // 可能导致循环依赖
        
        // 错误2: 执行复杂业务逻辑
        performComplexBusinessLogic(); // 应该避免
        
        // 错误3: 不处理异常
        // 可能抛出异常的代码
        
        // 错误4: 返回不合适的代理对象
        return new Object(); // 可能导致类型不匹配
        
        return null; // 正确的做法是返回null继续正常流程
    }
    
    /**
     * 错误的实例化后处理
     */
    @Override
    public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        // 错误: 阻止属性填充而不给出合理原因
        return false; // 可能导致Bean无法正确初始化
        
        return true; // 正确的做法是返回true继续正常流程
    }
    
    /**
     * 错误的属性处理
     */
    @Override
    public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {
        // 错误: 返回null
        return null; // 会导致属性填充被跳过
        
        return pvs; // 正确的做法是返回原始或修改后的属性值
    }
    
    private void performComplexBusinessLogic() {
        // 复杂的业务逻辑不应该在这里执行
    }
}

/**
 * 线程安全的实现
 */
@Component
public class ThreadSafeInstantiationAwareBeanPostProcessor implements SmartInstantiationAwareBeanPostProcessor {
    
    // 使用线程安全的集合
    private final Map<String, Object> proxyCache = new ConcurrentHashMap<>();
    private final Set<String> processedBeans = ConcurrentHashMap.newKeySet();
    private final Object lock = new Object();
    
    @Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        // 线程安全的缓存操作
        if (proxyCache.containsKey(beanName)) {
            return proxyCache.get(beanName);
        }
        
        synchronized (lock) {
            if (proxyCache.containsKey(beanName)) {
                return proxyCache.get(beanName);
            }
            
            // 创建代理对象
            Object proxy = createProxy(beanClass, beanName);
            if (proxy != null) {
                proxyCache.put(beanName, proxy);
            }
            
            return proxy;
        }
    }
    
    @Override
    public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        // 线程安全的集合操作
        return processedBeans.add(beanName); // 线程安全的添加操作
    }
    
    @Override
    public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {
        // 线程安全的处理逻辑
        synchronized (lock) {
            return processPropertiesSafely(pvs, bean, beanName);
        }
    }
    
    private Object createProxy(Class<?> beanClass, String beanName) {
        // 创建代理的具体实现
        return null;
    }
    
    private PropertyValues processPropertiesSafely(PropertyValues pvs, Object bean, String beanName) {
        // 线程安全的属性处理
        return pvs;
    }
}

/**
 * 使用泛型的类型安全实现
 */
@Component
public class GenericTypeSafeBeanPostProcessor<T> implements SmartInstantiationAwareBeanPostProcessor {
    
    private final Class<T> targetType;
    private final Function<T, T> processor;
    
    public GenericTypeSafeBeanPostProcessor(Class<T> targetType, Function<T, T> processor) {
        this.targetType = Assert.notNull(targetType, "目标类型不能为空");
        this.processor = Assert.notNull(processor, "处理器不能为空");
    }
    
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        // 类型安全的处理
        if (targetType.isInstance(bean)) {
            @SuppressWarnings("unchecked")
            T typedBean = (T) bean;
            return processor.apply(typedBean);
        }
        return bean;
    }
    
    // 其他方法的实现...
}