@Configuration注解类的处理逻辑 - ConfigurationClassPostProcessor

最新推荐文章于 2024-05-19 00:04:05 发布
最新推荐文章于 2024-05-19 00:04:05 发布
阅读量472 收藏 2
点赞数 1
分类专栏： Spring 文章标签： ConfigurationClassPostProcessor 初始化Bean Definition 预置BeanDefinitionRegistryPostProcess ComponentScan的处理逻辑 Import的处理逻辑
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ttyy1112/article/details/91991344
版权

@Configuration注解类的处理逻辑 - ConfigurationClassPostProcessor

代码基于Spring Boot 2.1.5.RELEASE。

1. 在ConfigurationClassPostProcessor之前

在ConfigurationClassPostProcessor执行之前在bean factory中已经注册了一些bean definition，这些bean定义包括初始化bean和通过预置factory post processor注入的一些bean。我们先来看一下这些bean定义。

1.1 初始化Bean Definition

有些bean定义是在创建ApplicationContext的时候就创建好的。
在这里插入图片描述

在下述代码中包含初始化bean定义：

org.springframework.context.annotation.AnnotationConfigUtils#registerAnnotationConfigProcessors(org.springframework.beans.factory.support.BeanDefinitionRegistry, java.lang.Object)

/**
 * Register all relevant annotation post processors in the given registry.
 * @param registry the registry to operate on
 * @param source the configuration source element (already extracted)
 * that this registration was triggered from. May be {@code null}.
 * @return a Set of BeanDefinitionHolders, containing all bean definitions
 * that have actually been registered by this call
 */
public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
		BeanDefinitionRegistry registry, @Nullable Object source) {

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

执行示例：
在这里插入图片描述

1.2 预置BeanDefinitionRegistryPostProcessor注册的bean

在ConfigurationClassPostProcessor执行前会有一些预置BeanDefinitionRegistryPostProcessor，预置processor的优先级高于bean factory中bean的优先级，所以这些processor会优先执行。其中对bean definition产生影响的只有一个，那就是：SharedMetadataReaderFactoryContextInitializer.CachingMetadataReaderFactoryPostProcessor

在这里插入图片描述

2. ConfigurationClassPostProcessor

@Configuration注解类处理器，基本上所有的bean definition都是通过这个类进行加载的。它会递归寻找所有的配置类并完成bean definition的加载工作。

2.1 递归处理

org.springframework.context.annotation.ConfigurationClassParser#processConfigurationClass

递归加载所有的类。

protected void processConfigurationClass(ConfigurationClass configClass) 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);
			}
			// Otherwise ignore new imported config class; existing non-imported class overrides it.
			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);
	do {
		sourceClass = doProcessConfigurationClass(configClass, sourceClass);
	}
	while (sourceClass != null);

	this.configurationClasses.put(configClass, configClass);
}

2.2 各注解加载顺序

org.springframework.context.annotation.ConfigurationClassParser#doProcessConfigurationClass

加载顺序：

  1. 如果是Component组件，处理类成员
  2. 处理@PropertySource注解
  3. 处理@ComponentScan注解
  4. 处理@Import注解
  5. 处理@ImportResource注解
  6. 处理@Bean方法
  7. 处理接口的默认方法
  8. 处理父类（如果有的话）
/**
 * Apply processing and build a complete {@link ConfigurationClass} by reading the
 * annotations, members and methods from the source class. This method can be called
 * multiple times as relevant sources are discovered.
 * @param configClass the configuration class being build
 * @param sourceClass a source class
 * @return the superclass, or {@code null} if none found or previously processed
 */
@Nullable
protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass)
		throws IOException {

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

	// 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<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) {
				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), true);

	// Process any @ImportResource annotations
	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
	Set<MethodMetadata> 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;
}

2.3 ComponentScan的处理逻辑

org.springframework.context.annotation.ComponentScanAnnotationParser#parse

