Spring Configuration注解

最新推荐文章于 2024-07-10 08:00:00 发布
最新推荐文章于 2024-07-10 08:00:00 发布
阅读量1.5k 收藏 3
点赞数
分类专栏： 【Spring Boot】 【Spring】
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sweatOtt/article/details/83154808
版权

Spring @Configuration标识的class，能够作为Spring的配置类，用来构建Bean，引入资源文件等等功能。所以有必要理解一下它是如何工作的。

注册 ConfigurationClassPostProcessor Bean

此注解的核心处理逻辑在ConfigurationClassPostProcessor类中，此类实现了BeanDefinitionRegistryPostProcessor接口，所以此类也必须被注册成Bean。ConfigurationClassPostProcessor注册的逻辑在AnnotationConfigUtils.registerAnnotationConfigProcessors()方法内

...
public static final String CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME =
		"org.springframework.context.annotation.internalConfigurationAnnotationProcessor";
...
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));
}
...

上面的注册ConfigurationClassPostProcessor会在AnnotatedBeanDefinitionReader构造时调用。

public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment) {
	...
	AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
}

AnnotatedBeanDefinitionReader类是用来处理注解方式注册bean的处理器。此类会在AnnotationConfigEmbeddedWebApplicationContext或者AnnotationConfigApplicationContext构造时构建。对于前2者context，SpringBoot会在启动时，会根据类路径下是否有web相关的类，决定启用哪个context。

到这里为止，ConfigurationClassPostProcessor注册为bean的流程已经显而易见了。

ConfigurationClassPostProcessor 处理 @Configuration 注解

由于ConfigurationClassPostProcessor继承了BeanDefinitionRegistryPostProcessor接口，直接看它实现的postProcessBeanDefinitionRegistry方法，发现它的核心处理逻辑在processConfigBeanDefinitions方法内。

我们将它的内部流程分为几块来看。

判断是否有 @Configuration 注解标注

String[] candidateNames = registry.getBeanDefinitionNames();

for (String beanName : candidateNames) {
	BeanDefinition beanDef = registry.getBeanDefinition(beanName);
	if (ConfigurationClassUtils.isFullConfigurationClass(beanDef) ||
			ConfigurationClassUtils.isLiteConfigurationClass(beanDef)) {
		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;
}

上面这段代码里，首先isFullConfigurationClass和isLiteConfigurationClass方法判断此类是否已经经过处理，如果不是，调用ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)，判断此类是否标有@Configuration注解，如果有的话放入configCandidates;

checkConfigurationClassCandidate方法

public static boolean checkConfigurationClassCandidate(BeanDefinition beanDef, MetadataReaderFactory metadataReaderFactory) {
	String className = beanDef.getBeanClassName();
	if (className == null || beanDef.getFactoryMethodName() != null) {
		return false;
	}

	AnnotationMetadata metadata;
	...
	if (isFullConfigurationCandidate(metadata)) {
		beanDef.setAttribute(CONFIGURATION_CLASS_ATTRIBUTE, CONFIGURATION_CLASS_FULL);
	}
	else if (isLiteConfigurationCandidate(metadata)) {
		beanDef.setAttribute(CONFIGURATION_CLASS_ATTRIBUTE, CONFIGURATION_CLASS_LITE);
	}
	else {
		return false;
	}
	// It's a full or lite configuration candidate... Let's determine the order value, if any.
	Map<String, Object> orderAttributes = metadata.getAnnotationAttributes(Order.class.getName());
	if (orderAttributes != null) {
		beanDef.setAttribute(ORDER_ATTRIBUTE, orderAttributes.get(AnnotationUtils.VALUE));
	}
	return true;
}

public static boolean isFullConfigurationCandidate(AnnotationMetadata metadata) {
	return metadata.isAnnotated(Configuration.class.getName());
}

public static boolean isLiteConfigurationCandidate(AnnotationMetadata metadata) {
...
	// Any of the typical annotations found?
	for (String indicator : candidateIndicators) {
		if (metadata.isAnnotated(indicator)) {
			return true;
		}
	}
	// Finally, let's look for @Bean methods...
	try {
		return metadata.hasAnnotatedMethods(Bean.class.getName());
	}
	...
}
  1. isFullConfigurationCandidate判断是否标有Configuration注解;
  2. isLiteConfigurationCandidate判断是否有Component，ComponentScan，Import，ImportResource，Bean注解，但是没有Configuration注解。
  3. checkConfigurationClassCandidate方法内，会根据不同的配置类类型，对BeanDefinition设置不同的属性，full or lite

