Spring与SpringBoot的重要接口及核心概念

BeanPostProcessor

1、在refresh->prepareBeanFactory阶段 ，prepareBeanFactory方法中加入两个

// AbstractApplicationContext#prepareBeanFactory
beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this))
...
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

2、阶段: refresh --> invokeBeanFactoryPostProcessors阶段

ConfigurationClassPostProcessor#postProcessBeanFactory方法中加入1个

// ConfigurationClassPostProcessor#postProcessBeanFactory
beanFactory.addBeanPostProcessor(new ImportAwareBeanPostProcessor(beanFactory));

3、阶段: refresh --> registerBeanPostProcessors阶段

使用工具类方法PostProcessorRegistrationDelegate#registerBeanPostProcessors加入了1个

beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

4、阶段: refresh --> registerBeanPostProcessors阶段

这个阶段位于invokeBeanFactoryPostProcessors方法之后 这时配置文件已经扫描，BeanDefinition已经注册，包括系统中BeanPostProcessor的BeanDefinition也被注册

ctrl + h 搜索

public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
			BeanDefinitionRegistry registry, @Nullable Object source) {
		......
		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));
		}

		// Check for JSR-250 support, and if present add the CommonAnnotationBeanPostProcessor.
		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));
		}
		......
}

populateBean

populateBean 是 Spring 容器中负责将配置信息（BeanDefinition）映射到具体对象实例的关键方法。它不仅仅是一个简单的赋值器，更是一个复杂的流水线，涉及到了 BeanWrapper、自动装配以及 后置处理器 的协同工作。

以下是该方法核心逻辑的逐行注释与深度解析：

protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
    // 1. 空值校验：如果传入的 BeanWrapper 为 null，说明实例化失败或未创建成功
    if (bw == null) {
        // 如果此时还有属性值需要注入，抛出异常
        if (mbd.hasPropertyValues()) {
            throw new BeanCreationException(
                    mbd.getResourceDescription(), beanName, 
                    "Cannot apply property values to null instance");
        }
        else {
            // 没有属性值，直接跳过属性填充阶段
            return;
        }
    }
	// 2. 后置处理器介入 (InstantiationAwareBeanPostProcessors)
    // 在属性设置之前，给 InstantiationAwareBeanPostProcessors 提供修改 bean 状态的机会
    // 例如：支持字段注入 (Field Injection) 的实现
    if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
        for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
            // 如果 postProcessAfterInstantiation 返回 false，则停止后续的属性填充
            if (!bp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
                return;
            }
        }
    }
	// 3. 获取属性值集合
    PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
	
	// 4. 自动装配模式处理 (Autowire)
    int resolvedAutowireMode = mbd.getResolvedAutowireMode();
    if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
        // 创建一个新的 MutablePropertyValues 对象，用于暂存新的属性值
        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 变量，使其指向包含新装配值的对象
        pvs = newPvs;
    }
	
	// 5. 属性后处理 (Property Post-processing)
    boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
    boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);
    PropertyDescriptor[] filteredPds = null;
	if (hasInstAwareBpps) {
        if (pvs == null) {
            pvs = mbd.getPropertyValues();
        }
        // 遍历所有 InstantiationAwareBeanPostProcessors
        for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
            // 调用 postProcessProperties 处理属性值
            // 注意：postProcessPropertyValues 已被标记为 @Deprecated，推荐使用 postProcessProperties
            PropertyValues pvsToUse = bp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
			if (pvsToUse == null) {
                // 如果返回 null，说明该处理器不处理属性，或者需要进行依赖检查
                if (filteredPds == null) {
                    // 过滤掉那些不需要进行依赖检查的属性描述符
                    filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
                }
                // 调用旧版方法（已弃用），通常是为了兼容性
                pvsToUse = bp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
                if (pvsToUse == null) {
                    return;
                }
            }
            pvs = pvsToUse;
        }
    }
    
	// 6. 依赖检查 (Dependency Check)
    if (needsDepCheck) {
        if (filteredPds == null) {
            filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
        }
        // 执行具体的依赖检查逻辑
        checkDependencies(beanName, mbd, filteredPds, pvs);
    }

	// 7. 最终应用属性值
    // 将最终确定的 PropertyValues 应用到 BeanWrapper 中，完成属性填充
    if (pvs != null) {
        applyPropertyValues(beanName, mbd, bw, pvs);
    }
}

