AnnotationConfigApplicationContext 简介

AnnotationConfigApplicationContext 是 Spring 框架中用于支持基于注解配置的核心容器类之一，它属于 org.springframework.context.annotation 包。与传统的基于 XML 配置的 ClassPathXmlApplicationContext 不同，AnnotationConfigApplicationContext 支持使用 Java 注解（如 @Component, @Service, @Repository, @Configuration, @Bean 等）来定义和管理 Bean。

🧩 一、基本使用方式

配置类

@Configuration
@ComponentScan("com.example")
public class AppConfig {
    @Bean
    public DataSource dataSource() {
        return new EmbeddedDatabaseBuilder().build();
    }
}

主程序

public class App {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        DataSource ds = context.getBean(DataSource.class);
        System.out.println(ds);
        context.close();
    }
}

📦 二、源码

1. new AnnotatedBeanDefinitionReader(this)在refresh()之前调用

// AnnotationConfigApplicationContext 是基于注解的容器上下文
public class AnnotationConfigApplicationContext extends GenericApplicationContext implements AnnotationConfigRegistry {

    // 内部使用一个 AnnotatedBeanDefinitionReader 来读取带有注解的类（如 @Component、@Configuration）
    private final AnnotatedBeanDefinitionReader reader;

    // 使用 ClassPathBeanDefinitionScanner 进行包扫描，自动注册 Bean
    private final ClassPathBeanDefinitionScanner scanner;


    /**
     * 默认构造函数：
     * 创建一个空的 BeanFactory，并初始化注解处理器和组件扫描器。
     */
    public AnnotationConfigApplicationContext() {
        // 初始化 AnnotatedBeanDefinitionReader，用于注册配置类（例如通过 register 方法传入的类）
        this.reader = new AnnotatedBeanDefinitionReader(this);

        // 初始化 ClassPathBeanDefinitionScanner，用于扫描指定包路径下的类，自动注册 Bean
        this.scanner = new ClassPathBeanDefinitionScanner(this);
    }

    /**
     * 构造函数：接受一个或多个配置类作为参数，通常是标注了 @Configuration 的类
     * 会将这些类注册为 Bean，并触发组件扫描
     */
    public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
        this(); // 调用默认构造函数，初始化 reader 和 scanner
        register(annotatedClasses); // 注册传入的配置类
        refresh(); // 刷新上下文，启动整个 IOC 容器的加载过程
    }

    /**
     * 构造函数：接受包路径，进行自动扫描注册 Bean
     */
    public AnnotationConfigApplicationContext(String... basePackages) {
        this(); // 同样调用默认构造函数
        scan(basePackages); // 执行包扫描
        refresh(); // 刷新上下文
    }


    /**
     * 注册一个或多个配置类
     * 实际是通过 reader 将这些类封装成 BeanDefinition 并注册到 BeanFactory 中
     */
    @Override
    public void register(Class<?>... annotatedClasses) {
        Assert.notEmpty(annotatedClasses, "At least one annotated class must be specified");
        this.reader.register(annotatedClasses);
    }

    /**
     * 扫描指定包路径下的类，并注册 BeanDefinition
     */
    @Override
    public void scan(String... basePackages) {
        Assert.notEmpty(basePackages, "At least one base package must be specified");
        this.scanner.scan(basePackages);
    }



    // ----------------------------- 核心方法 -----------------------------

    /**
     * refresh() 方法定义在 AbstractApplicationContext 中
     * 它是整个 Spring 容器启动的核心流程
     * 主要完成如下步骤：
     * 1. 准备刷新环境
     * 2. 创建或刷新 BeanFactory
     * 3. 加载 BeanDefinitions（核心一步）
     * 4. 准备 BeanFactory
     * 5. 初始化其他扩展功能（如 MessageSource、ApplicationEventMulticaster 等）
     * 6. 初始化单例 Bean（懒加载除外）
     * 7. 发布应用事件
     */
    @Override
    public void refresh() throws BeansException, IllegalStateException {
        synchronized (this.startupShutdownMonitor) {
            // 1. 准备刷新：记录时间、设置状态等
            prepareRefresh();

            // 2. 获取一个新的 BeanFactory，或者创建一个新的
            ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

            // 3. 设置 BeanFactory 的一些属性（如类加载器、表达式解析器等）
            prepareBeanFactory(beanFactory);

            try {
                // 4. 允许子类对 BeanFactory 做进一步定制
                postProcessBeanFactory(beanFactory);

                // 5. 执行所有的 BeanFactoryPostProcessor（比如处理 @ComponentScan、@Import 等）
                invokeBeanFactoryPostProcessors(beanFactory);

                // 6. 注册 BeanPostProcessor（用于后续 Bean 创建时的增强处理）
                registerBeanPostProcessors(beanFactory);

                // 7. 初始化消息资源（国际化支持）
                initMessageSource();

                // 8. 初始化事件广播器
                initApplicationEventMulticaster();

                // 9. 子类实现的方法，用于初始化特定的上下文
                onRefresh();

                // 10. 注册监听器
                registerListeners();

                // 11. 初始化所有非懒加载的单例 Bean
                finishBeanFactoryInitialization(beanFactory);

                // 12. 完成刷新，发布事件
                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 {
                // 清除缓存
                resetCommonCaches();
            }
        }
    }
}