处理标有 Configuration 注解的类

ConfigurationClassPostProcessor类的processConfigBeanDefinitions方法里剩下的代码

Set<BeanDefinitionHolder> candidates = new LinkedHashSet<BeanDefinitionHolder>(configCandidates);
Set<ConfigurationClass> alreadyParsed = new HashSet<ConfigurationClass>(configCandidates.size());
do {
	parser.parse(candidates);
	parser.validate();

	Set<ConfigurationClass> configClasses = new LinkedHashSet<ConfigurationClass>(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);

	candidates.clear();
	if (registry.getBeanDefinitionCount() > candidateNames.length) {
		String[] newCandidateNames = registry.getBeanDefinitionNames();
		Set<String> oldCandidateNames = new HashSet<String>(Arrays.asList(candidateNames));
		Set<String> alreadyParsedClasses = new HashSet<String>();
		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());

此处可以看到parser调用了parse()方法，此方法内会解析配置类.内部比较核心的方法是doProcessConfigurationClass

protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass)
		throws IOException {
	...
	// Process any @PropertySource annotations
	// 处理 @PropertySources
	for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable(
			sourceClass.getMetadata(), PropertySources.class,
			org.springframework.context.annotation.PropertySource.class)) {
		if (this.environment instanceof ConfigurableEnvironment) {
			processPropertySource(propertySource);
		}
		else {
			logger.warn("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
			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) {
				if (ConfigurationClassUtils.checkConfigurationClassCandidate(
						holder.getBeanDefinition(), this.metadataReaderFactory)) {
					parse(holder.getBeanDefinition().getBeanClassName(), holder.getBeanName());
				}
			}
		}
	}

	// Process any @Import annotations
	processImports(configClass, sourceClass, getImports(sourceClass), true);

	// Process any @ImportResource annotations
	if (sourceClass.getMetadata().isAnnotated(ImportResource.class.getName())) {
		AnnotationAttributes importResource =
				AnnotationConfigUtils.attributesFor(sourceClass.getMetadata(), ImportResource.class);
		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
	Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
	for (MethodMetadata methodMetadata : beanMethods) {
		configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
	}
    ...
}

从上面的代码可以看到此方法内处理了各种常用的注解。具体就不在此文里深入，对于其它注解之后会在专门的文章里描述。

回到parser.parse调用之后的逻辑，Set<ConfigurationClass> configClasses = new LinkedHashSet<ConfigurationClass>(parser.getConfigurationClasses());调用parser.getConfigurationClasses()获取到配置类需要注册为bean的所有类。

if (this.reader == null) {
	this.reader = new ConfigurationClassBeanDefinitionReader(
			registry, this.sourceExtractor, this.resourceLoader, this.environment,
			this.importBeanNameGenerator, parser.getImportRegistry());
}
this.reader.loadBeanDefinitions(configClasses);

上面这段代码会将获取到的所有类，通过ConfigurationClassBeanDefinitionReader.loadBeanDefinitions方法，注册为bean;

public void loadBeanDefinitions(Set<ConfigurationClass> configurationModel) {
	TrackedConditionEvaluator trackedConditionEvaluator = new TrackedConditionEvaluator();
	for (ConfigurationClass configClass : configurationModel) {
		loadBeanDefinitionsForConfigurationClass(configClass, trackedConditionEvaluator);
	}
}

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

到这里为止，@Configuration配置类解析，注册相关的bean的流程已经比较清晰了。具体细节还是不再深入。

总结

@Configuration实现过程主要基于BeanDefinitionRegistryPostProcessor接口，解析注解、处理资源等，最后动态注册bean来实现。不得不说Spring内部的几个XxxPostProcessor对于扩展非常方便。

