@ComponentScan 源码分析 (1)

已于 2023-09-12 21:44:49 修改
阅读量98 收藏
点赞数
文章标签： spring boot java spring 后端
于 2023-09-12 21:38:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38345773/article/details/132841299
版权

作用

@ComponentScan用于扫描指定包下的类，
将标注有@Controller、@Service、@Repository、@Component4个注解其中一个的类扫描到Spring容器，
作为SpringBean

结构

@ComponentScan(excludeFilters = { 
        @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
		@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {

}

流转图说明


分析

refresh

org.springframework.context.support.AbstractApplicationContext#refresh
image.png
直接定位到此处堆栈
image.png

doProcessConfigurationClass

org.springframework.context.annotation.ConfigurationClassParser#doProcessConfigurationClass
**问题1：**为什么启动JavabaseApplication也包含 @Component 注解呢？
答：经过分析直接定位到此方法在此处进行断点，这里会通过投递队列的形式递归解析每一个类注解上的注解

条件断点：annotationType.getName().equals(“org.springframework.boot.autoconfigure.SpringBootApplication”)

底层堆栈：org.springframework.core.annotation.AnnotationTypeMappings#addAllMappings
image.png

@Nullable
	protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass)
			throws IOException {
        
        // 处理配置类的嵌套内部类
        // 为什么启动类JavabaseApplication 也包含 @Component 注解呢
		if (configClass.getMetadata().isAnnotated(Component.class.getName())) {
			// 首先递归处理任何成员（嵌套）类
            // 注册恰好是配置类本身的成员（嵌套）类。
			processMemberClasses(configClass, sourceClass);
		}

		// 处理  @PropertySource 注解
		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");
			}
		}

		// 处理@ComponentScan注解，把ComponentScan或@ComponentScans者注解解析为AnnotationAttributes
		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) {
                // ****核心代码**** 配置类用@ComponentScan注释->立即执行扫描 *******
				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)) {
						
                        // 这里会递归执行，递归的作用是为了检测，本质也不是递归，源码注释说是递归
                        // 每个bean上的是否有 @PropertySource 和 @ComponentScan 注解
                        parse(bdCand.getBeanClassName(), holder.getBeanName());
					}
				}
			}
		}
		

		// No superclass -> processing is complete
		return null;
	}

处理MemberClasses

org.springframework.context.annotation.ConfigurationClassParser#processMemberClasses
处理成员变量带注解的情况如下：

@Import({ServiceB.class,ImportBeanDefinitionRegistrarTest.class}) //导入
public class ConfigurationTest {
    @Configuration(proxyBeanMethods = false)
    @Conditional(ConfigurationTest.EmbeddedDatabaseCondition.class)
    protected static class EmbeddedDatabaseConfiguration {
    }
    static class EmbeddedDatabaseCondition extends SpringBootCondition {
        @Override
        public ConditionOutcome getMatchOutcome(ConditionContext context, AnnotatedTypeMetadata metadata) {
           return new ConditionOutcome(true, (String) null);
        }
    }

    @Configuration(proxyBeanMethods = false)
    protected static class A {
    }

    @Configuration(proxyBeanMethods = false)
    @ConditionalOnClass(DataSource.class)
    protected static class B {
    }
}

image.png

处理@PropertySource

处理@ComponentScans

parse

这里的解析和执行引出俩个思考问题
问题1：为什么我们配置了 @Controller、@Service、@Repository、@Component 注解就能被spring扫描到呢？
答：ClassPathBeanDefinitionScanner 构造方法默认添加了 ，this.includeFilters.add(new AnnotationTypeFilter(Component.class));
问题2：为什么springBoot启动类要在所有的bean目录之上，才能扫描到bean？
**答：**答案就在下面代码中，因为默认的@ComponentScan注解 basePackages 是空的，所以会执行

if (basePackages.isEmpty()) {
// declaringClass = com.aaa.javabase.JavabaseApplication
// ClassUtils.getPackageName(declaringClass) = com.aaa.javabase
basePackages.add(ClassUtils.getPackageName(declaringClass));
}

org.springframework.context.annotation.ComponentScanAnnotationParser#parse

public Set<BeanDefinitionHolder> parse(AnnotationAttributes componentScan, final String declaringClass) {
        // 这里默认的构造方法执行了：this.includeFilters.add(new AnnotationTypeFilter(Component.class));
		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);
		}

        // 解析 @ComponentScan basePackages 参数
		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);
		}

        // 解析 @ComponentScan  basePackageClasses 参数
		for (Class<?> clazz : componentScan.getClassArray("basePackageClasses")) {
			basePackages.add(ClassUtils.getPackageName(clazz));
		}

        // 解析 @ComponentScan  basePackages 参数
        // 魔幻的地方出现了，
		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));
	}