Spring

一、核心概念

BeanDefinition

PostProcessor后置处理器

二、重要接口

三、工具类

四、容器启动过程

AnnotationConfigApplicationContext构造方法中几乎完成了Spring容器的所有工作：配置文件和配置类的读取，创建BeanDefinition、创建bean实例...

SpringBoot

一、核心概念

二、重要接口

三、工具类

附录A - AnnotationConfigApplicationContext

AnnotatedBeanDefinitionReader

ClassPathBeanDefinitionScaner

AnnotationConfigApplicationContext构造方法中几乎完成了Spring容器的所有工作：配置文件/配置类的读取，创建BeanDefinition、创建bean实例...

public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
	this();// 1 
	register(annotatedClasses); // 2 将配置类的BeanDefinition注册进容器中
	refresh();// 3
}

public AnnotationConfigApplicationContext() {
	StartupStep createAnnotatedBeanDefReader 
		= this.getApplicationStartup().start("spring.context.annotated-bean-reader.create");
	// 1.1
	this.reader = new AnnotatedBeanDefinitionReader(this);
	createAnnotatedBeanDefReader.end();
	// 1.2
	this.scanner = new ClassPathBeanDefinitionScanner(this);
}

执行上面程序后的内存状态如下：

>内存状态

// AnnotationConfigApplicationContext
DefaultResourceLoader
	|-Set<ProtocolResolver> protocolResolvers
		= new LinkedHashSet<>(4);
	|-Map<Class<?>, Map<Resource, ?>> resourceCaches
		= new ConcurrentHashMap<>(4);
AbstractApplicationContext
	|-List<BeanFactoryPostProcessor> beanFactoryPostProcessors
		= new ArrayList<>()
	|-Set<ApplicationListener<?>> applicationListeners
		= new LinkedHashSet<>()
	|-ResourcePatternResolver resourcePatternResolver
		= new PathMatchingResourcePatternResolver(this)
	|-ConfigurableEnvironment environment
		= new StandardEnvironment()
		// (2.1)创建AnnotatedBeanDefinitionReader实例时调用
GenericApplicationContext
	  ★★★★★ 
	|-DefaultListableBeanFactory beanFactory 
		= new DefaultListableBeanFactory();
AnnotationConfigApplicationContext(1) -> param:this
	// -> this.reader = new AnnotatedBeanDefinitionReader(this)
	|-AnnotatedBeanDefinitionReader reader (2);
		|-BeanNameGenerator beanNameGenerator 
			= AnnotationBeanNameGenerator.INSTANCE
		|-ScopeMetadataResolver scopeMetadataResolver 
			= new AnnotationScopeMetadataResolver()
		|-ConditionEvaluator conditionEvaluator
			= new ConditionEvaluator(registry, environment, null)
			|- ConditionContextImpl context
				= new ConditionContextImpl(registry, environment, resourceLoader)
		|-BeanDefinitionRegistry registry
				= AnnotationConfigApplicationContext实例
		|->> AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry)
	// ->this.scanner = new ClassPathBeanDefinitionScanner(this)
	  ClassPathScanningCandidateComponentProvider(3)
	  	|- List<TypeFilter> includeFilters 
	  		= new ArrayList<>()
	  	|-  List<TypeFilter> excludeFilters 
	  		= new ArrayList<>();
	  	|-Environment environment
	  		 = AnnotationConfigApplicationContext实例下的Environment
	  	|-MetadataReaderFactory metadataReaderFactory
	  		= new CachingMetadataReaderFactory(AnnotationConfigApplicationContext实例)
	|-ClassPathBeanDefinitionScanner scanner
		|-BeanDefinitionDefaults beanDefinitionDefaults 
			= new BeanDefinitionDefaults()
		|-BeanNameGenerator beanNameGenerator 
			= AnnotationBeanNameGenerator.INSTANCE
		|-ScopeMetadataResolver scopeMetadataResolver 
			= new AnnotationScopeMetadataResolver()
		|-BeanDefinitionRegistry registry = 
			= AnnotationConfigApplicationContext实例