public Set<BeanDefinitionHolder> parse(AnnotationAttributes componentScan, final String declaringClass) {
	ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(this.registry,
			componentScan.getBoolean("useDefaultFilters"), this.environment, this.resourceLoader);

	Class<? extends BeanNameGenerator> generatorClass = componentScan.getClass("nameGenerator");
	boolean useInheritedGenerator = (BeanNameGenerator.class == generatorClass);
	scanner.setBeanNameGenerator(useInheritedGenerator ? this.beanNameGenerator :
			BeanUtils.instantiateClass(generatorClass));

	ScopedProxyMode scopedProxyMode = componentScan.getEnum("scopedProxy");
	if (scopedProxyMode != ScopedProxyMode.DEFAULT) {
		scanner.setScopedProxyMode(scopedProxyMode);
	}
	else {
		Class<? extends ScopeMetadataResolver> resolverClass = componentScan.getClass("scopeResolver");
		scanner.setScopeMetadataResolver(BeanUtils.instantiateClass(resolverClass));
	}

	scanner.setResourcePattern(componentScan.getString("resourcePattern"));

	for (AnnotationAttributes filter : componentScan.getAnnotationArray("includeFilters")) {
		for (TypeFilter typeFilter : typeFiltersFor(filter)) {
			scanner.addIncludeFilter(typeFilter);
		}
	}
	for (AnnotationAttributes filter : componentScan.getAnnotationArray("excludeFilters")) {
		for (TypeFilter typeFilter : typeFiltersFor(filter)) {
			scanner.addExcludeFilter(typeFilter);
		}
	}

	boolean lazyInit = componentScan.getBoolean("lazyInit");
	if (lazyInit) {
		scanner.getBeanDefinitionDefaults().setLazyInit(true);
	}

	Set<String> basePackages = new LinkedHashSet<>();
	String[] basePackagesArray = componentScan.getStringArray("basePackages");
	for (String pkg : basePackagesArray) {
		String[] tokenized = StringUtils.tokenizeToStringArray(this.environment.resolvePlaceholders(pkg),
				ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
		Collections.addAll(basePackages, tokenized);
	}
	for (Class<?> clazz : componentScan.getClassArray("basePackageClasses")) {
		basePackages.add(ClassUtils.getPackageName(clazz));
	}
	if (basePackages.isEmpty()) {
		basePackages.add(ClassUtils.getPackageName(declaringClass));
	}

	scanner.addExcludeFilter(new AbstractTypeHierarchyTraversingFilter(false, false) {
		@Override
		protected boolean matchClassName(String className) {
			return declaringClass.equals(className);
		}
	});
	return scanner.doScan(StringUtils.toStringArray(basePackages));
}

2.4 Import的处理逻辑

org.springframework.context.annotation.ConfigurationClassParser#processImports

支持三种import注册方式

  1. 基于ImportSelector的注册方式：根据条件选择配置类
  2. 基于ImportBeanDefinitionRegistrar的注册方式：自定义规则的bean definition导入
  3. 基于@Configuration注解类的注册方式：基于配置类的方式
private void processImports(ConfigurationClass configClass, SourceClass currentSourceClass,
	Collection<SourceClass> importCandidates, boolean checkForCircularImports) {

	if (importCandidates.isEmpty()) {
		return;
	}

	if (checkForCircularImports && isChainedImportOnStack(configClass)) {
		this.problemReporter.error(new CircularImportProblem(configClass, this.importStack));
	}
	else {
		this.importStack.push(configClass);
		try {
			for (SourceClass candidate : importCandidates) {
				if (candidate.isAssignable(ImportSelector.class)) {
					// Candidate class is an ImportSelector -> delegate to it to determine imports
					Class<?> candidateClass = candidate.loadClass();
					ImportSelector selector = BeanUtils.instantiateClass(candidateClass, ImportSelector.class);
					ParserStrategyUtils.invokeAwareMethods(
							selector, this.environment, this.resourceLoader, this.registry);
					if (selector instanceof DeferredImportSelector) {
						this.deferredImportSelectorHandler.handle(configClass, (DeferredImportSelector) selector);
					}
					else {
						String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());
						Collection<SourceClass> importSourceClasses = asSourceClasses(importClassNames);
						processImports(configClass, currentSourceClass, importSourceClasses, false);
					}
				}
				else if (candidate.isAssignable(ImportBeanDefinitionRegistrar.class)) {
					// Candidate class is an ImportBeanDefinitionRegistrar ->
					// delegate to it to register additional bean definitions
					Class<?> candidateClass = candidate.loadClass();
					ImportBeanDefinitionRegistrar registrar =
							BeanUtils.instantiateClass(candidateClass, ImportBeanDefinitionRegistrar.class);
					ParserStrategyUtils.invokeAwareMethods(
							registrar, this.environment, this.resourceLoader, this.registry);
					configClass.addImportBeanDefinitionRegistrar(registrar, currentSourceClass.getMetadata());
				}
				else {
					// Candidate class not an ImportSelector or ImportBeanDefinitionRegistrar ->
					// process it as an @Configuration class
					this.importStack.registerImport(
							currentSourceClass.getMetadata(), candidate.getMetadata().getClassName());
					processConfigurationClass(candidate.asConfigClass(configClass));
				}
			}
		}
		catch (BeanDefinitionStoreException ex) {
			throw ex;
		}
		catch (Throwable ex) {
			throw new BeanDefinitionStoreException(
					"Failed to process import candidates for configuration class [" +
					configClass.getMetadata().getClassName() + "]", ex);
		}
		finally {
			this.importStack.pop();
		}
	}
}

