Spring源码分析のBean扫描流程

原创 已于 2025-02-16 11:47:55 修改 · 1.1k 阅读 · 26 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#spring #java #后端 #springboot

于 2025-02-16 11:47:40 首次发布

文章目录

前言

  原生的Spring在构造ApplicationContext时，会调用refresh方法。其中就包含了扫描所有包含@Component及其子注解的类（注解模式）或解析xml配置文件（xml模式）将其注册为BeanDefinition的逻辑。

一、scanCandidateComponents

  scanCandidateComponents是扫描指定路径下的类，并且将符合要求的类进行解析，注册成BeanDefinition的逻辑。
  在该方法中：

  1. 将传入的类路径进行格式转换。
  2. 获取指定类路径下的所有.class文件。
  3. 通过MetadataReader 解析.class的元数据信息。

  获得类的元数据信息，判断类上是否有相关注解的方式有两种，第一是通过JVM的类加载，第二是MetadataReader 。为什么Spring选择的是后者？因为JVM的类是懒加载的，如果在Spring启动时就将所有目标路径下的类全部通过JVM加载，那么就违背了JVM类加载的机制。并且如果目标路径下的类很多，对于性能也有一定的损失。而MetadataReader 使用的是ASM技术 最终。得到的是BeanDefinition对象而不是在JVM中加载.class文件。

	/**
	*	参数：需要扫描的类路径 例：com.itbaima
	*  返回值：BeanDefinition的集合
	**/
	private Set<BeanDefinition> scanCandidateComponents(String basePackage) {
		Set<BeanDefinition> candidates = new LinkedHashSet<>();
		try {
			//将参数中的类路径进行转换 com.itbaima->classpath*:com/itbaima/**/*.class
			String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
					resolveBasePackage(basePackage) + '/' + this.resourcePattern;
			//得到指定类路径下的所有资源文件（类的.class文件）	
			//例:file [D:\Idea_workspace\2024\springplus\target\classes\com\itbaima\AppConfig.class]
			Resource[] resources = getResourcePatternResolver().getResources(packageSearchPath);
			boolean traceEnabled = logger.isTraceEnabled();
			boolean debugEnabled = logger.isDebugEnabled();
			//遍历这些资源文件
			for (Resource resource : resources) {
				if (traceEnabled) {
					logger.trace("Scanning " + resource);
				}
				try {
					//通过MetadataReader 对某个.class文件的元数据进行解析
					MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource);
					//1.1 isCandidateComponent
					if (isCandidateComponent(metadataReader)) {
						//创建BeanDefinition
						ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
						//设置BeanDefinition的source属性 file [D:\Idea_workspace\2024\springplus\target\classes\com\itbaima\AppConfig.class]
						sbd.setSource(resource);
						//再次进行判断，对应的类是不是接口或抽象类(和上面的isCandidateComponent是重载的方法)
						if (isCandidateComponent(sbd)) {
							if (debugEnabled) {
								logger.debug("Identified candidate component class: " + resource);
							}
							//将该BeanDefinition放入集合中
							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 (FileNotFoundException ex) {
					if (traceEnabled) {
						logger.trace("Ignored non-readable " + resource + ": " + ex.getMessage());
					}
				}
				catch (Throwable ex) {
					throw new BeanDefinitionStoreException(
							"Failed to read candidate component class: " + resource, ex);
				}
			}
		}
		catch (IOException ex) {
			throw new BeanDefinitionStoreException("I/O failure during classpath scanning", ex);
		}
		return candidates;
	}

1.1 isCandidateComponent

  在ClassPathScanningCandidateComponentProvider中，isCandidateComponent有两个，第一个主要是用于判断类元信息中是否需要排除/包含注解：
在这里插入图片描述ExcludeFilter表示排除过滤器，IncludeFilter表示包含过滤器

1.1.1、排除/包含过滤器

  ExcludeFilter的作用：被排除在外的类，即使类上加入了@Component及其子注解，也不会被扫描到：

@Component
public class OrderService {
}

@Component
public class UserService {
}

@ComponentScan(value = "org.ragdollcat",
        excludeFilters = {@ComponentScan.Filter(
                type = FilterType.ASSIGNABLE_TYPE,
                classes = UserService.class)})
public class AppConfig {
}

public class Demo1 {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);

        System.out.println(context.getBean("orderService"));
        System.out.println(context.getBean("userService"));
    }
}

在这里插入图片描述
  IncludeFilter的作用：被包含的类，即使类上没有加入@Component及其子注解，也会被扫描到：

@ComponentScan(value = "org.ragdollcat",
        includeFilters = {@ComponentScan.Filter(
                type = FilterType.ASSIGNABLE_TYPE,
                classes = UserService.class)})