（1）实例化AnnotatedBeanDefinitionReader

this.reader = new AnnotatedBeanDefinitionReader(this);

AnnotatedBeanDefinitionReader主要用于手动注册单个带有注解的类（如 @Component、@Service 等），将其解析为 BeanDefinition 并注册到 Spring 容器中。

在创建时会自动注册 Spring 内置的注解后置处理器 ， 例如 ConfigurationClassPostProcessor、AutowiredAnnotationBeanPostProcessor），这些处理器负责解析 @Autowired、@Conditional 等注解。

典型使用场景是在 AnnotationConfigApplicationContext 中通过 register(Class<?>...) 方法直接注册配置类或组件类

（1.1）StandardEnvironment实例被创建

（1）源码

public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry) {
	// （1）getOrCreateEnvironment方法中调用 AbstractApplicationContext#getEnvironment方法
	// 为ApplicationContext创建StandardEnvironment实例
	this(registry, getOrCreateEnvironment(registry));
}
// -->>
// 从容器中获取Environment ，获取不到则创建并返回新的Environment实例对象。
private static Environment getOrCreateEnvironment(BeanDefinitionRegistry registry) {
	Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
	if (registry instanceof EnvironmentCapable) {
		// AnnotationConfigApplicationContext是EnvironmentCapable的实现类
		return ((EnvironmentCapable) registry).getEnvironment();
	}
	return new StandardEnvironment();
}

// >> AbstractApplicationContext.java#getEnvironment
public ConfigurableEnvironment getEnvironment() {
	if (this.environment == null) {
		this.environment = createEnvironment();
	}
	return this.environment;
}
protected ConfigurableEnvironment createEnvironment() {
	return new StandardEnvironment();
}

父类构造方法中调用抽象方法customizePropertySources，通过System.getProperties()获取系统属性，System.getenv()获取环境变量

// StandardEnvironment .java
protected void customizePropertySources(MutablePropertySources propertySources) {
	propertySources.addLast(
			new PropertiesPropertySource(SYSTEM_PROPERTIES_PROPERTY_SOURCE_NAME, getSystemProperties()));
	propertySources.addLast(
			new SystemEnvironmentPropertySource(SYSTEM_ENVIRONMENT_PROPERTY_SOURCE_NAME, getSystemEnvironment()));
}

//AbstractEnvironment.java
public Map<String, Object> getSystemProperties() {
		try {
			return (Map) System.getProperties();
		}
		......
}
public Map<String, Object> getSystemEnvironment() {
		......
		try {
			return (Map) System.getenv();
		}
		....
}

（2）调用栈

customizePropertySources:97, StandardEnvironment 
<init>:140, AbstractEnvironment 
<init>:124, AbstractEnvironment 
<init>:68, StandardEnvironment 
createEnvironment:347, AbstractApplicationContext 
getEnvironment:336, AbstractApplicationContext 
getEnvironment:136, AbstractApplicationContext 
getOrCreateEnvironment:296, AnnotatedBeanDefinitionReader 
<init>:71, AnnotatedBeanDefinitionReader 
<init>:69, AnnotationConfigApplicationContext 
<init>:91, AnnotationConfigApplicationContext 

（1.2）硬编码注册一些内部Bean的BeanDefinition

AnnotationConfigUtils.registerAnnotationConfigProcessors 方法中硬编码向容器注册了2个bean实例对象、一些Bean的BeanDefinition。

public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment) {
	Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
	Assert.notNull(environment, "Environment must not be null");
	// 持有 AnnotationConfigApplicationContext 实例引用
	this.registry = registry;
	// conditionEvaluator 是包内可见的类，用来解析@Conditional注解 
	// Internal class used to evaluate Conditional annotations. 
	this.conditionEvaluator = new ConditionEvaluator(registry, environment, null);
	//（2）
	AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
	// -->>
}