3. 自定义BeanDefinitionRegistryPostProcessor注册的bean

步骤：创建BeanDefinitionRegistryPostProcessor接口的实现类，向bean factory注册自己的bean，将实现类注册为bean。

个人建议通过import方式注册bean

阿湯哥
关注
专栏目录
【Spring源码】9. 超级重要的ConfigurationClassPostProcessor
aqin1012的博客
07-29 635
上一篇我们捋了捋invokeBeanFactoryPostProcessors()的整体逻辑，由于ConfigurationClassPostProcessor实现了BeanDefinitionRegistryPostProcessor所以他会在invokeBeanFactoryPostProcessors()方法中被处理，我们debug到invokeBeanFactoryPostProcessors()方法中.........
一文学会Spring的@Configuration配置类解析
xxxzzzqqq_的博客
03-20 170
本篇文章将详细分析Spring中如何加载并解析由@注解修饰的配置类。注解是Spring中特别重要且知名的注解，大家都知道怎么使用（如果还不知道，那你一定是没看超详细总结Spring的配置注解），作用就是可以向容器注册bean，并且就像“每一个成功的男人背后都有一个优秀的女人在支持”，@注解的背后也有一个功能强大的类在支撑，那就是，所以本文的重点就是如何解析由@注解修饰的配置类。本文的一个思维导图如下所示。最后，请务必知道Spring的是什么，不能只知道Spring有bean但不知道bean的前生。
spring boot 加载过程分析--ConfigurationClassPostProcessor
weixin_33849215的博客
07-24 435
ConfigurationClassPostProcessor 前面说到ConfigurationClassPostProcessor是BeanDefinitionRegistryPostProcessor接口的实现，在调用invokeBeanFactoryPostProcessors时，会先被调用；而且通过之前的分析我们可以知道，它是在容器初始化置AnnotatedBeanDefinitionR...
configurationClassPostProcessor
linの编程之路
03-05 160
整体结构 按照该类中方法的调用顺序进行介绍 configurationClassPostProcessor实现了BeanDefinitionRegistryPostProcessor接口。在invokeBeanFactoryPostProcessor中第一个调用到 也就是我们第一个获取容器中beanDefinitionRegistryPostProcessor的bean名称时得到该类，并执行实现的postProcessBeanDefinitionRegistry方法 public void postP
ConfigurationClassPostProcessor
m0_37607945的博客
06-10 628
用于在容器启动过程中处理标注@Configuration类的BeanFactoryPostProcessor 。在xml配置文件中使用<context:annotation-config/>or <context:component-scan/>都会注入这个后置处理器。由于这个Bean非常重要，因为在标注@Configuration的类中包含了其他需要进行注册的Bean定义，所以在与其他的后置处理器一起使用时，必须在前面进行作用，因此通过实现了接口PriorityOrdered来保证
ConfigurationClassPostProcessor —— Spring中最！最！最！重要的后置处理器！没有之一！！！
z69183787的专栏
02-27 1495
0. 疑惑 在阅读本文之前，可以先思考一下以下几个问题。 (1) @Configuration注解的作用是什么，Spring是如何解析加了@Configuration注解的类？ (2) Spring在什么时候对@ComponentScan、@ComponentScans注解进行了解析？ (3) Spring什么时候解析了@Import注解，如何解析的？ (4) Spring什么...
2w字长文给你讲透了配置类为什么要添加 @Configuration注解，是时候应该安排一下了！
weixin_46898270的博客
05-28 1318
Spring 用的爽不爽？在你爽的同时，你也知道为什么这么爽，在 Spring 中，@Configuration 是一个重重重要的注解，那么配置类为什么要添加 @Configuration 注解呢？本篇文章就带你 get 这个点。 不加 @Configuration 导致的问题 我们先来看看如果不在配置类上添加 @Configuration 注解会有什么问题，代码示例如下： 不添加 @Configuration 注解运行结果: create dmzService create A by dmzServi
【Spring】简述@Configuration配置类注册BeanDefinition到Spring容器的过程
HuaZi_Myth的博客
11-26 369
概述 本文以SpringBoot应用为基础，尝试分析基于注解@Configuration的配置类是如何向Spring容器注册BeanDefinition的过程 其中主要分析了 ConfigurationClassPostProcessor 这个BeanDefinitionRegistryPostProcessor 即Bean定义注册后置处理器，在Spring启动过程中对@Configurati...
Spring源码解析 – @Configuration配置类及注解Bean的解析
weixin_43493131的博客
10-23 344
在分析Spring 容器创建过程时，我们知道容器默认会加载一些后置处理器PostPRocessor，以AnnotationConfigApplicationContext为例，在构造函数中初始化reader时，加载默认后置处理器。其中 ConfigurationClassPostProcessor这个后置处理器专门处理带有@Configuration注解的类，ConfigurationClassP...
Spring5源码分析(3)----后置处理器ConfigurationClassPostProcessor
南猫信巷
09-21 87
ConfigurationClassPostProcessor
spring 源码系列（五）- 最重要的后置处理器ConfigurationClassPostProcessor
bintoYu的博客
02-14 737
1 介绍 ConfigurationClassPostProcessor用于对@Configuration类进行解析。 实际上不止@Configuration，该处理器会对容器中含有以下注释的bean进行处理： @Configuration @Component：注意，@Service、@Controller等一些注释本身其实也是@Component @ComponentScan @Import...
Spring核心后置处理器ConfigurationClassPostProcessor
思考的力量
10-21 428
ConfigurationClassPostProcessorConfigurationClassPostProcessor类层次postProcessBeanDefinitionRegistry方法（核心）processConfigBeanDefinitions方法解析的核心方法doProcessConfigurationClassloadBeanDefinitions方法加载BeanDefinitionregisterBeanDefinitionForImportedConfigurationClass
聊聊Spring中的ConfigurationClassPostProcessor
TankyZhang的博客
02-23 2628
 之前有讲到过在Spring中有各种各样的BeanFantoryPostProcessor后置处理器，在这些后置处理器中有一个对于Spring使用java Config起着至关重要的后置处理器，他就是ConfigurationClassPostProcessor，因为通过他的一个方法postProcessBeanDefinitionRegistry会进行类的扫描以及注册，在这个方法中对于配置类进行...