org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider#registerDefaultFilters

	protected void registerDefaultFilters() {
		this.includeFilters.add(new AnnotationTypeFilter(Component.class));
		ClassLoader cl = ClassPathScanningCandidateComponentProvider.class.getClassLoader();
		try {
			this.includeFilters.add(new AnnotationTypeFilter(
					((Class<? extends Annotation>) ClassUtils.forName("javax.annotation.ManagedBean", cl)), false));
			logger.trace("JSR-250 'javax.annotation.ManagedBean' found and supported for component scanning");
		}
		catch (ClassNotFoundException ex) {
			// JSR-250 1.1 API (as included in Java EE 6) not available - simply skip.
		}
		try {
			this.includeFilters.add(new AnnotationTypeFilter(
					((Class<? extends Annotation>) ClassUtils.forName("javax.inject.Named", cl)), false));
			logger.trace("JSR-330 'javax.inject.Named' annotation found and supported for component scanning");
		}
		catch (ClassNotFoundException ex) {
			// JSR-330 API not available - simply skip.
		}
	}

doScan

org.springframework.context.annotation.ClassPathBeanDefinitionScanner#doScan

protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
		Assert.notEmpty(basePackages, "At least one base package must be specified");
		Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>();
		for (String basePackage : basePackages) {
			Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
			for (BeanDefinition candidate : candidates) {
				ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
				candidate.setScope(scopeMetadata.getScopeName());
				String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
				if (candidate instanceof AbstractBeanDefinition) {
					postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
				}
				if (candidate instanceof AnnotatedBeanDefinition) {
					AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
				}
				if (checkCandidate(beanName, candidate)) {
					BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
					definitionHolder =
							AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
					beanDefinitions.add(definitionHolder);
					registerBeanDefinition(definitionHolder, this.registry);
				}
			}
		}
		return beanDefinitions;
	}

org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider#findCandidateComponents

public Set<BeanDefinition> findCandidateComponents(String basePackage) {
		if (this.componentsIndex != null && indexSupportsIncludeFilters()) {
			return addCandidateComponentsFromIndex(this.componentsIndex, basePackage);
		}
		else {
			return scanCandidateComponents(basePackage);
		}
	}

扫描匹配指定候选组件
private Set<BeanDefinition> scanCandidateComponents(String basePackage) {
		Set<BeanDefinition> candidates = new LinkedHashSet<>();
		try {
            // 扫描指定路径下面的静态文件
			String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
					resolveBasePackage(basePackage) + '/' + this.resourcePattern;
			Resource[] resources = getResourcePatternResolver().getResources(packageSearchPath);
			boolean traceEnabled = logger.isTraceEnabled();
			boolean debugEnabled = logger.isDebugEnabled();
			for (Resource resource : resources) {
				if (traceEnabled) {
					logger.trace("Scanning " + resource);
				}
				if (resource.isReadable()) {
					try {
						MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource);
						if (isCandidateComponent(metadataReader)) {
							ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
							sbd.setResource(resource);
							sbd.setSource(resource);
							if (isCandidateComponent(sbd)) {
								if (debugEnabled) {
									logger.debug("Identified candidate component class: " + resource);
								}
								candidates.add(sbd);
							}
							else {
								if (debugEnabled) {
									logger.debug("Ignored because not a concrete top-level class: " + resource);
								}
							}
						}
						else {
							if (traceEnabled) {
								logger.trace("Ignored because not matching any filter: " + resource);
							}
						}
					}
					catch (Throwable ex) {
						throw new BeanDefinitionStoreException(
								"Failed to read candidate component class: " + resource, ex);
					}
				}
				else {
					if (traceEnabled) {
						logger.trace("Ignored because not readable: " + resource);
					}
				}
			}
		}
		catch (IOException ex) {
			throw new BeanDefinitionStoreException("I/O failure during classpath scanning", ex);
		}
		return candidates;
	}

org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider#isCandidateComponent
对应前面的 this.includeFilters.add(new AnnotationTypeFilter(Component.class));
这里会匹配@Component注解匹配上才返回候选组件
image.png