public class AppConfig {
}

public class UserService {
}

在这里插入图片描述

1.1.2、条件装配

  这里还有一个条件装配的概念，我们可以自定义一个类，实现Condition 接口，重写matches方法，自定义匹配的逻辑

@Component
public class MyConditional implements Condition {
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        return false;
    }
}

  并且在需要条件装配的类上，加入@Conditional注解：

@Component
@Conditional(MyConditional.class)
public class UserService {
}

1.1.3、重载一

  在isCandidateComponent方法中：

  1. 判断判断类元信息中是否需要排除/包含注解。
  2. 如果类元信息中需要包含某个注解，能匹配的上，如果还有@Conditional注解，则需要再次判断是否符合条件。
	/**
	*	判断类元信息中是否需要排除/包含注解
	*	参数：类元信息
	*/
	protected boolean isCandidateComponent(MetadataReader metadataReader) throws IOException {
		//如果当前元数据中的注解 有符合需要排除的注解 则返回false
		for (TypeFilter tf : this.excludeFilters) {
			if (tf.match(metadataReader, getMetadataReaderFactory())) {
				return false;
			}
		}
		//如果当前元数据中的注解 有符合包含的注解 则再次进入判断
		for (TypeFilter tf : this.includeFilters) {
			if (tf.match(metadataReader, getMetadataReaderFactory())) {
				return isConditionMatch(metadataReader);
			}
		}
		return false;
	}

	/**
	*  主要用于判断条件装配
	*
	*/
	private boolean isConditionMatch(MetadataReader metadataReader) {
		if (this.conditionEvaluator == null) {
			this.conditionEvaluator =
					new ConditionEvaluator(getRegistry(), this.environment, this.resourcePatternResolver);
		}
		return !this.conditionEvaluator.shouldSkip(metadataReader.getAnnotationMetadata());
	}

	
	public boolean shouldSkip(@Nullable AnnotatedTypeMetadata metadata, @Nullable ConfigurationPhase phase) {
		//元数据为空 或者类上没有加@Conditional注解 无需判断 直接返回false
		if (metadata == null || !metadata.isAnnotated(Conditional.class.getName())) {
			return false;
		}

		if (phase == null) {
			if (metadata instanceof AnnotationMetadata &&
					ConfigurationClassUtils.isConfigurationCandidate((AnnotationMetadata) metadata)) {
				return shouldSkip(metadata, ConfigurationPhase.PARSE_CONFIGURATION);
			}
			return shouldSkip(metadata, ConfigurationPhase.REGISTER_BEAN);
		}

		List<Condition> conditions = new ArrayList<>();
		//得到所有实现了Condition接口的类
		for (String[] conditionClasses : getConditionClasses(metadata)) {
			for (String conditionClass : conditionClasses) {
			  //转换为Condition 对象
				Condition condition = getCondition(conditionClass, this.context.getClassLoader());
				//加入到集合中
				conditions.add(condition);
			}
		}

		AnnotationAwareOrderComparator.sort(conditions);

		for (Condition condition : conditions) {
			ConfigurationPhase requiredPhase = null;
			if (condition instanceof ConfigurationCondition) {
				requiredPhase = ((ConfigurationCondition) condition).getConfigurationPhase();
			}
			//关键点：调用自定义实现了Condition接口的类 的match方法 查看返回结果
			if ((requiredPhase == null || requiredPhase == phase) && !condition.matches(this.context, metadata)) {
				//如果自定义实现了Condition接口的类 的match方法 返回的是false 则 这里返回的true 表示需要跳过加上了@Condition注解的类的扫描
				return true;
			}
		}

		return false;
	}

  在进行匹配时，调用的核心方法：

	@Override
	protected boolean matchSelf(MetadataReader metadataReader) {
		//首先获取类元数据上的注解信息
		AnnotationMetadata metadata = metadataReader.getAnnotationMetadata();
		//返回判断的结果：
		//1、类上有@Component及其子注解 或 2、considerMetaAnnotations 为true 并且类上有@Component及其子注解
		return metadata.hasAnnotation(this.annotationType.getName()) ||
				(this.considerMetaAnnotations && metadata.hasMetaAnnotation(this.annotationType.getName()));
	}

1.1.4、重载二

  第二个isCandidateComponent方法，主要是判断当前类是否是接口或者抽象类，有一种特殊情况，即该类是抽象类，但是有@Lookup注解，也会被装配。

	protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {
		AnnotationMetadata metadata = beanDefinition.getMetadata();
		return (metadata.isIndependent() && (metadata.isConcrete() ||
				(metadata.isAbstract() && metadata.hasAnnotatedMethods(Lookup.class.getName()))));
	}


	default boolean isConcrete() {
		//如果是接口或者抽象类 则返回false
		return !(isInterface() || isAbstract());
	}