• GenericApplicationContext：提供了一个通用的 ApplicationContext 实现，内部使用 DefaultListableBeanFactory。
• AnnotationConfigRegistry：提供了 register() 和 scan() 方法的支持。
• AnnotatedBeanDefinitionReader：注册 Spring 内部的一些注解处理器。

2. 核心组件

3. 关键点：

⚙️ 三、AnnotatedBeanDefinitionReader

1. 源码，重点是AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry)

/**
 * AnnotatedBeanDefinitionReader 是一个用于程序化注册 bean 类的便捷适配器。
 *
 * <p>这是对 {@link ClassPathBeanDefinitionScanner} 的替代方案，它应用了相同的注解解析逻辑，
 * 但仅适用于显式注册的类。
 *
 */
public class AnnotatedBeanDefinitionReader {

    /**
     * 使用给定的 registry 创建一个新的 AnnotatedBeanDefinitionReader。
     * 
     * <p>如果 registry 实现了 EnvironmentCapable 接口（例如 ApplicationContext），
     * 则会继承其 Environment；否则将创建一个新的 StandardEnvironment 并使用它。
     * 
     * @param registry 用于加载 Bean 定义的 BeanFactory，以 BeanDefinitionRegistry 形式提供
     * @see #AnnotatedBeanDefinitionReader(BeanDefinitionRegistry, Environment)
     * @see #setEnvironment(Environment)
     */
    public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry) {
        this(registry, getOrCreateEnvironment(registry));
    }

    /**
     * 使用给定的 registry 和 environment 创建一个新的 AnnotatedBeanDefinitionReader。
     * 
     * @param registry 用于加载 Bean 定义的 BeanFactory，以 BeanDefinitionRegistry 形式提供
     * @param environment 在评估 Bean 定义配置文件时使用的环境
     * @since 3.1
     */
    public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment) {
        Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
        Assert.notNull(environment, "Environment must not be null");
        this.registry = registry;
        // 初始化 ConditionEvaluator
        this.conditionEvaluator = new ConditionEvaluator(registry, environment, null);
        // 注册 Spring 内部的一些注解处理器（如 Configuration、ComponentScan 等）
        AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
    }

}

2. AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry)，重点是注册ConfigurationClassPostProcessor

public static void registerAnnotationConfigProcessors(BeanDefinitionRegistry registry) {
    registerAnnotationConfigProcessors(registry, null);
}