ConfigurationClassPostProcessor浅析
m13012606980的专栏
10-11 964
记录ConfigurationClassPostProcessor如何被创建以及干了哪些工作。
ConfigurationClassPostProcessor 详解
qq_44587855的博客
12-27 588
字段 实现接口的方法 这个方法代码有些长，但是却是唯一一个我很愿意耐心读懂的方法。 public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) { List<BeanDefinitionHolder> configCandidates = new ArrayList(); String[] candidateNames = registry.getBeanDefiniti
玩转 Spring 之 配置类解析ConfigurationClassPostProcessor
leofee的博客
10-16 721
ConfigurationClassPostProcessor实现了BeanDefinitionRegistryPostProcessors。 关于BeanDefinitionRegistryPostProcessors定义如下： public interface BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor { void postProcessBeanDefinitionRegistry(BeanDefinit
java -spring 15 配置类 ConfigurationClassPostProcessor
最新发布
qq_38757863的博客
05-19 454
01。
ConfigurationClassPostProcessor配置类后处理器源码深度解析【三万字】
终生学习践行者
11-11 4102
基于最新Spring 5.x，详细介绍ConfigurationClassPostProcessor配置类后处理器的工作流程源码，以及对于重要注解的解析原理。
@configuration注解原理
10-10
@configuration注解是Spring Framework中的一个注解，用于将类标记为配置类。通过@Configuration注解，可以告诉Spring容器该类是一个配置类，Spring容器会根据配置类的定义来生成相应的Bean定义，并且可以在配置类中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值