在AnnotatedBeanDefinitionReader构造方方法中，借助AnnotationConfigUtils.registerAnnotationConfigProcessors 方法中硬编码向容器注册了2个bean实例对象、一些Bean的BeanDefinition。

// AnnotationConfigUtils.java
// 向容器注册一些SpringFramwork框架中类的BeanDefinition,供后续使用
public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
		BeanDefinitionRegistry registry, @Nullable Object source) {
	// 获取AnnotationConfigApplicationContext 持有的DefaultListableBeanFactory 实例
	DefaultListableBeanFactory beanFactory 
				= unwrapDefaultListableBeanFactory(registry);
	if (beanFactory != null) {
		if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
			beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
		}
		if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
			beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
		}
	}
	Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);
	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));
	}
	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));
	}
	// Check for JSR-250 support, and if present add the CommonAnnotationBeanPostProcessor.
	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));
	}
	// Check for JPA support, and if present add the PersistenceAnnotationBeanPostProcessor.
	if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) {
		RootBeanDefinition def = new RootBeanDefinition();
		try {
			def.setBeanClass(ClassUtils.forName(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME,
					AnnotationConfigUtils.class.getClassLoader()));
		}
		catch (ClassNotFoundException ex) {
			throw new IllegalStateException(
					"Cannot load optional framework class: " + PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, ex);
		}
		def.setSource(source);
		beanDefs.add(registerPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME));
	}

	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));
	}

	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,这是一个

• 1、getOrCreateEnvironment方法中调用 AbstractApplicationContext#getEnvironment方法为AnnotationConfigApplicationContext 创建StandardEnvironment实例

• 2、AnnotatedBeanDefinitionReader#registry 持有AnnotationConfigApplicationContext 实例引用

• 3、AnnotatedBeanDefinitionReader创建并持有ConditionEvaluator实例;

• 4、使用工具类AnnotationConfigUtils#registerAnnotationConfigProcessors方法向AnnotationConfigApplicationContext 注册各种是对象和各种BeanDefinition

（2）实例化ClassPathBeanDefinitionScanner

public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters,
		Environment environment, ResourceLoader resourceLoader) {

	Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
	this.registry = registry;
	// useDefaultFilters传递过来true
	if (useDefaultFilters) {
		// 
		registerDefaultFilters();
	}
	setEnvironment(environment);
	setResourceLoader(resourceLoader);
}

// >> ClassPathScanningCandidateComponentProvider.java
public void setResourceLoader(ResourceLoader resourceLoader) {
	this.resourcePatternResolver = ResourcePatternUtils.getResourcePatternResolver(resourceLoader);
	this.metadataReaderFactory = new CachingMetadataReaderFactory(resourceLoader);
}

（3）register(componentClasses)

（4）刷新容器refresh()

AbstractApplicationContext#refresh

