spring源码分析-ConfigurationClassPostProcessor

spring-系列

文章目录

spring-系列
前言
ConfigurationClassPostProcessor
- postProcessBeanDefinitionRegistry
- - processConfigBeanDefinitions
ConfigurationClassParser
- parse
- processConfigurationClass
- doProcessConfigurationClass
ConfigurationClassBeanDefinitionReader
- loadBeanDefinitions
- loadBeanDefinitionsForConfigurationClass
- registerBeanDefinitionForimportedConfigurationClass
- loadBeanDefinitionsForBeanMethod
- loadBeanDefinitionsFromimportedResources
- loadBeanDefinitionsFromRegistrars
总结

前言

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

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

processConfigBeanDefinitions(registry)是真正处理Bean的方法。

processConfigBeanDefinitions

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

		for (String beanName : candidateNames) {
			BeanDefinition beanDef = registry.getBeanDefinition(beanName);
			if (beanDef.getAttribute(ConfigurationClassUtils.CONFIGURATION_CLASS_ATTRIBUTE) != null) {
				if (logger.isDebugEnabled()) {
					logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
				}
			}

			
			else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
				configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
			}
		}

		// 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
		
		ConfigurationClassParser parser = new ConfigurationClassParser(
				this.metadataReaderFactory, this.problemReporter, this.environment,
				this.resourceLoader, this.componentScanBeanNameGenerator, registry);

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

			
			parser.validate();

			
			Set 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 oldCandidateNames = new HashSet<>(Arrays.asList(candidateNames));
				Set 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 configCandidates) {
		for (BeanDefinitionHolder holder : configCandidates) {
			BeanDefinition bd = holder.getBeanDefinition();
			try {
				if (bd instanceof AnnotatedBeanDefinition) {
					
					parse(((AnnotatedBeanDefinition) bd).getmetadata(), holder.getBeanName());
				}
				else if (bd instanceof AbstractBeanDefinition && ((AbstractBeanDefinition) bd).hasBeanClass()) {
					
					parse(((AbstractBeanDefinition) bd).getBeanClass(), holder.getBeanName());
				}
				else {
					
					parse(bd.getBeanClassName(), holder.getBeanName());
				}
			}
			catch (BeanDefinitionStoreException ex) {
				throw ex;
			}
			catch (Throwable ex) {
				throw new BeanDefinitionStoreException(
						"Failed to parse configuration class [" + bd.getBeanClassName() + "]", ex);
			}
		}

		
		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 filter) throws IOException {
		
		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 filter)
			throws IOException {

		
		if (configClass.getmetadata().isAnnotated(Component.class.getName())) {
			// Recursively process any member (nested) classes first
			
			processMemberClasses(configClass, sourceClass, filter);
		}

		// Process any @PropertySource annotations
		
		for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable(
				sourceClass.getmetadata(), PropertySources.class,
				org.springframework.context.annotation.PropertySource.class)) {
			if (this.environment instanceof ConfigurableEnvironment) {
				
				processPropertySource(propertySource);
			}
			else {
				logger.info("Ignoring @PropertySource annotation on [" + sourceClass.getmetadata().getClassName() +
						"]. Reason: Environment must implement ConfigurableEnvironment");
			}
		}

		// Process any @ComponentScan annotations
		
		Set 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
				
				Set 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();
					}
					
					if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
						
						parse(bdCand.getBeanClassName(), holder.getBeanName());
					}
				}
			}
		}

		// Process any @import annotations
		
		processimports(configClass, sourceClass, getimports(sourceClass), filter, true);

		// Process any @importResource annotations
		
		AnnotationAttributes importResource =
				AnnotationConfigUtils.attributesFor(sourceClass.getmetadata(), importResource.class);
		if (importResource != null) {
			String[] resources = importResource.getStringArray("locations");
			Class readerClass = importResource.getClass("reader");
			for (String resource : resources) {
				String resolvedResource = this.environment.resolveRequiredPlaceholders(resource);
				configClass.addimportedResource(resolvedResource, readerClass);
			}
		}

		// Process individual @Bean methods
		
		Set beanMethods = retrieveBeanMethodmetadata(sourceClass);
		for (Methodmetadata methodmetadata : beanMethods) {
			configClass.addBeanMethod(new BeanMethod(methodmetadata, configClass));
		}

		// Process default methods on interfaces
		
		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 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;
		}

		
		if (configClass.isimported()) {
			registerBeanDefinitionForimportedConfigurationClass(configClass);
		}

		
		for (BeanMethod beanMethod : configClass.getBeanMethods()) {
			loadBeanDefinitionsForBeanMethod(beanMethod);
		}

		
		loadBeanDefinitionsFromimportedResources(configClass.getimportedResources());

		
		loadBeanDefinitionsFromRegistrars(configClass.getimportBeanDefinitionRegistrars());
	}