1.1.5、补充：@Lookup注解

  如果某个单例bean中有个属性是多例的，在初始化单例后，每次获取到的属性的地址值都是一样的：

@Component
@Scope("prototype")
public class User {
}

@Component
public class OrderService {

    @Autowired
    private User user;

    public void test(){
        System.out.println(user);
    }

//    @Lookup("user")
//    public User m1(){
//        return null;
//    }
}

public class Demo1 {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);

        OrderService orderService = (OrderService) context.getBean("orderService");

        orderService.test();
        orderService.test();
        orderService.test();
    }

}

在这里插入图片描述  如果要每次获取不同的属性，可以使用@Lookup注解实现：

@Component
public class OrderService {

    @Autowired
    private User user;

    public void test(){
        System.out.println(m1());
    }

    @Lookup("user")
    public User m1(){
        return null;
    }
}

在这里插入图片描述

总结

  在Scan方法中主要做了：

  1. 将传入参数的路径进行转换，转换为classpath的格式。
  2. 获取路径下的所有资源文件（.class）。
  3. 通过MetadataReader 解析.class的元数据信息。
  4. 判断被扫描到的类上是否存在@Component及其子注解，并且有无需要排除某个类的情况。还需要判断类上是否加入了@Conditional注解。如果有，调用@Conditional注解value中的类的.matches方法，判断是否需要跳过该类。
  5. 将被扫描的类包装成BeanDefinition对象。
  6. 再次判断被扫描的类是否是接口/抽象类。如果是则不将其创建为BeanDefinition。有加入了@Lookup的抽象类的特殊情况。
  7. 将BeanDefinition对象加入集合。