处理@Import

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) {
                    // 1、@Bean注解-扫描 ImportSelector接口的地方
					if (candidate.isAssignable(ImportSelector.class)) {
						// Candidate class is an ImportSelector -> delegate to it to determine imports
						Class<?> candidateClass = candidate.loadClass();
						ImportSelector selector = ParserStrategyUtils.instantiateClass(candidateClass, ImportSelector.class,
								this.environment, this.resourceLoader, this.registry);
						if (selector instanceof DeferredImportSelector) {
                            // 这里需要注意的是 DeferredImportSelector 的直接实现类，不再递归
							this.deferredImportSelectorHandler.handle(configClass, (DeferredImportSelector) selector);
						}
						else {
							String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());
							Collection<SourceClass> importSourceClasses = asSourceClasses(importClassNames);
                            // 这里又是一个递归，把ImportSelector的直接实现类的 selectImports返回的数组，注册bean
							processImports(configClass, currentSourceClass, importSourceClasses, false);
						}
					}
                    // 2、@Bean注解-扫描 ImportBeanDefinitionRegistrar 接口的地方
                    // 用途：@MapperScan注解就是基于此条件执行
					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 =
								ParserStrategyUtils.instantiateClass(candidateClass, ImportBeanDefinitionRegistrar.class,
										this.environment, this.resourceLoader, this.registry);
                        // 这里放入list，后面会在Parse之后，在这里面调用解析ConfigurationClassBeanDefinitionReader#loadBeanDefinitionsFromRegistrars
						configClass.addImportBeanDefinitionRegistrar(registrar, currentSourceClass.getMetadata());
					}
                    // 3、@Bean注解-直接设置class文件的地方
					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();
			}
		}
	}

处理@ImportResource

处理@Bean

处理 Interfaces @Bean

org.springframework.context.annotation.ConfigurationClassParser#processInterfaces
经过debug发现spring内部bean没有用到processInterfaces，所以这块不重要。
处理接口的默认方法实现，从 JDK8 开始，接口中的方法可以有自己的默认实现，如果这个接口的方法加了 @Bean 注解，也需要被解析；然后检索配置类中加了 @Bean 注解的方法，将 @Bean 方法转化为 BeanMethod 对象，保存再集合中。

public interface UserManager {
    @Bean
    default Object testBeanTlz() {
        return new HashSet();
    }
}

@Component
public class UserManagerImpl implements UserManager {
}