解析配置类Bean的逻辑：

第一步：验证当前配置类是否满足加载Bean的条件，不满足直接返回。
第二步：加载@import定义的配置类Bean
第三步：加载被@Bean的定义的Bean
第四步：加载@importedResource配置的Bean
第五步：加载importBeanDefinitionRegistrar接口注册的Bean

registerBeanDefinitionForimportedConfigurationClass

	private void registerBeanDefinitionForimportedConfigurationClass(ConfigurationClass configClass) {
		Annotationmetadata metadata = configClass.getmetadata();
		
		AnnotatedGenericBeanDefinition configBeanDef = new AnnotatedGenericBeanDefinition(metadata);

		
		Scopemetadata scopemetadata = scopemetadataResolver.resolveScopemetadata(configBeanDef);
		configBeanDef.setScope(scopemetadata.getScopeName());
		String configBeanName = this.importBeanNameGenerator.generateBeanName(configBeanDef, this.registry);
		
		AnnotationConfigUtils.processCommonDefinitionAnnotations(configBeanDef, metadata);

		BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(configBeanDef, configBeanName);
		definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopemetadata, definitionHolder, this.registry);
		
		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();


		
		if (this.conditionevaluator.shouldSkip(metadata, ConfigurationPhase.REGISTER_BEAN)) {
			configClass.skippedBeanMethods.add(methodName);
			return;
		}
		if (configClass.skippedBeanMethods.contains(methodName)) {
			return;
		}

		
		AnnotationAttributes bean = AnnotationConfigUtils.attributesFor(metadata, Bean.class);
		Assert.state(bean != null, "No @Bean annotation attributes");

		// Consider name and any aliases
		List names = new ArrayList<>(Arrays.asList(bean.getStringArray("name")));
		
		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)?
		
		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
			
			beanDef.setFactoryBeanName(configClass.getBeanName());
			
			beanDef.setUniqueFactoryMethodName(methodName);
		}

		if (metadata instanceof StandardMethodmetadata) {
			beanDef.setResolvedFactoryMethod(((StandardMethodmetadata) metadata).getIntrospectedMethod());
		}

		

		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;

		
		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));
		}
		
		this.registry.registerBeanDefinition(beanName, beanDefToRegister);
	}

这个方式是对@Bean注解的解析，可以看到Bean的参数来源@Bean注解，Bean实例化是通过工厂方法实现，proxyMode参数开启代理模式的实现。

loadBeanDefinitionsFromimportedResources

	private void loadBeanDefinitionsFromimportedResources(
			Map> importedResources) {

		Map, BeanDefinitionReader> readerInstanceCache = new HashMap<>();

		importedResources.forEach((resource, readerClass) -> {
			// Default reader selection necessary?
			
			if (BeanDefinitionReader.class == readerClass) {
				if (StringUtils.endsWithIgnoreCase(resource, ".groovy")) {
					// When clearly asking for Groovy, that's what they'll get...
					readerClass = GroovyBeanDefinitionReader.class;
				}
				
				else if (shouldIgnoreXml) {
					throw new UnsupportedOperationException("XML support disabled");
				}
				else {
					
					// Primarily ".xml" files but for any other extension as well
					readerClass = XmlBeanDefinitionReader.class;
				}
			}

			BeanDefinitionReader reader = readerInstanceCache.get(readerClass);
			if (reader == null) {
				try {
					
					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() + "]");
				}
			}
			
			
			reader.loadBeanDefinitions(resource);
		});
	}

这里可以看出@importedResource加载外部Bean只支持groovy和xml两种类型，根据后缀名来判断。

loadBeanDefinitionsFromRegistrars

	private void loadBeanDefinitionsFromRegistrars(Map 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接口来实现自动装配。

spring源码分析-ConfigurationClassPostProcessor

Java相关栏目本月热门文章