public void refresh() throws BeansException, IllegalStateException {
	synchronized (this.startupShutdownMonitor) {
		StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");

		// Prepare this context for refreshing.
		//--------（1）
		// 主要进行一系列准备工作：设置启动时间、活跃状态，初始化属性源和事件集合 
		prepareRefresh();

		// Tell the subclass to refresh the internal bean factory.
		//--------（2）
		ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

		// Prepare the bean factory for use in this context.
		//--------（3）
		prepareBeanFactory(beanFactory);

		try {
			// Allows post-processing of the bean factory in context subclasses.
			//--------（4）
			postProcessBeanFactory(beanFactory);
			StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
			// Invoke factory processors registered as beans in the context.
			
			//--------（5）
			// 
			// >> 功能点1 - 注册各种BeanDefinition
			// 		使用ConfigurationClassPostProcessor注册各种BeanDefinition到容器中
			// 		1、ConfigurationClassPostProcessor的BeanDefinition在`AnnotationConfigApplicationContext`构造方法中调用
			// 		`AnnotatedBeanDefinitionReader`构造方法中被注册到容器
			// 		2、通过beanFactory.getBean方法创建ConfigurationClassPostProcessor实例，
			// 		并作为BeanDefinitionRegistryPostProcessor接口的实现类被调用，扫描并注册各种bean的BeanDefinition
			// 注意：
			// 	所有用户自定义的Bean都依赖ConfigurationClassPostProcessor实例的执行，向容器中注册对应的BeanDefinition
			// 
			
			// >> 功能点2：自定义的BeanDefinitionRegistryPostProcessor和 BeanFactoryPostProcessor实现类，
			// 	在此创建实例和执行,
			invokeBeanFactoryPostProcessors(beanFactory);
			
			// Register bean processors that intercept bean creation.
			//--------（6）
			// 1从容器中获取所有的BeanPostProcessor类型的bean名称；
			// 2通过getBean创建bean实例；
			// 3将创建的bean实例放入beanFactory中的List<BeanPostProcessor> beanPostProcessors；
			// 后续创建bean实例时，对实例进行初始化的前后调用BeanPostProcessor的2个接口方法：
			//	postProcessBeforeInitialization和postProcessAfterInitialization对bean进行增强
			
			// >> 功能点1 创建两个监听器的后置处理器(用于将过滤器过滤出来): 
			//			（1.1）BeanPostProcessor实现类ApplicationListenerDetector
			//				后续finishBeanFactoryInitialization-实例化bean时,过滤出ApplicationListener
			//				类型的bean放入容器applicationListeners属性里，供发布事件时调用
			// 	 		（1.2）SmartInitializingSingleton实现类EventListenerMethodProcessor
			// 				在容器实例化bean时，对每个bean中的方法进行甄别，筛选出标记@EventListener的方法
			// 				将方法包装成ApplicationListenerMethodAdapter实例并放入容器。
			registerBeanPostProcessors(beanFactory);
			
			// 空方法
			beanPostProcess.end();

			// Initialize message source for this context.
			//--------（7）
			// 初始化消息源：支持国际化消息解析 
			initMessageSource();

			// Initialize event multicaster for this context.
			//--------（8）
			// 初始化事件广播器：创建事件多播器（默认SimpleApplicationEventMulticaster） 
			initApplicationEventMulticaster();

			// Initialize other special beans in specific context subclasses.
			//--------（9）空方法
			// 子类扩展点：初始化特定Bean（如Web环境初始化DispatcherServlet） 
			onRefresh();

			// Check for listener beans and register them.
			//--------（）
			registerListeners();

			// Instantiate all remaining (non-lazy-init) singletons.
			//--------（）
			finishBeanFactoryInitialization(beanFactory);
			
			// Last step: publish corresponding event.
			//--------（）
			// 功能点1-发布一个事件ContextRefreshedEvent
			finishRefresh();
		}

		catch (BeansException ex) {
			if (logger.isWarnEnabled()) {
				logger.warn("Exception encountered during context initialization - " +
						"cancelling refresh attempt: " + ex);
			}
			// Destroy already created singletons to avoid dangling resources.
			//--------（）
			destroyBeans();
			// Reset 'active' flag.
			//--------（）
			cancelRefresh(ex);
			// Propagate exception to caller.
			throw ex;
		}

		finally {
			// Reset common introspection caches in Spring's core, since we
			// might not ever need metadata for singleton beans anymore...
			//--------（）
			resetCommonCaches();
			//--------（）
			contextRefresh.end();
		}
	}
}

附录B - ConfigurationClassPostProcessor