private void processInterfaces(ConfigurationClass configClass, SourceClass sourceClass) throws IOException {
    // 找到配置类的所有接口，遍历接口
    for (SourceClass ifc : sourceClass.getInterfaces()) {
        // 找到含有 @Bean 注解的默认方法
        Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(ifc);
        for (MethodMetadata methodMetadata : beanMethods) {
            if (!methodMetadata.isAbstract()) {
                // A default method or other concrete method on a Java 8+ interface...
                // 添加到集合中
                configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
            }
        }
        //递归处理，因为接口可能存在父接口
        processInterfaces(configClass, ifc);
    }
}
十三月tlz
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【SpringBoot笔记15】@ComponentScan源码分析
西瓜游侠的博客
08-11 805
版本：SpringBoot 2.1.7.RELEASE 1 @ComponentScan的作用 @ComponentScan注解是用来告诉Spring框架应该去哪里扫描被@Component注解注释的类，并将这些类注册成Spring容器中的bean的。 @ComponentScan注解通常与@Configuration注解一起使用。 2 @ComponentScan源码分析 @Componen...
Spring IoC源码分析1
08-03
1. **bean的装配方式**： - **XML方式**：传统的Spring配置使用XML文件来定义bean。例如： ```xml ``` 使用`ClassPathXmlApplicationContext`来加载XML配置并创建容器。 ```java ApplicationContext ...
@ComponentScan源码分析
duzhuang2399的博客
08-17 218
`@ComponentScan` 注解，用于自动扫描特定包（和其子包）中的组件，并自动注册为 Spring 容器中的 bean。当我们使用 Spring Boot，它默认会扫描主应用程序所在的包以及子包。但是，如果我们需要更细粒度的控制，或者我们在使用传统的 Spring 而非 Spring Boot，那么我们可能会明确地使用 `@ComponentScan`。
Spring源码系列（二）——@ComponentScan源码解析
犀利的小牛
12-24 1595
首先看一下本次用到的简单的示例代码 StudentA用@Component注解标识 Config用@ComponentScan标识，扫描的基础包路径为：com.kennor.test 最后Test运行的示例代码如下： public static void main(String[] args) { AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(Config
Spring @ComponentScan注解源码分析
xuguofeng2016的博客
01-04 420
本文将通过阅读spring源码，分析@ComponentScan注解扫描组件的原理。 和@Bean注解一样，@ComponentScan注解也是通过ConfigurationClassPostProcessor后置处理器完成扫描工作的。
Spring 源码解读（三）：@ComponentScan使用及原理详解
qq_43602877的博客
01-12 1458
总结的来说，就是初始化了一个ClassPathBeanDefinitionScanner扫描器，根据@ComponentScan的属性，设置扫描器的属性，最后调用扫描器的doScan()方法执行真正的扫描工作。发现配置类LITE模式匹配规则里面并没有包含@ComponentScans注解，所以判断当前类不是配置类，自然不会再进行后面的相关注解解析了，这也就是上面多次使用@ComponentScan扫描注入不成功的问题。@ComponentScan 的定义，比起之前的两个注解，会稍微复杂一些。
SpringBoot 源码解析5：ConfigurationClassPostProcessor整体流程和@ComponentScan源码分析
java_xiaoba1的博客
01-21 1077
SpringBoot源码解析，核心注解支持ConfigurationClassPostProcessor，@ComponentScan源码解析
@ComponentScan注解 -【Spring底层原理】
2401_85767310的博客
06-17 670
ComponentScan注解 -【Spring底层原理】案例已上传GitHub，欢迎star：https://github.com/oneStarLR/spring-annotation一、注解用法。
Spring基础组件的使用——@ComponentScan扫描规则及其源码分析
李云龙的意大利面
04-14 6641
@ComponentScan扫描规则及其源码分析 指定扫描范围 源码解析 自定义过滤规则 ANNOTATION（注解） ASSIGNABLE_TYPE（指定的类型） CUSTOM（自定义） @ComponentScans @ComponentScan告诉Spring 哪个packages 的用注解标识的类 会被spring自动扫描并且装入bean容器。 我们可以先三个方面来学习@ComponentScan 1、指定扫描范围 2、源码解析 3、自定义过滤规则 指定扫描范围 大
【spring源码分析】@ComponentScan的使用以及分析
lzq2357639195的博客
01-13 1199
spring源码分析，@ComponentScan的使用以及分析
SpringBoot源码分析Demo
11-18
本源码分析Demo旨在深入理解SpringBoot的工作原理，特别是其自动化配置和注解解析机制。 首先，让我们来探讨SpringBoot的核心概念——自动化配置。SpringBoot通过`@EnableAutoConfiguration`注解开启了自动化配置...
spring启动componentscan类扫描加载过程
11-25
接下来，我们将深入探讨`@ComponentScan`的工作原理及其背后的源码分析。 首先，`@ComponentScan`注解用于指示Spring容器在指定的包及其子包下搜索带有特定注解（如`@Component`、`@Service`、`@Repository`和`@...
三、Spring源码分析——ApplicationContext
08-11
《Spring源码分析——ApplicationContext》 在Java世界中，Spring框架是不可或缺的一部分，它以其强大的IoC（Inversion of Control，控制反转）和AOP（Aspect Oriented Programming，面向切面编程）特性，极大地...
springboot 启动过程源码分析
11-06
SpringBoot 启动过程源码分析 SpringBoot 的启动原理是基于 JavaConfig 形式的配置，使用 @Configuration 注解标注的启动类来配置 IoC 容器。@SpringBootApplication 注解是 SpringBoot 的核心注解，它包括了三个...
Spring Boot中的多租户架构实现
微赚淘客开发者博客
07-06 1409
在多租户系统中，每个租户都能够安全且有效地使用相同的应用程序，同时确保数据隔离和性能独立性。通过合理的设计和实施，开发人员可以有效地管理和运行支持多个租户的应用程序，从而提升系统的灵活性和扩展性。每个租户是一个逻辑上独立的客户，拥有自己的数据、配置、用户界面等资源，而这些资源又可以在同一个应用程序实例中共享。在Spring Boot中配置多租户数据源，可以使用AbstractRoutingDataSource实现动态数据源切换，根据不同的租户标识动态选择数据源。
【Cookie 在 Spring Boot 中的实现】
武帝为此的博客
07-06 602
Cookie是一小段文本信息，通常由服务器发送到浏览器，然后由浏览器存储在本地。它包含了一些键值对，用于存储关于用户的信息。浏览器在每次请求同一网站时都会将这些Cookie发送回服务器，从而维护会话状态。Cookie通常用于实现用户身份验证、跟踪用户行为、保存用户偏好设置等。
Spring Boot单体服务之间用feign调用
最新发布
木槿
07-09 156
会定义路径和url等信息，用于指定服务调用服务调用启动feign配置调用url。
科普文：spring boot中常用的接口、工具栏、注解整理
为无为，事无事，味无味。
07-08 1182
如果容器中存在ApplicationListener的Bean，当ApplicationContext调用publishEvent方法时，对应的Bean会被触发。
@componentScan源码
04-24
我可以回答你关于@componentScan注解的一些问题，但我不会透露你让我...在源码中，@componentScan被实现为一个带有@Repeatable注释的注释容器。当然，如果你想了解更多细节，你可以查看相关的Spring Framework源代码。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值