Spring 源码学习（三）—— 注解式配置解析
weixin_63445802的博客
10-30 1024
AbstractTypeHierarchyTraversingFilter 抽象类只有两个使用 final 修饰的属性，分别为匹配时是否考虑匹配父类或接口的 considerInherited 与 considerInterfaces 属性；AbstractClassTestingTypeFilter 抽象类实现了 match 方法，其直接获取 metadataReader 参数的 ClassMetadata 原始参数并使用该对象执行单一参数的 match 方法；
深度讲解Spring Bean扫描类：源码深度剖析与实战策略
m0_51176516的博客
05-22 1293
Spring Bean扫描是Spring框架中一个非常重要的功能，它使得开发者能够轻松地管理和使用Spring Bean。通过深入理解Spring Bean扫描的源码实现和工作原理，我们可以更好地掌握Spring框架的使用技巧，并在实际开发中更加灵活地运用Spring的各项特性。同时，结合实战策略和技巧，我们可以进一步优化系统的性能和可扩展性，提升开发效率和质量。
ClassPathScanningCandidateComponentProvider
杜海的博客
09-09 3601
ClassPathScanningCandidateComponentProvider是Spring提供的工具，可以按自定义的类型，查找classpath下符合要求的class文件。 // 需要扫描的路径 private static final String scanPackage = "com.dh.node"; /** * 启动就开始扫描到map */ @PostConstruct public void init() { discoverComponents(); } .
【spring如何扫描一个路径下被注解修饰的类】
最新发布
weixin_47068446的博客
10-20 456
我们利用Spring框架或者SpringBoot框架经常会自己写一些注解，来方便自己的业务使用，但是我们如何获取到被注解修饰的类或方法，是一个值得探讨的问题，下面我们会具体分析一些demo来给出路径下某些被注解修饰的类的方案。下面的case是我们获取org.apache.dubbo.springboot.demo下的被@Service修饰的类。4.返回每个匹配类的 BeanDefinition。2.扫描出所有 .class 文件；4.判断类上是否包含指定注解；1.按包扫描 class；
Feign源码深度刨析-(2)组件扫描器:ClassPathScanningCandidateComponentProvider
知秋的博客
08-16 833
“不积跬步，无以至千里。” 这篇文章，一起来看看feign的核心机制，看看是如何扫描所有包下的@FeignClient注解的接口 入口就是这个registerFeignClients(metadata, registry)方法 public void registerFeignClients(AnnotationMetadata metadata, BeanDefinitionRegistry registry) { ClassP.
ClassPathScanningCandidateComponentProvider 扫描给定包及其子包的类
Leon_Jinhai_Sun的博客
11-16 1282
ClassPathScanningCandidateComponentProvider 类的findCandidateComponents()方法具体实现扫描给定类路径包的功能，主要源码如下： //保存过滤规则要包含的注解，即Spring默认的@Component、@Repository、@Service、 //@Controller注解的Bean，以及JavaEE6的@ManagedBean和JSR-330的@Named注解 private final List<TypeFilter> i
spring源码解析-（2）Bean的包扫描
qq_46020268的博客
06-08 1408
if (lazy!= null) {= null) {4 将定义好的BeanDefinition放入set，并返回set。// 创建一个BeanDefinitionHolder，并将其添加到集合中// 应用代理模式// 将BeanDefinition注册到容器中。
spring源码解析-（1）关于Bean
qq_46020268的博客
06-08 846
以上代码可以有效的避免我们在开发中大量的if判断，同时可以让你的代码可阅读性更高。hutools和spring依赖中均有该类型的写法，可以参考一下。2、设计模式&接口&抽象类，帮助更好的处理一系列方法在面对一系列处理的时候，我们应该抽象出接口，并使用抽象类去约定模板方法，继而使用子类去实现，这种方式会节省我们大量重复的工作，而且所有的方法都有迹可循，在模板方法中定义流程，在子类中实现，能够有效的解耦流程和实现。这样我们就可以只关心子类的具体实现了。
Spring源码解析：Bean初始化流程分析
资源摘要信息:"Spring 源码分析（Bean的初始化）" 本文深入探讨了 Spring 框架中 Bean 初始化的核心机制，重点围绕 ClassPathXmlApplicationContext 容器的启动过程展开源码级分析，揭示了 Spring IoC（控制反转）...
spring源码分析之bean的创建
热门推荐
liushangzaibeijing的博客
05-04 6万+
本篇博文通过分析beanFactory.getBean() 方法，完整的阐述了在spring中如何获取一个实例化的bean,分析了相关的源码逻辑，希望能对读者分析spring源码起到很好的参考作用
ClassPathScanningCandidateComponentProvider学习
weixin_44877172的博客
02-18 872
ClassPathScanningCandidateComponentProvider
Spring揭秘：ClassPathScanningProvider接口应用场景及实现原理！
科技互联网领域深度探索者，乐于分享与写作。
03-14 953
ClassPathScanningCandidateComponentProvider是Spring框架中一个非常核心的类，它主要用于在类路径下扫描并发现带有特定注解的组件，支持诸如@ComponentScan、@Component、@Service、@Repository和@Controller等注解的自动扫描和注册。
Reflection 和 ClassPathScanningCandidateComponentProvider的使用
2301_78976656的博客
07-04 618
首先，我们定义一个注解：java复制代码这个例子展示了如何结合使用和反射来实现在 Spring Boot 应用中自动发现和注册服务的功能。这种技术可以显著增强应用的可配置性和模块化，允许开发者通过简单的注解来控制哪些类被加载和如何被处理，从而简化了开发和维护过程。
ClassPathScanningCandidateComponentProvider类详解
weixin_39724194的博客
12-10 442
https://www.cnblogs.com/aspirant/p/10649202.html https://blog.youkuaiyun.com/qq_30038111/article/details/82703383 https://www.jianshu.com/p/369d3fdb0148
【Spring专题】Spring之Bean的生命周期源码解析——阶段一（扫描生成BeanDefinition）
qq_32681589的博客
08-10 1853
Spring最重要的功能就是帮助程序员创建对象（也就是IOC），而启动Spring就是为创建Bean对象做准备，所以我们先明白Spring到底是怎么去创建Bean的，也就是先弄明白Bean的生命周期。Bean的生命周期就是指：在Spring中，一个Bean是如何生成的，如何销毁的。/*** 创建一个新的AnnotationConfigApplicationContext，扫描给定包中的组件，为这些组件注册bean定义，并自动刷新上下文。
聊透Spring类扫描机制
BASK2312的博客
02-22 910
今天我们来聊聊Spring的类扫描机制，也就是Spring判断哪些类归自己管辖，哪些类只能远观不可亵玩的类识别机制。关于Spring的类扫描机制的设计，贰师兄梳理下来的感受是：设计的精巧，实现的优雅，是值得拿出来和小伙伴们解读一波的。吹捧了这么久，我们赶紧进入正题吧，先来看看我们准备从哪几个方面，和大家一起解读Spring的类扫描机制吧。配置类扫描的流程分析。扫描过滤器的工作流程分析。首个配置类解析，触发扫描流程跟踪。
Spring自定义类扫描器
Daily one note for Java
06-16 5284
在我们刚开始接触Spring的时候，要定义bean的话需要在xml中编写，比如： id="myBean" class="your.pkg.YourClass"/> 后来发现如果bean比较多，会需要写很多的bean标签，太麻烦了。于是出现了一个component-scan注解。这个注解直接指定包名就可以，它会去扫描这个包下所有的class，然后判断是否解析： context:componen
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值