// ConfigurationClassPostProcessor#processConfigBeanDefinitions
public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
	List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
	String[] candidateNames = registry.getBeanDefinitionNames();

	// 1、从容器（registry）中筛选出配置类的BeanDefinition，并将其封装为BeanDefinitionHolder ，放入List中供手续程序使用
	for (String beanName : candidateNames) {
		BeanDefinition beanDef = registry.getBeanDefinition(beanName);
		if (beanDef.getAttribute(ConfigurationClassUtils.CONFIGURATION_CLASS_ATTRIBUTE) != null) {
			if (logger.isDebugEnabled()) {
				logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
			}
		}
		else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
			configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
		}
	}

	// Return immediately if no @Configuration classes were found
	if (configCandidates.isEmpty()) {
		return;
	}

	// Sort by previously determined @Order value, if applicable
	configCandidates.sort((bd1, bd2) -> {
		int i1 = ConfigurationClassUtils.getOrder(bd1.getBeanDefinition());
		int i2 = ConfigurationClassUtils.getOrder(bd2.getBeanDefinition());
		return Integer.compare(i1, i2);
	});

	// Detect any custom bean name generation strategy supplied through the enclosing application context
	SingletonBeanRegistry sbr = null;
	if (registry instanceof SingletonBeanRegistry) {
		sbr = (SingletonBeanRegistry) registry;
		if (!this.localBeanNameGeneratorSet) {
			BeanNameGenerator generator = (BeanNameGenerator) sbr.getSingleton(
					AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR);
			if (generator != null) {
				this.componentScanBeanNameGenerator = generator;
				this.importBeanNameGenerator = generator;
			}
		}
	}

	if (this.environment == null) {
		this.environment = new StandardEnvironment();
	}

	// Parse each @Configuration class
	// 2、创建ConfigurationClassParser 实例，用来解析配置类
	ConfigurationClassParser parser = new ConfigurationClassParser(
			this.metadataReaderFactory, this.problemReporter, this.environment,
			this.resourceLoader, this.componentScanBeanNameGenerator, registry);

	Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
	Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());
	do {
		StartupStep processConfig = this.applicationStartup.start("spring.context.config-classes.parse");
		parser.parse(candidates);
		parser.validate();

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

		// Read the model and create bean definitions based on its content
		if (this.reader == null) {
			this.reader = new ConfigurationClassBeanDefinitionReader(
					registry, this.sourceExtractor, this.resourceLoader, this.environment,
					this.importBeanNameGenerator, parser.getImportRegistry());
		}
		this.reader.loadBeanDefinitions(configClasses);
		alreadyParsed.addAll(configClasses);
		processConfig.tag("classCount", () -> String.valueOf(configClasses.size())).end();

		candidates.clear();
		if (registry.getBeanDefinitionCount() > candidateNames.length) {
			String[] newCandidateNames = registry.getBeanDefinitionNames();
			Set<String> oldCandidateNames = new HashSet<>(Arrays.asList(candidateNames));
			Set<String> alreadyParsedClasses = new HashSet<>();
			for (ConfigurationClass configurationClass : alreadyParsed) {
				alreadyParsedClasses.add(configurationClass.getMetadata().getClassName());
			}
			for (String candidateName : newCandidateNames) {
				if (!oldCandidateNames.contains(candidateName)) {
					BeanDefinition bd = registry.getBeanDefinition(candidateName);
					if (ConfigurationClassUtils.checkConfigurationClassCandidate(bd, this.metadataReaderFactory) &&
							!alreadyParsedClasses.contains(bd.getBeanClassName())) {
						candidates.add(new BeanDefinitionHolder(bd, candidateName));
					}
				}
			}
			candidateNames = newCandidateNames;
		}
	}
	while (!candidates.isEmpty());

	// Register the ImportRegistry as a bean in order to support ImportAware @Configuration classes
	if (sbr != null && !sbr.containsSingleton(IMPORT_REGISTRY_BEAN_NAME)) {
		sbr.registerSingleton(IMPORT_REGISTRY_BEAN_NAME, parser.getImportRegistry());
	}

	if (this.metadataReaderFactory instanceof CachingMetadataReaderFactory) {
		// Clear cache in externally provided MetadataReaderFactory; this is a no-op
		// for a shared cache since it'll be cleared by the ApplicationContext.
		((CachingMetadataReaderFactory) this.metadataReaderFactory).clearCache();
	}
}

配置类解析器 ConfigurationClassParser

解析配置类中一下注解：

@PropertySource

@ComponentScan

@Import

@ImportResource

@Bean方法