public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
        BeanDefinitionRegistry registry, @Nullable Object source) {

    // 获取或创建一个存放 BeanDefinitionHolder 的集合
    Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>();

    // 1. 注册 ConfigurationClassPostProcessor，用于处理 @Configuration 注解
    if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
        RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
        def.setSource(source);
        beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
    }

    // 2. 注册 AutowiredAnnotationBeanPostProcessor，处理 @Autowired 和 @Value
    if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
        RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
        def.setSource(source);
        beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
    }

    // 3. 注册 CommonAnnotationBeanPostProcessor，处理 @Resource, @PostConstruct, @PreDestroy
    if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
        RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
        def.setSource(source);
        beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
    }

    // 4. 注册 PersistenceAnnotationBeanPostProcessor，处理 @PersistenceContext
    if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) {
        RootBeanDefinition def = new RootBeanDefinition(PersistenceAnnotationBeanPostProcessor.class);
        def.setSource(source);
        beanDefs.add(registerPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME));
    }

    // 5. 注册 EventListenerMethodProcessor，处理 @EventListener
    if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {
        RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);
        def.setSource(source);
        beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));
    }

    // 6. 注册 DefaultEventListenerFactory，提供默认的事件监听器工厂
    if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {
        RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);
        def.setSource(source);
        beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));
    }

    return beanDefs;
}

🔍 四、ConfigurationClassPostProcessor

ConfigurationClassPostProcessor 是 Spring 框架中用于处理 @Configuration 类的核心组件，它是一个 BeanFactoryPostProcessor，在容器启动阶段对配置类进行解析和注册相关的 Bean 定义。

类结构

public class ConfigurationClassPostProcessor implements BeanDefinitionRegistryPostProcessor,
		BeanRegistrationAotProcessor, BeanFactoryInitializationAotProcessor, PriorityOrdered,
		ResourceLoaderAware, ApplicationStartupAware, BeanClassLoaderAware, EnvironmentAware {}

执行顺序

BeanDefinitionRegistryPostProcessor 的 postProcessBeanDefinitionRegistry() 会在其 postProcessBeanFactory() 之前执行，这样postProcessBeanFactory()才能对 postProcessBeanDefinitionRegistry() 注册的@Configuration 配置类增强（代理）

核心方法：postProcessBeanDefinitionRegistry

	/**
	 * 从 registry 中派生出更多的 BeanDefinition，主要是处理配置类。
	 */
	@Override
	public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
		int registryId = System.identityHashCode(registry);
		if (this.registriesPostProcessed.contains(registryId)) {
			throw new IllegalStateException(
					"postProcessBeanDefinitionRegistry already called on this post-processor against " + registry);
		}
		if (this.factoriesPostProcessed.contains(registryId)) {
			throw new IllegalStateException(
					"postProcessBeanFactory already called on this post-processor against " + registry);
		}
		this.registriesPostProcessed.add(registryId);
		processConfigBeanDefinitions(registry); // 处理配置类
	}

核心方法：postProcessBeanFactory

	/**
	 * 准备配置类以支持运行时请求 Bean，
	 * 方法是用 CGLIB 增强子类替换它们。
	 */
	@Override
	public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
		int factoryId = System.identityHashCode(beanFactory);
		if (this.factoriesPostProcessed.contains(factoryId)) {
			throw new IllegalStateException(
					"postProcessBeanFactory already called on this post-processor against " + beanFactory);
		}
		this.factoriesPostProcessed.add(factoryId);
		if (!this.registriesPostProcessed.contains(factoryId)) {
			// 如果没有调用过 registry 处理，则在此处延迟处理
			processConfigBeanDefinitions((BeanDefinitionRegistry) beanFactory);
		}
		enhanceConfigurationClasses(beanFactory); // 增强配置类
		beanFactory.addBeanPostProcessor(new ImportAwareBeanPostProcessor(beanFactory)); // 添加后置处理器
	}

processConfigBeanDefinitions 方法

/**
 * 构建并验证基于配置类 registry 的配置模型。
 */