_laomei_
关注
专栏目录
SpringBoot插件之Develop Tools: DevTools, Lombok, Spring Configuration Proccessor
Wu_yongtao的博客
03-04 499
SpringBoot 插件之 Develop Tools Spring Boot DevTools Lombok Spring Configuration Proccessor 1. Spring Boot DevTools 1.1 功能简介 使 Spring Boot 应用支持热部署，提高开发者的开发效率，无需手动重启 Spring Boot 应用。 1.2 原理 深层原理是使用了两个 ClassLoader，一个 Classloader 加载那些不会改变的类（第三方Jar包）， 另一个
聊透spring @Configuration配置类
m0_71777195的博客
01-30 1983
本章节我们来探索Spring中一个常用的注解。。那啥是配置类啊，有啥用啊。这个我们得结合实际使用场景来说，通常情况下。加了的配置类内部，都会。为了简化定义，在后续我们称@Bean注解的方法为工厂方法。配置类的奥秘就在这里，Spring会保证多次调用@Bean标注的工厂方法，，这也贯彻了Spring的单例哲学。多次调用创建方法，产生的竟然是同一个对象，这貌似违背了编程的基础原理。怎么可能😱，一定是Spring做了什么，那就跟随着贰师兄的脚步一起解开的神秘面纱吧。
Spring @Configuration注解及配置方法
08-19
主要介绍了Spring @Configuration注解及配置方法,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
spring的@Configuration注解
听海边涛声
01-29 940
spring的@Configuration注解
详细分析Spring中的@Configuration注解基本知识（附Demo）
最新发布
码农研究僧的博客
07-10 2521
在Java和Spring框架中，@Configuration注解用于定义配置类，这些类可以替代传统的XML配置文件 是Spring的一部分，用于创建和管理bean，提供了更灵活和强大的配置机制 配置类包含了一个或多个@Bean方法，这些方法返回要在Spring容器中管理的bean
Spring——@Configuration注解
zl13101758272的博客
07-12 363
文章目录@Configuration注解1. @Configuration注解什么作用？1.1 value值验证，与@Component一样的功能1.2 proxyBeanMethods值验证，是否生产CGLIB代理类1.2.1 proxyBeanMethods 值为true1.2.1 proxyBeanMethods 值为false @Configuration注解 1. @Configuration注解什么作用？ 被@Configuration注解修饰表示当前的类是一个配置类。看一下@Configura
Spring @Configuration注解
weixin_34082177的博客
08-27 94
1 该注解的用途 这个注解表示这个类可以作为spring ioc容器bean的来源，其本质上它是对xml文件中创建bean的一种替换。有了这个注释，Spring framework就能在需要的时候构造出bean出来，然后完成bean的注入。 2 一般使用方式 package com.tutorialspoint; import org.springframework.context.ann...
spring configuration注解
07-16
Spring Configuration注解是一种用于配置Spring应用程序的注解方式。它提供了一种简化配置的方式，可以通过注解来声明和管理Spring Bean，以及配置和解决Bean之间的依赖关系。 Spring提供了多个@Configuration注解...
configuration注解总结
12-07
做springboot项目期间总结了一下，可能不完善，但是对于初学者应该是有用的
【Spring6系列】1.深度解析@Configuration注解
qq_45721579的博客
02-22 6161
Configuration注解是从Spring 3.0版本开始加入的一个使Spring能够支持注解驱动开发的标注型注解，主要用于标注在类上。当某个类标注了@Configuration注解时，表示这个类是Spring的一个配置类。@Configuration注解能够替代Spring的文件，并且被@Configuration注解标注的类，能够自动注册到IOC容器并进行实例化。
Spring的@Configuration注解使用
OceanSky的专栏
12-30 6930
Spring的@Configuration注解用于定义配置类，可替换XML配置文件，被 注解的类内部包含有一个或者多个被@Bean注解的方法，这些方法将会被ApplicationContext上下文类进行扫描，并构建对应的bean,加入到Spring容器之中进行管理。 @Configuration注解类有如下限制： @Configuration类不可以是final类； @Configuratio...
Spring注解 --Configuration
fwk19840301的博客
07-10 958
//配置类==配置文件 @Configuration //告诉Spring这是一个配置类 @ComponentScans( value = { @ComponentScan(value="com.atguigu",includeFilters = { /* @Filter(type=FilterType.ANNOTATION,classes={Controller.cla...
Spring源码之@Configuration注解解析
HongYu012的博客
02-23 838
1.前言 ​ Spring注解开发中，我们只需求要类上加上@Configuration注解，然后在类中的方法上面加上@Bean注解即可完成Spring Bean组件的注册。相较于之前的xml配置文件定义注册组件简化了非常多。那么Spring底层是如何处理@Configuration注解来完成Spring组件的注册，下面通过源码一步一步进行分析。 2.准备工作 Spring版本：2.2.13.RELEASE 源码中涉及的类： ConfigurationClassPostProcessor Conf
spring之@Configuration注解
手写ArrayList
05-31 1112
@Configuration标注在类上，相当于把该类作为spring的xml配置文件中的，作用为：配置spring容器 package com.dalingjia.spring; import org.springframework.context.annotation.Configuration; @Configuration public class TestConfiguration {...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值