protected final SourceClass doProcessConfigurationClass(
        ConfigurationClass configClass, SourceClass sourceClass, Predicate<String> filter)
        throws IOException {
	// 1. 处理嵌套类
    // 如果当前配置类内部还有其他的类（例如：@Configuration public class Outer { @Configuration static class Inner {} }）
    // 那么我们需要先递归处理这些内部类，因为它们可能也包含配置信息。
    if (configClass.getMetadata().isAnnotated(Component.class.getName())) {
        processMemberClasses(configClass, sourceClass, filter);
    }
	// 2. 处理 @PropertySource
    // 遍历所有的 @PropertySource 注解
    for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable(
            sourceClass.getMetadata(), PropertySources.class,
            org.springframework.context.annotation.PropertySource.class)) {
        if (this.environment instanceof ConfigurableEnvironment) {
            // 将配置文件加载到 Environment 中，这样其他地方就可以通过 @Value 获取值了
            processPropertySource(propertySource);
        } else {
            logger.info("Ignoring @PropertySource annotation on [" + sourceClass.getMetadata().getClassName() +
                    "]. Reason: Environment must implement ConfigurableEnvironment");
        }
    }
	// 3. 处理 @ComponentScan
    // 这一步非常重要。如果配置类上有 @ComponentScan，Spring 会立即执行扫描。
    Set<AnnotationAttributes> componentScans = AnnotationConfigUtils.attributesForRepeatable(
            sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
    if (!componentScans.isEmpty() &&
            !this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
		// 解析扫描属性，获取需要扫描的包路径
        for (AnnotationAttributes componentScan : componentScans) {
            // 执行扫描，返回找到的所有 BeanDefinitionHolder
            Set<BeanDefinitionHolder> scannedBeanDefinitions =
                    this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
			// 检查扫描结果，看是否发现了新的配置类
            for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
                BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
                if (bdCand == null) {
                    bdCand = holder.getBeanDefinition();
                }
				// 判断这个扫描出来的 BeanDefinition 是否是一个配置类
                if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
                    // 如果是配置类，就递归调用 parse 方法进行处理
                    parse(bdCand.getBeanClassName(), holder.getBeanName());
                }
            }
        }
    }
    
	// 4. 处理 @Import
    // 处理 @Import 注解，它可以引入其他配置类、ImportSelector 或 ImportBeanDefinitionRegistrar
    processImports(configClass, sourceClass, getImports(sourceClass), filter, true);
    
	// 5. 处理 @ImportResource
    // 处理 @ImportResource，用于导入传统的 XML 配置文件
    AnnotationAttributes importResource =
            AnnotationConfigUtils.attributesFor(sourceClass.getMetadata(), ImportResource.class);
    if (importResource != null) {
        String[] resources = importResource.getStringArray("locations");
        Class<? extends BeanDefinitionReader> readerClass = importResource.getClass("reader");
        for (String resource : resources) {
            // 解析占位符（如 ${...}）
            String resolvedResource = this.environment.resolveRequiredPlaceholders(resource);
            // 将 XML 资源添加到配置类中
            configClass.addImportedResource(resolvedResource, readerClass);
        }
    }
	// 6. 处理 @Bean 方法
    // 收集类中所有被 @Bean 注解标记的方法元数据
    Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
    for (MethodMetadata methodMetadata : beanMethods) {
        configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
    }
	// 7. 处理接口方法 (默认方法)
    // 如果当前配置类是一个接口，或者实现了某个接口，处理其中的默认方法
    processInterfaces(configClass, sourceClass);
	// 8. 处理父类
    // 如果当前类有父类，且不是 java.lang.Object，就去处理父类
    if (sourceClass.getMetadata().hasSuperClass()) {
        String superclass = sourceClass.getMetadata().getSuperClassName();
        if (superclass != null && !superclass.startsWith("java") &&
                !this.knownSuperclasses.containsKey(superclass)) {
            this.knownSuperclasses.put(superclass, configClass);
            // 返回父类的 SourceClass，以便递归处理
            return sourceClass.getSuperClass();
        }
    }
	// 没有父类，处理结束
    return null;
}

ConfigurationClassBeanDefinitionReader