public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
    // 存储所有配置类候选
    List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
    String[] candidateNames = registry.getBeanDefinitionNames();

    // 遍历所有已注册的 BeanDefinition
    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);
            }
        }
        // 判断是否是一个配置类候选（是否标注了 @Configuration 或其他组件注解）
        else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
            configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
        }
    }

    // 如果没有找到任何配置类，直接返回
    if (configCandidates.isEmpty()) {
        return;
    }

    // 按照 order 排序（@Order 或 Ordered 接口定义的顺序）
    configCandidates.sort((bd1, bd2) -> {
        int i1 = ConfigurationClassUtils.getOrder(bd1.getBeanDefinition());
        int i2 = ConfigurationClassUtils.getOrder(bd2.getBeanDefinition());
        return Integer.compare(i1, i2);
    });

    // 获取 SingletonBeanRegistry（用于注册单例 Bean）
    SingletonBeanRegistry singletonRegistry = null;
    if (registry instanceof SingletonBeanRegistry sbr) {
        singletonRegistry = sbr;

        // 如果没有设置自定义的 BeanNameGenerator，则尝试从容器中获取
        if (!this.localBeanNameGeneratorSet) {
            BeanNameGenerator generator = (BeanNameGenerator) singletonRegistry.getSingleton(
                    AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR);
            if (generator != null) {
                this.componentScanBeanNameGenerator = generator;
                this.importBeanNameGenerator = generator;
            }
        }
    }

    // 如果 environment 为空，则创建一个 StandardEnvironment
    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 = CollectionUtils.newHashSet(configCandidates.size());

    do {
        StartupStep processConfig = this.applicationStartup.start("spring.context.config-classes.parse");

        // 解析配置类
        parser.parse(candidates);

        // 验证配置类（例如检查 @Bean 方法是否被正确声明）
        parser.validate();

        Set<ConfigurationClass> configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());
        configClasses.removeAll(alreadyParsed);

        // 加载 Bean 定义
        if (this.reader == null) {
            this.reader = new ConfigurationClassBeanDefinitionReader(
                    registry, this.sourceExtractor, this.resourceLoader, this.environment,
                    this.importBeanNameGenerator, parser.getImportRegistry());
        }
        this.reader.loadBeanDefinitions(configClasses); // 注册 BeanDefinition
        alreadyParsed.addAll(configClasses);

        processConfig.tag("classCount", () -> String.valueOf(configClasses.size())).end();

        // 清空候选列表，准备下一轮解析（可能有新注册的配置类）
        candidates.clear();

        // 如果有新增的 BeanDefinition，继续处理它们中的配置类
        if (registry.getBeanDefinitionCount() > candidateNames.length) {
            String[] newCandidateNames = registry.getBeanDefinitionNames();
            Set<String> oldCandidateNames = Set.of(candidateNames);
            Set<String> alreadyParsedClasses = CollectionUtils.newHashSet(alreadyParsed.size());

            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，以支持 ImportAware 配置类
    if (singletonRegistry != null && !singletonRegistry.containsSingleton(IMPORT_REGISTRY_BEAN_NAME)) {
        singletonRegistry.registerSingleton(IMPORT_REGISTRY_BEAN_NAME, parser.getImportRegistry());
    }

    // 存储 PropertySourceDescriptors，供 Ahead-of-time 使用
    this.propertySourceDescriptors = parser.getPropertySourceDescriptors();

    // 清除元数据读取器的缓存（如果是 CachingMetadataReaderFactory）
    if (this.metadataReaderFactory instanceof CachingMetadataReaderFactory cachingMetadataReaderFactory) {
        cachingMetadataReaderFactory.clearCache();
    }
}

📌 关键点

enhanceConfigurationClasses方法

用于增强（代理）配置类（@Configuration 类） ，以确保在调用 @Bean 方法时返回的是同一个 Bean 实例（即单例行为），而不是每次都创建新的实例。

/**
 * 对 BeanFactory 中的配置类进行后处理，查找需要增强的 @Configuration 类，
 * 然后通过 ConfigurationClassEnhancer 进行增强（CGLIB 代理）。
 *
 * <p>候选状态由 BeanDefinition 的元数据属性决定。
 */
