本文详细分析了Spring的ConfigurationClassPostProcessor，它是BeanDefinitionRegistryPostProcessor接口的实现，用于处理@Configuration注解的Bean。文章从postProcessBeanDefinitionRegistry方法开始，详细探讨了配置类的解析和Bean的加载过程，包括ConfigurationClassParser的parse方法，以及ConfigurationClassBeanDefinitionReader如何加载Bean定义。同时，还解析了@Configuration、@Import、@ComponentScan等注解的工作原理，揭示了SpringBoot自动装配的实现方式。
spring-系列
文章目录
前言
ConfigurationClassPostProcessor是BeanDefinitionRegistryPostProcessor接口的实现类。spring通过@Configuration注解加载Bean的具体实现，该类将全面解剖@Configuration注解的神秘面纱。在阅读本文之前读者需要知道什么是BeanDefinitionRegistryPostProcessor，如果还有疑问请移步。
ConfigurationClassPostProcessor
public class ConfigurationClassPostProcessor implements BeanDefinitionRegistryPostProcessor,
PriorityOrdered, ResourceLoaderAware, ApplicationStartupAware, BeanClassLoaderAware, EnvironmentAware {
}
该类是BeanDefinitionRegistryPostProcessor接口扩展的一个经典案例，实现了PriorityOrdered来优先加载@Configuration的Bean，核心入口是BeanDefinitionRegistryPostProcessor接口的postProcessBeanDefinitionRegistry方法，下面详细讨论。
postProcessBeanDefinitionRegistry
/**
* 加载外部定义的Bean，该方法是Configuration，Bean，Component，Service，Import等注解加载Bean的入口
* @param registry the bean definition registry used by the application context
*/
@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
/**
* 获取registry注册器hashcode的值
*/
int registryId = System.identityHashCode(registry);
/**
* 验证该注册器是否已注册该Bean，表示一个注册器只能注册一次ConfigurationClassPostProcessor
*/
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);
/**
* 执行外部Bean的注册逻辑
*/
processConfigBeanDefinitions(registry);
}
processConfigBeanDefinitions(registry)是真正处理Bean的方法。
processConfigBeanDefinitions
/**
* 处理Configuration的Bean加载逻辑
* @param registry
*/
public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
/**
* 存储所有被Configuration注解修饰的类
*/
List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
/**
* 获取当前所有bean名称
*/
String[] candidateNames = registry.getBeanDefinitionNames();
for (String beanName : candidateNames) {
BeanDefinition beanDef = registry.getBeanDefinition(beanName);
if (beanDef.getAttribute(ConfigurationClassUtils.CONFIGURATION_CLASS_ATTRIBUTE) != null) {
if (logger.isDebugEnabled()) {
logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
}
}
/**
* 检查当前是否是一个标准的Bean（检查当前类是否被 Configuration， Component，ComponentSpan，Import，ImportResource 注解修饰）
*/
else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
}
}
// Return immediately if no @Configuration classes were found
/**
* 如果未找到@Configuration类，则立即返回
*/
if (configCandidates.isEmpty()) {
return;
}
// Sort by previously determined @Order value, if applicable、
/**
* 对所有Configuration修饰的类进行排序
*/
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
/**
* 检测上下文提供的任何自定义bean名称生成策略,
*/
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;
}
}
}
/**
* 给environment赋初始值
*/
if (this.environment == null) {
this.environment = new StandardEnvironment();
}
// Parse each @Configuration class
/**
* 创建 @Configuration注解的解析类
*/
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");
/**
* 解析被@Configuration修饰的Bean
*/
parser.parse(candidates);
/**
* 验证被@Configuration 注解修饰的类不能被Final修饰
* 验证被@Bean 注解修饰的方法可以被重写
*/
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());
}
/**
* 通过配置类来加载Bean，这是真正加载Bean的入口
*/
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();
}
}
分析源码执行逻辑：
-
第一步：寻找所有被@Configuration的Bean（configCandidates），且排序。
-
第二步：加载Bean的准备工作，初始化BeanNameGenerator（Bean名称生成器）和Environment（环境变量对象）。
-
第三步：创建@Configuration注解的解析类ConfigurationClassParser。
-
第四步：遍历第一步 configCandidates通过ConfigurationClassParser的parse方法来解析每一个Configuration配置类。
-
第五步：创建@Configuration注解Bean加载器类ConfigurationClassBeanDefinitionReader。
-
第六步：通过ConfigurationClassBeanDefinitionReader的 loadBeanDefinitions(configClasses) 方法来加载Bean
ConfigurationClassParser
由以上代码知道真正解析@Configuration注解配置类是ConfigurationClassParser的parse(candidates)方法，这里只是将配置类解析为ConfigurationClass对象，并不是真正的加载Bean，下面详细讨论。
parse
public void parse(Set<BeanDefinitionHolder> configCandidates) {
for (BeanDefinitionHolder holder : configCandidates) {
BeanDefinition bd = holder.getBeanDefinition();
try {
if (bd instanceof AnnotatedBeanDefinition) {
/**
* 解析 AnnotatedBeanDefinition 类型的Bean
*/
parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());
}
else if (bd instanceof AbstractBeanDefinition && ((AbstractBeanDefinition) bd).hasBeanClass()) {
/**
* 解析 AbstractBeanDefinition 类型的Bean
*/
parse(((AbstractBeanDefinition) bd).getBeanClass(), holder.getBeanName());
}
else {
/**
* 解析其他类型的Bean
*/
parse(bd.getBeanClassName(), holder.getBeanName());
}
}
catch (BeanDefinitionStoreException ex) {
throw ex;
}
catch (Throwable ex) {
throw new BeanDefinitionStoreException(
"Failed to parse configuration class [" + bd.getBeanClassName() + "]", ex);
}
}
/**
* 解析DeferredImportSelector接口
*/
this.deferredImportSelectorHandler.process();
}
protected final void parse(@Nullable String className, String beanName) throws IOException {
Assert.notNull(className, "No bean class name for configuration class bean definition");
MetadataReader reader = this.metadataReaderFactory.getMetadataReader(className);
processConfigurationClass(new ConfigurationClass(reader, beanName), DEFAULT_EXCLUSION_FILTER);
}
protected final void parse(Class<?> clazz, String beanName) throws IOException {
processConfigurationClass(new ConfigurationClass(clazz, beanName), DEFAULT_EXCLUSION_FILTER);
}
protected final void parse(AnnotationMetadata metadata, String beanName) throws IOException {
processConfigurationClass(new ConfigurationClass(metadata, beanName), DEFAULT_EXCLUSION_FILTER);
}
将BeanDefinitionHolder解析为ConfigurationClass 对象，最后执行this.deferredImportSelectorHandler.process()来加载DeferredImportSelector定义的Bean，这个是SpringBoot实现自动加载Bean的原理。
processConfigurationClass
protected void processConfigurationClass(ConfigurationClass configClass, Predicate<String> filter) throws IOException {
/**
* 如果该Bean不需要加载，则直接跳过
*/
if (this.conditionEvaluator.shouldSkip(configClass.getMetadata(), ConfigurationPhase.PARSE_CONFIGURATION)) {
return;
}
ConfigurationClass existingClass = this.configurationClasses.get(configClass);
/**
* 验证配置类是否已被加载
*/
if (existingClass != null) {
if (configClass.isImported()) {
if (existingClass.isImported()) {
existingClass.mergeImportedBy(configClass);
}
/**
* 否则忽略新导入的配置类；现有的非导入类将覆盖它。
*/
return;
}
else {
// Explicit bean definition found, probably replacing an import.
// Let's remove the old one and go with the new one.
this.configurationClasses.remove(configClass);
this.knownSuperclasses.values().removeIf(configClass::equals);
}
}
// Recursively process the configuration class and its superclass hierarchy.
SourceClass sourceClass = asSourceClass(configClass, filter);
do {
/**
* 解析配置类
*/
sourceClass = doProcessConfigurationClass(configClass, sourceClass, filter);
}
while (sourceClass != null);
this.configurationClasses.put(configClass, configClass);
}
解析每一个有效的@Configuration的配置类，且添加到configurationClasses中。
doProcessConfigurationClass
@Nullable
protected final SourceClass doProcessConfigurationClass(
ConfigurationClass configClass, SourceClass sourceClass, Predicate<String> filter)
throws IOException {
/**
* 处理Component注解
*/
if (configClass.getMetadata().isAnnotated(Component.class.getName())) {
// Recursively process any member (nested) classes first
/**
* 首先递归处理成员（内部）类
*/
processMemberClasses(configClass, sourceClass, filter);
}
// Process any @PropertySource annotations
/**
* 处理PropertySource注解
*/
for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable(
sourceClass.getMetadata(), PropertySources.class,
org.springframework.context.annotation.PropertySource.class)) {
if (this.environment instanceof ConfigurableEnvironment) {
/**
* 加载资源文件到environment中
*/
processPropertySource(propertySource);
}
else {
logger.info("Ignoring @PropertySource annotation on [" + sourceClass.getMetadata().getClassName() +
"]. Reason: Environment must implement ConfigurableEnvironment");
}
}
// Process any @ComponentScan annotations
/**
* 处理ComponentScan注解
*/
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) {
// The config class is annotated with @ComponentScan -> perform the scan immediately
/**
* 解析ComponentScan注解加载的Bean
*/
Set<BeanDefinitionHolder> scannedBeanDefinitions =
this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
// Check the set of scanned definitions for any further config classes and parse recursively if needed
for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
if (bdCand == null) {
bdCand = holder.getBeanDefinition();
}
/**
* 检查当前Bean是否是配置类（被@Configuration修饰）
*/
if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
/**
* 如果是配置类，则解析配置类
*/
parse(bdCand.getBeanClassName(), holder.getBeanName());
}
}
}
}
// Process any @Import annotations
/**
* 处理@Import加载的Bean
*/
processImports(configClass, sourceClass, getImports(sourceClass), filter, true);
// Process any @ImportResource annotations
/**
* 处理@ImportResource加载的Bean
* 从外部导入Bean资源
*/
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);
configClass.addImportedResource(resolvedResource, readerClass);
}
}
// Process individual @Bean methods
/**
* 处理被@Bean注解修饰的方法
*/
Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
for (MethodMetadata methodMetadata : beanMethods) {
configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
}
// Process default methods on interfaces
/**
* 处理接口上被@Bean的默认方法
*/
processInterfaces(configClass, sourceClass);
// Process superclass, if any
/**
* 处理父类，如果父类存在
*/
if (sourceClass.getMetadata().hasSuperClass()) {
String superclass = sourceClass.getMetadata().getSuperClassName();
if (superclass != null && !superclass.startsWith("java") &&
!this.knownSuperclasses.containsKey(superclass)) {
this.knownSuperclasses.put(superclass, configClass);
// Superclass found, return its annotation metadata and recurse
return sourceClass.getSuperClass();
}
}
// No superclass -> processing is complete
return null;
}
doProcessConfigurationClass方法是不是大概看到@Configuration本质了，解析步骤如下：
-
第一步：判断当前的配置类是否是内部类配置类，如果是采用内部类递归解析。
-
第二步：通过processPropertySource(propertySource)方法解析 @PropertySources 和 @PropertySource 注解导入外部属性配置（如：@PropertySources({ @PropertySource(“test.properties”) })）
-
第三步：通过ComponentScanAnnotationParser的parse方法解析 @ComponentScans 和 @ComponentScan 注解解析满足@Configuration的配置类，通过执行parse(bdCand.getBeanClassName(), holder.getBeanName())递归解析为配置类。
-
第四步：通过processImports方法解析 @Import 注解导入Bean的配置类
-
第五步：解析 @ImportResource注解定义的外部Bean，添加到配置类中
-
第六步：解析 @Bean注解定义的Bean，添加到配置类中
ConfigurationClassBeanDefinitionReader
ConfigurationClassBeanDefinitionReader通过loadBeanDefinitions方法加载ConfigurationClassParser解析的配置类定义有效的Bean。loadBeanDefinitions(configClasses)是该对象的核心。
loadBeanDefinitions
public void loadBeanDefinitions(Set<ConfigurationClass> configurationModel) {
TrackedConditionEvaluator trackedConditionEvaluator = new TrackedConditionEvaluator();
for (ConfigurationClass configClass : configurationModel) {
/**
* 通过配置文件加载一个配置类
*/
loadBeanDefinitionsForConfigurationClass(configClass, trackedConditionEvaluator);
}
}
遍历加载所有配置类的Bean。
loadBeanDefinitionsForConfigurationClass
private void loadBeanDefinitionsForConfigurationClass(
ConfigurationClass configClass, TrackedConditionEvaluator trackedConditionEvaluator) {
if (trackedConditionEvaluator.shouldSkip(configClass)) {
String beanName = configClass.getBeanName();
if (StringUtils.hasLength(beanName) && this.registry.containsBeanDefinition(beanName)) {
this.registry.removeBeanDefinition(beanName);
}
this.importRegistry.removeImportingClass(configClass.getMetadata().getClassName());
return;
}
/**
* 配置是通过@Import注解创建的配置类Bean，
* 如：@Import(ImportBeanDefinitionRegistrarConfig.class)，ImportBeanDefinitionRegistrarConfig就是一个配置类
*/
if (configClass.isImported()) {
registerBeanDefinitionForImportedConfigurationClass(configClass);
}
/**
* 遍历加载方法定义的Bean
*/
for (BeanMethod beanMethod : configClass.getBeanMethods()) {
loadBeanDefinitionsForBeanMethod(beanMethod);
}
/**
* 加载@ImportedResource申明的Bean
*/
loadBeanDefinitionsFromImportedResources(configClass.getImportedResources());
/**
* 加载ImportBeanDefinitionRegistrar注册的Bean
*/
loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());
}
解析配置类Bean的逻辑：
-
第一步：验证当前配置类是否满足加载Bean的条件，不满足直接返回。
-
第二步：加载@Import定义的配置类Bean
-
第三步：加载被@Bean的定义的Bean
-
第四步：加载@ImportedResource配置的Bean
-
第五步：加载ImportBeanDefinitionRegistrar接口注册的Bean
registerBeanDefinitionForImportedConfigurationClass
private void registerBeanDefinitionForImportedConfigurationClass(ConfigurationClass configClass) {
AnnotationMetadata metadata = configClass.getMetadata();
/**
* 创建一个BeanDefinition对象
*/
AnnotatedGenericBeanDefinition configBeanDef = new AnnotatedGenericBeanDefinition(metadata);
/**
* 设置Bean的scope和Bean名称和默认参数
*/
ScopeMetadata scopeMetadata = scopeMetadataResolver.resolveScopeMetadata(configBeanDef);
configBeanDef.setScope(scopeMetadata.getScopeName());
String configBeanName = this.importBeanNameGenerator.generateBeanName(configBeanDef, this.registry);
/**
* 设置Bean的默认参数
*/
AnnotationConfigUtils.processCommonDefinitionAnnotations(configBeanDef, metadata);
BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(configBeanDef, configBeanName);
definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
/**
* 注册Bean
*/
this.registry.registerBeanDefinition(definitionHolder.getBeanName(), definitionHolder.getBeanDefinition());
configClass.setBeanName(configBeanName);
if (logger.isTraceEnabled()) {
logger.trace("Registered bean definition for imported class '" + configBeanName + "'");
}
}
loadBeanDefinitionsForBeanMethod
private void loadBeanDefinitionsForBeanMethod(BeanMethod beanMethod) {
ConfigurationClass configClass = beanMethod.getConfigurationClass();
MethodMetadata metadata = beanMethod.getMetadata();
String methodName = metadata.getMethodName();
/**
* 验证当前Bean是否满足创建条件，不满足直接跳过
*/
if (this.conditionEvaluator.shouldSkip(metadata, ConfigurationPhase.REGISTER_BEAN)) {
configClass.skippedBeanMethods.add(methodName);
return;
}
if (configClass.skippedBeanMethods.contains(methodName)) {
return;
}
/**
* 获取@Bean的参数
*/
AnnotationAttributes bean = AnnotationConfigUtils.attributesFor(metadata, Bean.class);
Assert.state(bean != null, "No @Bean annotation attributes");
// Consider name and any aliases
List<String> names = new ArrayList<>(Arrays.asList(bean.getStringArray("name")));
/**
* 创建Bean名称
*/
String beanName = (!names.isEmpty() ? names.remove(0) : methodName);
// 别名注册
for (String alias : names) {
this.registry.registerAlias(beanName, alias);
}
// Has this effectively been overridden before (e.g. via XML)?
/**
* 验证该该方法是不是重写，导致Bean重复
*/
if (isOverriddenByExistingDefinition(beanMethod, beanName)) {
if (beanName.equals(beanMethod.getConfigurationClass().getBeanName())) {
throw new BeanDefinitionStoreException(beanMethod.getConfigurationClass().getResource().getDescription(),
beanName, "Bean name derived from @Bean method '" + beanMethod.getMetadata().getMethodName() +
"' clashes with bean name for containing configuration class; please make those names unique!");
}
return;
}
ConfigurationClassBeanDefinition beanDef = new ConfigurationClassBeanDefinition(configClass, metadata, beanName);
beanDef.setSource(this.sourceExtractor.extractSource(metadata, configClass.getResource()));
/**
* 验证方法是否是静态方法
*/
if (metadata.isStatic()) {
// static @Bean method
if (configClass.getMetadata() instanceof StandardAnnotationMetadata) {
beanDef.setBeanClass(((StandardAnnotationMetadata) configClass.getMetadata()).getIntrospectedClass());
}
else {
beanDef.setBeanClassName(configClass.getMetadata().getClassName());
}
beanDef.setUniqueFactoryMethodName(methodName);
}
else {
// instance @Bean method
/**
* 设置当前Bean的实例化工厂信息
*/
beanDef.setFactoryBeanName(configClass.getBeanName());
/**
* 设置工厂方法
*/
beanDef.setUniqueFactoryMethodName(methodName);
}
if (metadata instanceof StandardMethodMetadata) {
beanDef.setResolvedFactoryMethod(((StandardMethodMetadata) metadata).getIntrospectedMethod());
}
/*****************************根据@Bean注册参数来赋值给Bean*********************************/
beanDef.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_CONSTRUCTOR);
beanDef.setAttribute(org.springframework.beans.factory.annotation.RequiredAnnotationBeanPostProcessor.
SKIP_REQUIRED_CHECK_ATTRIBUTE, Boolean.TRUE);
AnnotationConfigUtils.processCommonDefinitionAnnotations(beanDef, metadata);
Autowire autowire = bean.getEnum("autowire");
if (autowire.isAutowire()) {
beanDef.setAutowireMode(autowire.value());
}
boolean autowireCandidate = bean.getBoolean("autowireCandidate");
if (!autowireCandidate) {
beanDef.setAutowireCandidate(false);
}
String initMethodName = bean.getString("initMethod");
if (StringUtils.hasText(initMethodName)) {
beanDef.setInitMethodName(initMethodName);
}
String destroyMethodName = bean.getString("destroyMethod");
beanDef.setDestroyMethodName(destroyMethodName);
// Consider scoping
ScopedProxyMode proxyMode = ScopedProxyMode.NO;
AnnotationAttributes attributes = AnnotationConfigUtils.attributesFor(metadata, Scope.class);
if (attributes != null) {
beanDef.setScope(attributes.getString("value"));
proxyMode = attributes.getEnum("proxyMode");
if (proxyMode == ScopedProxyMode.DEFAULT) {
proxyMode = ScopedProxyMode.NO;
}
}
// Replace the original bean definition with the target one, if necessary
BeanDefinition beanDefToRegister = beanDef;
/**
* 如果开启代码模式，将使用gclib创建代理对象，否则使用源配置类的方法作为工厂方法，默认是开启的
*/
if (proxyMode != ScopedProxyMode.NO) {
BeanDefinitionHolder proxyDef = ScopedProxyCreator.createScopedProxy(
new BeanDefinitionHolder(beanDef, beanName), this.registry,
proxyMode == ScopedProxyMode.TARGET_CLASS);
beanDefToRegister = new ConfigurationClassBeanDefinition(
(RootBeanDefinition) proxyDef.getBeanDefinition(), configClass, metadata, beanName);
}
if (logger.isTraceEnabled()) {
logger.trace(String.format("Registering bean definition for @Bean method %s.%s()",
configClass.getMetadata().getClassName(), beanName));
}
/**
* 注册Bean
*/
this.registry.registerBeanDefinition(beanName, beanDefToRegister);
}
这个方式是对@Bean注解的解析，可以看到Bean的参数来源@Bean注解，Bean实例化是通过工厂方法实现，proxyMode参数开启代理模式的实现。
loadBeanDefinitionsFromImportedResources
private void loadBeanDefinitionsFromImportedResources(
Map<String, Class<? extends BeanDefinitionReader>> importedResources) {
Map<Class<?>, BeanDefinitionReader> readerInstanceCache = new HashMap<>();
importedResources.forEach((resource, readerClass) -> {
// Default reader selection necessary?
/**
* 解析groovy定义的bean
*/
if (BeanDefinitionReader.class == readerClass) {
if (StringUtils.endsWithIgnoreCase(resource, ".groovy")) {
// When clearly asking for Groovy, that's what they'll get...
readerClass = GroovyBeanDefinitionReader.class;
}
/**
* 不支持XML定义的bean，抛出UnsupportedOperationException异常
*/
else if (shouldIgnoreXml) {
throw new UnsupportedOperationException("XML support disabled");
}
else {
/**
* 解析XML定义的bean
*/
// Primarily ".xml" files but for any other extension as well
readerClass = XmlBeanDefinitionReader.class;
}
}
BeanDefinitionReader reader = readerInstanceCache.get(readerClass);
if (reader == null) {
try {
/**
* 反射实例化BeanDefinitionReader对象
*/
reader = readerClass.getConstructor(BeanDefinitionRegistry.class).newInstance(this.registry);
// 赋初始值
if (reader instanceof AbstractBeanDefinitionReader) {
AbstractBeanDefinitionReader abdr = ((AbstractBeanDefinitionReader) reader);
abdr.setResourceLoader(this.resourceLoader);
abdr.setEnvironment(this.environment);
}
readerInstanceCache.put(readerClass, reader);
}
catch (Throwable ex) {
throw new IllegalStateException(
"Could not instantiate BeanDefinitionReader class [" + readerClass.getName() + "]");
}
}
/**
* 使用BeanDefinitionReader加载Bean
*/
reader.loadBeanDefinitions(resource);
});
}
这里可以看出@ImportedResource加载外部Bean只支持groovy和xml两种类型，根据后缀名来判断。
loadBeanDefinitionsFromRegistrars
private void loadBeanDefinitionsFromRegistrars(Map<ImportBeanDefinitionRegistrar, AnnotationMetadata> registrars) {
registrars.forEach((registrar, metadata) ->
registrar.registerBeanDefinitions(metadata, this.registry, this.importBeanNameGenerator));
}
这个方法就很简单了通过回调的方式执行ImportBeanDefinitionRegistrar接口的registerBeanDefinitions方法完成Bean的注册。
总结
根据源码我们知道@Configuration是通过BeanDefinitionRegistryPostProcessor接口实现，然后通过ConfigurationClassParser解析所有配置文件，最后通过ConfigurationClassBeanDefinitionReader将配置文件中的Bean加载到BeanFactory完成Bean的加载。加载Bean配置类的方式可以有@Configuration，@Import，@ImportedResource，@ImportedResources, @ComponentScans，@ComponentScan等多种方式，实际应用中科根据自己的需求选择。比如大名鼎鼎的SpringBoot是通过@Configuration、@Import和DeferredImportSelector接口来实现自动装配。
扫一扫
1409
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