public void enhanceConfigurationClasses(ConfigurableListableBeanFactory beanFactory) {
    // 创建一个记录需要增强的 BeanDefinition 映射表
    Map<String, AbstractBeanDefinition> configBeanDefs = new LinkedHashMap<>();

    // 遍历所有注册的 BeanDefinition
    for (String beanName : beanFactory.getBeanDefinitionNames()) {
        BeanDefinition beanDef = beanFactory.getBeanDefinition(beanName);
        Object configClassAttr = beanDef.getAttribute(ConfigurationClassUtils.CONFIGURATION_CLASS_ATTRIBUTE);

        AnnotationMetadata annotationMetadata = null;
        MethodMetadata methodMetadata = null;

        // 如果是 AnnotatedBeanDefinition，则提取其元数据信息
        if (beanDef instanceof AnnotatedBeanDefinition annotatedBeanDefinition) {
            annotationMetadata = annotatedBeanDefinition.getMetadata();
            methodMetadata = annotatedBeanDefinition.getFactoryMethodMetadata();
        }

        // 如果 BeanDefinition 没有 BeanClass 或者不是 full configuration class，尝试解析类
        if ((configClassAttr != null || methodMetadata != null) &&
                (beanDef instanceof AbstractBeanDefinition abd) && !abd.hasBeanClass()) {
            boolean liteConfigurationCandidateWithoutBeanMethods =
                    (ConfigurationClassUtils.CONFIGURATION_CLASS_LITE.equals(configClassAttr) &&
                            annotationMetadata != null && !ConfigurationClassUtils.hasBeanMethods(annotationMetadata));
            if (!liteConfigurationCandidateWithoutBeanMethods) {
                try {
                    // 解析 BeanClass（加载类）
                    abd.resolveBeanClass(this.beanClassLoader);
                } catch (Throwable ex) {
                    throw new IllegalStateException("Cannot load configuration class: " + beanDef.getBeanClassName(), ex);
                }
            }
        }

        // 如果是 full configuration class（即 @Configuration(proxyBeanMethods = true)）
        if (ConfigurationClassUtils.CONFIGURATION_CLASS_FULL.equals(configClassAttr)) {
            if (!(beanDef instanceof AbstractBeanDefinition abd)) {
                throw new BeanDefinitionStoreException("Cannot enhance @Configuration bean definition '" +
                        beanName + "' since it is not stored in an AbstractBeanDefinition subclass");
            } else if (beanFactory.containsSingleton(beanName)) {
                // 如果已经存在单例实例，说明过早初始化了，无法增强
                if (logger.isWarnEnabled()) {
                    logger.warn("Cannot enhance @Configuration bean definition '" + beanName +
                            "' since its singleton instance has been created too early. The typical cause " +
                            "is a non-static @Bean method with a BeanDefinitionRegistryPostProcessor " +
                            "return type: Consider declaring such methods as 'static' and/or marking the " +
                            "containing configuration class as 'proxyBeanMethods=false'.");
                }
            } else {
                // 加入增强队列
                configBeanDefs.put(beanName, abd);
            }
        }
    }

    // 如果没有需要增强的配置类，直接返回
    if (configBeanDefs.isEmpty()) {
        return;
    }

    // 创建增强器
    ConfigurationClassEnhancer enhancer = new ConfigurationClassEnhancer();

    // 遍历每个需要增强的 BeanDefinition
    for (Map.Entry<String, AbstractBeanDefinition> entry : configBeanDefs.entrySet()) {
        AbstractBeanDefinition beanDef = entry.getValue();

        // 设置标志，表示要保留目标类（不使用代理类作为目标）
        beanDef.setAttribute(AutoProxyUtils.PRESERVE_TARGET_CLASS_ATTRIBUTE, Boolean.TRUE);

        // 获取原始类
        Class<?> configClass = beanDef.getBeanClass();

        // 使用 CGLIB 增强类
        Class<?> enhancedClass = enhancer.enhance(configClass, this.beanClassLoader);

        // 如果增强后的类与原类不同，说明增强成功
        if (configClass != enhancedClass) {
            if (logger.isTraceEnabled()) {
                logger.trace(String.format("Replacing bean definition '%s' existing class '%s' with " +
                        "enhanced class '%s'", entry.getKey(), configClass.getName(), enhancedClass.getName()));
            }

            // 替换 BeanDefinition 中的 BeanClass 为增强后的类
            beanDef.setBeanClass(enhancedClass);
        }
    }
}

🔍 五、ConfigurationClassPostProcessor调用

详见上一篇