Spring源码- context:component-scan base-package标签的作用源码解析

已于 2024-08-02 08:48:27 修改
阅读量370 收藏 5
点赞数 6
分类专栏： Spring源码详解 Spring java学习 文章标签： spring java javascript
于 2024-08-01 18:20:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37200262/article/details/140837860
版权

1.扫描包路径下所有的类加载解析成bean定义信息
在这里插入图片描述
ClassPathBeanDefinitionScanner .doScan方法调用路径

doScan:276, ClassPathBeanDefinitionScanner (org.springframework.context.annotation)
parse:95, ComponentScanBeanDefinitionParser (org.springframework.context.annotation)
parse:76, NamespaceHandlerSupport (org.springframework.beans.factory.xml)
parseCustomElement:1475, BeanDefinitionParserDelegate (org.springframework.beans.factory.xml)
parseCustomElement:1452, BeanDefinitionParserDelegate (org.springframework.beans.factory.xml)
parseBeanDefinitions:181, DefaultBeanDefinitionDocumentReader (org.springframework.beans.factory.xml)
doRegisterBeanDefinitions:150, DefaultBeanDefinitionDocumentReader (org.springframework.beans.factory.xml)
registerBeanDefinitions:97, DefaultBeanDefinitionDocumentReader (org.springframework.beans.factory.xml)
registerBeanDefinitions:526, XmlBeanDefinitionReader (org.springframework.beans.factory.xml)
doLoadBeanDefinitions:397, XmlBeanDefinitionReader (org.springframework.beans.factory.xml)
loadBeanDefinitions:341, XmlBeanDefinitionReader (org.springframework.beans.factory.xml)
loadBeanDefinitions:310, XmlBeanDefinitionReader (org.springframework.beans.factory.xml)
loadBeanDefinitions:190, AbstractBeanDefinitionReader (org.springframework.beans.factory.support)
loadBeanDefinitions:234, AbstractBeanDefinitionReader (org.springframework.beans.factory.support)
loadBeanDefinitions:197, AbstractBeanDefinitionReader (org.springframework.beans.factory.support)
loadBeanDefinitions:267, AbstractBeanDefinitionReader (org.springframework.beans.factory.support)
loadBeanDefinitions:150, AbstractXmlApplicationContext (org.springframework.context.support)
loadBeanDefinitions:102, AbstractXmlApplicationContext (org.springframework.context.support)
refreshBeanFactory:138, AbstractRefreshableApplicationContext (org.springframework.context.support)
obtainFreshBeanFactory:718, AbstractApplicationContext (org.springframework.context.support)
refresh:577, AbstractApplicationContext (org.springframework.context.support)
<init>:150, ClassPathXmlApplicationContext (org.springframework.context.support)
<init>:98, ClassPathXmlApplicationContext (org.springframework.context.support)
<init>:15, MyClassPathXmlApplicationContext (com.mashibing)
main:84, Test (com.mashibing)

parse:95, ComponentScanBeanDefinitionParser (org.springframework.context.annotation)

解析节点使用scanner在执行的basePackages包中执行扫描，返回已注册的bean定义

	@Override
	@Nullable
	public BeanDefinition parse(Element element, ParserContext parserContext) {
		// 获取<context:component-scan>节点的base-package属性值
		String basePackage = element.getAttribute(BASE_PACKAGE_ATTRIBUTE);//base-package
		// 解析占位符
		basePackage = parserContext.getReaderContext().getEnvironment().resolvePlaceholders(basePackage);
		// 解析base-package(允许通过,;\t\n中的任一符号填写多个)
		String[] basePackages = StringUtils.tokenizeToStringArray(basePackage,
				ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);

		// Actually scan for bean definitions and register them.
		// 构建和配置ClassPathBeanDefinitionScanner
		ClassPathBeanDefinitionScanner scanner = configureScanner(parserContext, element);//类路径Bean定义扫描器
		// 使用scanner在执行的basePackages包中执行扫描，返回已注册的bean定义
		Set<BeanDefinitionHolder> beanDefinitions = scanner.doScan(basePackages);
		// 组件注册（包括注册一些内部的注解后置处理器，触发注册事件）
		registerComponents(parserContext.getReaderContext(), beanDefinitions, element);

		return null;
	}

doScan:276, ClassPathBeanDefinitionScanner (org.springframework.context.annotation)

扫描开始

	/**
	 * Perform a scan within the specified base packages, 在指定的基本包内执行扫描，
	 * returning the registered bean definitions. 返回已注册的bean定义。
	 * <p>This method does <i>not</i> register an annotation config processor 这个方法不注册注释配置处理器
	 * but rather leaves this up to the caller. 而是把这个问题留给调用者。
	 * @param basePackages the packages to check for annotated classes 要检查带注释的类的包
	 * @return set of beans registered if any for tooling registration purposes (never {@code null}) 为了工具注册目的而注册的bean集(从不{@code null})
	 */
	protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
		Assert.notEmpty(basePackages, "At least one base package must be specified");
		Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>();
		// 遍历basePackages
		for (String basePackage : basePackages) {
			// 扫描basePackage,将符合要求的bean定义全部找出来
			Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
			// 遍历所有候选的bean定义
			for (BeanDefinition candidate : candidates) {
				// 解析@Scope注解，包括scopeName和proxyMode
				ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
				candidate.setScope(scopeMetadata.getScopeName());
				// 使用beanName生成器来生成beanName
				String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
				if (candidate instanceof AbstractBeanDefinition) {
					// 处理beanDefinition对象，例如，此bean是否可以自动装配到其他bean中
					postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
				}
				if (candidate instanceof AnnotatedBeanDefinition) {
					// 处理定义在目标类上的通用注解，包括@Lazy，@Primary，@DependsOn，@Role，@Description
					AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
				}
				// 检查beanName是否已经注册过，如果注册过，检查是否兼容
				if (checkCandidate(beanName, candidate)) {
					// 将当前遍历bean的bean定义和beanName封装成BeanDefinitionHolder
					BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
					// 根据proxyMode的值，选择是否创建作用域代理
					definitionHolder =
							AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
					beanDefinitions.add(definitionHolder);
					// 注册beanDefinition
					registerBeanDefinition(definitionHolder, this.registry);
				}
			}
		}
		return beanDefinitions;
	}

// 扫描basePackage,将符合要求的bean定义全部找出来
Set candidates = findCandidateComponents(basePackage);

	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 {//组装扫描路径（组装完成后是这种格式：classpath*:org/springframework/learn/demo01/**/*.class）
			String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
					resolveBasePackage(basePackage) + '/' + this.resourcePattern;
			Resource[] resources = getResourcePatternResolver().getResources(packageSearchPath);//根据路径获取资源对象，即扫描出该路径下的的所有class文件，得到 Resource
			boolean traceEnabled = logger.isTraceEnabled();
			boolean debugEnabled = logger.isDebugEnabled();
			for (Resource resource : resources) {
				if (traceEnabled) {
					logger.trace("Scanning " + resource);
				}
				if (resource.isReadable()) {
					try {//根据资源对象获取资源对象的MetadataReader
						MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource);
						if (isCandidateComponent(metadataReader)) {// 1. 是否需要初始化为spring bean，即是否有 @Component、@Service等注解//2. 查看配置类是否有@Conditional一系列的注解，然后是否满足注册Bean的条件
							ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);// 将 metadataReader 转换为 ScannedGenericBeanDefinition，这也是BeanDefinition家族中的一员
							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;
	}

判断是否可以生成bean定义信息

	protected boolean isCandidateComponent(MetadataReader metadataReader) throws IOException {
		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;
	}

	/**
	 * Determine whether the given class is a candidate component based on any 确定给定的类是否是基于任何的候选组件
	 * {@code @Conditional} annotations.{@code @Conditional}注释。
	 * @param metadataReader the ASM ClassReader for the class
	 * @return whether the class qualifies as a candidate component
	 */
	private boolean isConditionMatch(MetadataReader metadataReader) {
		if (this.conditionEvaluator == null) {
			this.conditionEvaluator =
					new ConditionEvaluator(getRegistry(), this.environment, this.resourcePatternResolver);
		}
		return !this.conditionEvaluator.shouldSkip(metadataReader.getAnnotationMetadata());
	}

    /**
     * Determine if an item should be skipped based on {@code @Conditional} annotations.
     * The {@link ConfigurationPhase} will be deduced from the type of item (i.e. a
     * {@code @Configuration} class will be {@link ConfigurationPhase#PARSE_CONFIGURATION})
     *
     * @param metadata the meta data
     * @return if the item should be skipped
     */
    public boolean shouldSkip(AnnotatedTypeMetadata metadata) {
        return shouldSkip(metadata, null);
    }

 /**
     * 基于@Conditional标签判断该对象是否要跳过
     * <p>
     * Determine if an item should be skipped based on {@code @Conditional} annotations.
     *
     * @param metadata the meta data
     * @param phase    the phase of the call
     * @return if the item should be skipped
     */
    public boolean shouldSkip(@Nullable AnnotatedTypeMetadata metadata, @Nullable ConfigurationPhase phase) {
        // metadata为空或者配置类中不存在@Conditional标签
        if (metadata == null || !metadata.isAnnotated(Conditional.class.getName())) {
            return false;
        }

        // 采用递归的方式进行判断，第一次执行的时候phase为空，向下执行 // 判断传入的 phase
        if (phase == null) {
            // 下面的逻辑判断中，需要进入ConfigurationClassUtils.isConfigurationCandidate方法，主要的逻辑如下：
            // 1、metadata是AnnotationMetadata类的一个实例
            // 2、检查bean中是否使用@Configuration注解
            // 3、检查bean不是一个接口
            // 4、检查bean中是否包含@Component @ComponentScan @Import @ImportResource中任意一个
            // 5、检查bean中是否有@Bean注解
            // 只要满足其中1,2或者1,3或者1,4或者1,5就会继续递归
            if (metadata instanceof AnnotationMetadata &&
                    ConfigurationClassUtils.isConfigurationCandidate((AnnotationMetadata) metadata)) {
                return shouldSkip(metadata, ConfigurationPhase.PARSE_CONFIGURATION);
            }
            return shouldSkip(metadata, ConfigurationPhase.REGISTER_BEAN);
        }
        // 实例化 condition，其放入 conditions 中
        List<Condition> conditions = new ArrayList<>();
        for (String[] conditionClasses : getConditionClasses(metadata)) {// 1. getConditionClasses(metadata)：获取 @Conditional 中指定的判断类
            for (String conditionClass : conditionClasses) {
                // 获取到@Conditional注解后面的value数组  // 2. 实例化操作（用到的还是反射），统一放到 conditions 中
                Condition condition = getCondition(conditionClass, this.context.getClassLoader());
                conditions.add(condition);
            }
        }
        // 对相关的条件进行排序操作
        AnnotationAwareOrderComparator.sort(conditions);// 3. 排序上面得到的 condition 实例

        for (Condition condition : conditions) {
            ConfigurationPhase requiredPhase = null;
            if (condition instanceof ConfigurationCondition) {
                requiredPhase = ((ConfigurationCondition) condition).getConfigurationPhase();
            }
            // requiredPhase只可能是空或者是ConfigurationCondition的一个实例对象
            if ((requiredPhase == null || requiredPhase == phase) && !condition.matches(this.context, metadata)) {

                //此逻辑为：1.requiredPhase不是ConfigurationCondition的实例
                //2.phase==requiredPhase,从上述的递归可知：phase可为ConfigurationPhase.PARSE_CONFIGURATION或者ConfigurationPhase.REGISTER_BEAN
                //3.condition.matches(this.context, metadata)返回false
                //如果1、2或者1、3成立，则在此函数的上层将阻断bean注入Spring容器
                return true;// 4. 调用 Condition#matches 方法进行判断
            }
        }

        return false;
    }

ConfigurationClassUtils.isConfigurationCandidate((AnnotationMetadata) metadata))

/**
	 * 检查给定的元数据，以查找给定的候选配置类是否被指定的注解标注
	 *
	 * Check the given metadata for a configuration class candidate
	 * (or nested component class declared within a configuration/component class).
	 * @param metadata the metadata of the annotated class
	 * @return {@code true} if the given class is to be registered for
	 * configuration class processing; {@code false} otherwise
	 */
	public static boolean isConfigurationCandidate(AnnotationMetadata metadata) {
		// Do not consider an interface or an annotation...
		// 不考虑接口或注解
		if (metadata.isInterface()) {
			return false;
		}

		// Any of the typical annotations found?
		// 检查是否被注解@Component、@ComponentScan、@Import、@ImportResource标注
		for (String indicator : candidateIndicators) {
			if (metadata.isAnnotated(indicator)) {
				return true;
			}
		}

		// Finally, let's look for @Bean methods...
		// 最后检查是否有@Bean标注的方法
		try {
			return metadata.hasAnnotatedMethods(Bean.class.getName());
		}
		catch (Throwable ex) {
			if (logger.isDebugEnabled()) {
				logger.debug("Failed to introspect @Bean methods on class [" + metadata.getClassName() + "]: " + ex);
			}
			return false;
		}
	}

解析节点使用scanner在执行的basePackages包中执行扫描，返回已注册的bean定义这步有个registerComponents方法实现:调用链路如下:

registerAnnotationConfigProcessors:155, AnnotationConfigUtils (org.springframework.context.annotation)
registerComponents:168, ComponentScanBeanDefinitionParser (org.springframework.context.annotation)
parse:97, ComponentScanBeanDefinitionParser (org.springframework.context.annotation)
parse:76, NamespaceHandlerSupport (org.springframework.beans.factory.xml)
parseCustomElement:1475, BeanDefinitionParserDelegate (org.springframework.beans.factory.xml)
parseCustomElement:1452, BeanDefinitionParserDelegate (org.springframework.beans.factory.xml)
parseBeanDefinitions:181, DefaultBeanDefinitionDocumentReader (org.springframework.beans.factory.xml)
doRegisterBeanDefinitions:150, DefaultBeanDefinitionDocumentReader (org.springframework.beans.factory.xml)
registerBeanDefinitions:97, DefaultBeanDefinitionDocumentReader (org.springframework.beans.factory.xml)
registerBeanDefinitions:526, XmlBeanDefinitionReader (org.springframework.beans.factory.xml)
doLoadBeanDefinitions:397, XmlBeanDefinitionReader (org.springframework.beans.factory.xml)
loadBeanDefinitions:341, XmlBeanDefinitionReader (org.springframework.beans.factory.xml)
loadBeanDefinitions:310, XmlBeanDefinitionReader (org.springframework.beans.factory.xml)
loadBeanDefinitions:190, AbstractBeanDefinitionReader (org.springframework.beans.factory.support)
loadBeanDefinitions:234, AbstractBeanDefinitionReader (org.springframework.beans.factory.support)
loadBeanDefinitions:197, AbstractBeanDefinitionReader (org.springframework.beans.factory.support)
loadBeanDefinitions:267, AbstractBeanDefinitionReader (org.springframework.beans.factory.support)
loadBeanDefinitions:150, AbstractXmlApplicationContext (org.springframework.context.support)
loadBeanDefinitions:102, AbstractXmlApplicationContext (org.springframework.context.support)
refreshBeanFactory:138, AbstractRefreshableApplicationContext (org.springframework.context.support)
obtainFreshBeanFactory:718, AbstractApplicationContext (org.springframework.context.support)
refresh:577, AbstractApplicationContext (org.springframework.context.support)
<init>:150, ClassPathXmlApplicationContext (org.springframework.context.support)
<init>:98, ClassPathXmlApplicationContext (org.springframework.context.support)
<init>:15, MyClassPathXmlApplicationContext (com.mashibing)
main:84, Test (com.mashibing)

	// 组件注册（包括注册一些内部的注解后置处理器，触发注册事件）
		registerComponents(parserContext.getReaderContext(), beanDefinitions, element);



	protected void registerComponents(
			XmlReaderContext readerContext, Set<BeanDefinitionHolder> beanDefinitions, Element element) {

		Object source = readerContext.extractSource(element);
		// 使用注解的tagName和source构建CompositeComponentDefinition
		CompositeComponentDefinition compositeDef = new CompositeComponentDefinition(element.getTagName(), source);

		// 将扫描到的所有beanDefinition添加到compositeDef的nestedComponents属性中
		for (BeanDefinitionHolder beanDefHolder : beanDefinitions) {
			compositeDef.addNestedComponent(new BeanComponentDefinition(beanDefHolder));
		}

		// Register annotation config processors, if necessary. 如果需要，注册注释配置处理器。
		boolean annotationConfig = true;
		if (element.hasAttribute(ANNOTATION_CONFIG_ATTRIBUTE)) {//"annotation-config";
			// 获取component-scan标签的annotation-config属性值，默认为true
			annotationConfig = Boolean.parseBoolean(element.getAttribute(ANNOTATION_CONFIG_ATTRIBUTE));
		}
		if (annotationConfig) {
			// 如果annotation-config属性值为true，在给定的注册表中注册所有用于注解的bean后置处理器 internalConfigurationAnnotationProcessor
			Set<BeanDefinitionHolder> processorDefinitions =
					AnnotationConfigUtils.registerAnnotationConfigProcessors(readerContext.getRegistry(), source);
			for (BeanDefinitionHolder processorDefinition : processorDefinitions) {
				// 将注册的注解后置处理器的BeanDefinition添加到compositeDef的nestedComponents属性中
				compositeDef.addNestedComponent(new BeanComponentDefinition(processorDefinition));//将给定组件添加为该复合组件的嵌套元素。
			}
		}

		// 触发组件注册事件，默认实现为EmptyReaderEventListener
		readerContext.fireComponentRegistered(compositeDef);
	}

public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
			BeanDefinitionRegistry registry, @Nullable Object source) {

		// 获取beanFactory
		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());
			}
		}

		// 创建BeanDefinitionHolder集合
		Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);

		// 注册内部管理的用于处理@configuration注解的后置处理器的bean
		if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {// internalConfigurationAnnotationProcessor
			RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
			def.setSource(source);
			// 注册BeanDefinition到注册表中 internalConfigurationAnnotationProcessor
			beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
		}

		// 注册内部管理的用于处理@Autowired，@Value,@Inject以及@Lookup注解的后置处理器bean
		if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {// internalAutowiredAnnotationProcessor
			RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
			def.setSource(source);
			beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));//internalAutowiredAnnotationProcessor
		}

		// Check for JSR-250 support, and if present add the CommonAnnotationBeanPostProcessor.
		// 注册内部管理的用于处理JSR-250注解，例如@Resource,@PostConstruct,@PreDestroy的后置处理器bean
		if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {//internalCommonAnnotationProcessor
			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.
		// 注册内部管理的用于处理JPA注解的后置处理器bean
		if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) {//internalPersistenceAnnotationProcessor
			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));
		}

		// 注册内部管理的用于处理@EventListener注解的后置处理器的bean
		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));
		}

		// 注册内部管理用于生产ApplicationListener对象的EventListenerFactory对象
		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;
	}

ConfigurationClassPostProcessor.class:

public static final String CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME =
			"org.springframework.context.annotation.internalConfigurationAnnotationProcessor";

AutowiredAnnotationBeanPostProcessor.class：

public static final String AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME =
			"org.springframework.context.annotation.internalAutowiredAnnotationProcessor";

CommonAnnotationBeanPostProcessor.class：

	public static final String COMMON_ANNOTATION_PROCESSOR_BEAN_NAME =
			"org.springframework.context.annotation.internalCommonAnnotationProcessor";

EventListenerMethodProcessor.class：

public static final String EVENT_LISTENER_PROCESSOR_BEAN_NAME =
			"org.springframework.context.event.internalEventListenerProcessor";

DefaultEventListenerFactory.class：

public static final String EVENT_LISTENER_FACTORY_BEAN_NAME =
			"org.springframework.context.event.internalEventListenerFactory";

最终话 调用这个方法向容器注册bean ，beanName就是上面的类的全路径名

registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)

	private static BeanDefinitionHolder registerPostProcessor(
			BeanDefinitionRegistry registry, RootBeanDefinition definition, String beanName) {

		// 设置role
		definition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
		// 注册BeanDefinition到registry
		registry.registerBeanDefinition(beanName, definition);
		// 封装成BeanDefinitionHolder并返回
		return new BeanDefinitionHolder(definition, beanName);
	}

public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
			throws BeanDefinitionStoreException {

		Assert.hasText(beanName, "Bean name must not be empty");
		Assert.notNull(beanDefinition, "BeanDefinition must not be null");

		if (beanDefinition instanceof AbstractBeanDefinition) {
			try {
				// 注册前的最后一个校验，这里的检验不同于之前的xml文件校验，主要是对应abstractBeanDefinition属性的methodOverrides校验，
				// 检验methodOverrides是否与工厂方法并存或者methodoverrides对应的方法根本不存在
				((AbstractBeanDefinition) beanDefinition).validate();
			}
			catch (BeanDefinitionValidationException ex) {
				throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
						"Validation of bean definition failed", ex);
			}
		}

		BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
		// 处理注册已经注册的beanName情况
		if (existingDefinition != null) {
			// 如果对应的beanName已经注册且在配置中配置了bean不允许被覆盖，则抛出异常
			if (!isAllowBeanDefinitionOverriding()) {
				throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
			}
			else if (existingDefinition.getRole() < beanDefinition.getRole()) {
				// e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
				if (logger.isInfoEnabled()) {
					logger.info("Overriding user-defined bean definition for bean '" + beanName +
							"' with a framework-generated bean definition: replacing [" +
							existingDefinition + "] with [" + beanDefinition + "]");
				}
			}
			else if (!beanDefinition.equals(existingDefinition)) {
				if (logger.isDebugEnabled()) {
					logger.debug("Overriding bean definition for bean '" + beanName +
							"' with a different definition: replacing [" + existingDefinition +
							"] with [" + beanDefinition + "]");
				}
			}
			else {
				if (logger.isTraceEnabled()) {
					logger.trace("Overriding bean definition for bean '" + beanName +
							"' with an equivalent definition: replacing [" + existingDefinition +
							"] with [" + beanDefinition + "]");
				}
			}
			this.beanDefinitionMap.put(beanName, beanDefinition);
		}
		else {
			if (hasBeanCreationStarted()) {
				// Cannot modify startup-time collection elements anymore (for stable iteration) 不能再修改启动时集合元素(为了稳定迭代)
				synchronized (this.beanDefinitionMap) {
					this.beanDefinitionMap.put(beanName, beanDefinition);
					List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
					updatedDefinitions.addAll(this.beanDefinitionNames);
					updatedDefinitions.add(beanName);
					this.beanDefinitionNames = updatedDefinitions;
					removeManualSingletonName(beanName);
				}
			}
			else {
				// Still in startup registration phase
				// 注册beanDefinition
				this.beanDefinitionMap.put(beanName, beanDefinition);
				// 记录beanName
				this.beanDefinitionNames.add(beanName);
				//更新工厂的内部手工单例名称集。
				removeManualSingletonName(beanName);
			}
			this.frozenBeanDefinitionNames = null;
		}

		if (existingDefinition != null || containsSingleton(beanName)) {
			// 重置所有beanName对应的缓存
			resetBeanDefinition(beanName);
		}
		else if (isConfigurationFrozen()) {
			//除关于按类型映射的任何假设。
			clearByTypeCache();
		}
	}

invokeBeanFactoryPostProcessors在执行的时候扫描找到所有实现BeanDefinitionRegistryPostProcessor接口bean的beanName
ConfigurationClassPostProcessor.class:这个类后续会被执行到里面的postProcessBeanDefinitionRegistry方法

public static final String CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME =
			"org.springframework.context.annotation.internalConfigurationAnnotationProcessor";
```java
invokeBeanFactoryPostProcessors:109, PostProcessorRegistrationDelegate (org.springframework.context.support)
invokeBeanFactoryPostProcessors:812, AbstractApplicationContext (org.springframework.context.support)
refresh:590, AbstractApplicationContext (org.springframework.context.support)
<init>:150, ClassPathXmlApplicationContext (org.springframework.context.support)
<init>:98, ClassPathXmlApplicationContext (org.springframework.context.support)
<init>:15, MyClassPathXmlApplicationContext (com.mashibing)
main:84, Test (com.mashibing)

在这里插入图片描述

努力的布布
关注
专栏目录
＜context:component-scan base-package=““/＞中base-package值得语法规则
summer_style的博客
10-23 1077
spring中 base-package 属性指定要扫描的基础包。我们可以在配置中使用匹配符和占位符。 通配符说明： ? 匹配一个字符 * 匹配空或匹配至少一个字符但不包含分割符（默认分割符为‘/’） ** 匹配空或匹配至少一个字符可以包含分割符（默认分割符为‘/’） <!-- 完整的包 --> <context:component-scan base-package="com.test" /> <!-- 使用通配符，只能匹配 com.a.test 无法匹配 com.a.b
五、component-scan 标签的解析原理
书生不读四书五经
07-30 4080
文章目录一、component-scan概述1、Spring中component-scan标签配置2、component-scan功能案例代码二、component-scan解析源码1、回顾Spring的自定义标签解析（SPI）2、Spring xml解析自定义标签入口3、ContextNamespaceHandler parse解析4、ComponentScanBeanDefinitionParser 解析compponent-scan标签4.1 注解扫描器4.2 扫描包下的类并注册BeanDefinit
spring 配置<context:component-scan base-package=” ”/>
jiangxindu1的专栏
06-13 3万+
在context中配置 如：在base-package指明一个包： 表明cn.gacl.java包及其子包中，如果某个类的头上带有特定的注解 @Component，@Repository，@Service，@Controller，就会将这个对象作为Bean注册进Spring容器。 在中指定多个包： ,cn.edu.service.impl,cn.edu.action"/>
关于component-scan中base-package包含通配符的问题探究
热门推荐
菜鸟的成长之路...
07-19 6万+
今天在配置Spring的component-scan时，发现了一个有趣的问题。就是在指定base-package时，如果使用了星号通配符*，有时会出现类扫描不到的情况。下面研究一下这个问题。先介绍一下项目结构： 为了演示，我在java文件夹下创建名为controller的包，并在该包下创建了一个名为IndexController的类。如图所示： 先来看正常情况： 在Spring配置文件中配
关于spring中<context:component-scan base-package="" />写法
huwenhu2007的专栏
09-03 2万+
1.通配符形式 2.全路径 3.AspectJ語法 4.正则表达式语法
Spring-解析context:component-scan base-package=""
Andy_Health的博客
03-17 397
spring.xml中配置注解扫描 测试用例 AnnotationConfigApplicationContext ，并调用refresh();方法 根据解析xml路径，进入解析自定义xml标签，DefaultBeanDefinitionDocumentReader.parseBeanDefinitions()方法中delegate.parseCustomElement(ele); 4....
Spring扫描器—spring组件扫描使用详解
04-05
在Spring框架中，`<context:component-scan/>`元素是核心组件扫描的基石，它允许我们自动检测和注册beans，极大地简化了配置工作。这篇博客将深入探讨这个功能强大的特性，以及如何在实际开发中有效利用它。 一、...
Spring IoC源码学习：context:component-scan 节点详解
程序员囧辉
02-17 6237
前言 在Spring IoC：parseCustomElement详解中，我们介绍了自定义命名空间节点解析的大部分内容，但是还剩下节点解析的具体过程。本文将以 <context:component-scan />节点为例子，介绍自定义命名空间 context的component-scan节点的解析过程。 正文 首先，我们回到Spring IoC：parseCu...
逐行解读Spring（二） - 自定义标签解析与component-scan原理
github_37947909的博客
07-03 588
文章目录一、自定义标签是什么？1. 自定义标签的定义2. 关于`spring`内置的自定义标签`context:component-scan`二、源码解析1. 自定义标签解析过程2. `context:component-scan`标签工作原理3. Filter匹配流程三、实践1. 使用`context:component-scan`扫描自定义注解2. 自定义标签四、总结1. 自定义标签解析过程2. `@Component`，`@Service`等注解的实现原理五、其他 上一篇我们讲了默认标签-bean标签
spring_MVC源码
07-31
12. <context:component-scan base-package="com.mvc.controller" /> 13. <!-- 启动Spring MVC的注解功能，完成请求和注解POJO的映射 --> 14. <bean class="org.springframework.web.servlet.mvc....
Spring扫描组件<context:component-scan base-package=" "/>的使用详解
冰冻非一日之寒
12-16 3万+
1.如果不想在xml文件中配置bean，我们可以给我们的类加上spring组件注解，只需再配置下spring的扫描器就可以实现bean的自动载入。 需要注意的是： 在base-package指明一个包： 表明com.b505包及其子包中，如果某个类的头上带有特定的注解 @Component，@Repository，@Service，@Controller，就会将
spring配置<context:component-scan base-package=””/>
menghuanzhiming的博客
09-14 5861
base-package属性，指定扫描的包，配置扫描多个包，可以通过“,”逗号隔开； use-default-filters属性是使用默认过滤器，默认值为true， 首先通过exclude-filter 进行黑名单过滤； 然后通过include-filter 进行白名单过滤； 否则默认选中扫描。（true则会对除了黑名单外进行扫描管理，false则不使用默认过滤器） context:inclu
30Springd的包扫描——<context:component-scan base-package=” ”/>
weixin_33769207的博客
10-13 148
在context中配置 如：在base-package指明一个包： &lt;context:component-scan base-package="cn.edu.dao"/&gt; 表明cn.gacl.java包及其子包中，如果某个类的头上带有特定的注解 @Component，@Repository，@Service，@Controller，就会将这个对象作为Bean注册进spring容器。 ...
【小平工作日志】Spring注解注入配置：<context:component-scan base-package="**.**"/>详解！...
10-18 472
Spring 从2.5（+）版本开始支持注解注入，为spring配置省了很多事情。但同时因为注解是写入在代码里面的，也损失了灵活操作性。 我们首先看一个注解注入的实际例子，然后再详细介绍context:component-scan的使用。 如果你已经在用spring mvc的注解配置，那么...
spring的<context:component-scan base-package=""/>用法
chamy1213的博客
11-17 1059
使用 @Component 虽然我们可以通过@Autowired或@Resource在 Bean 类中使用自动注入功能，但是 Bean 还是在 XML 文件中通过 进行定义 —— 也就是说，在 XML 配置文件中定义 Bean，通过@Autowired或@Resource为 Bean 的成员变量、方法入参或构造函数入参提供自动注入的功能。能否也通过注释定义 Bean，从 XML 配置
Spring <context:component-scan base-package=""/> 与 <context:annotation-config/>的区别
fjkxyl的博客
03-18 506
前段时间开发遇到一个这样的问题，使用开启注解服务后，发现@Controller，@Component，@Service等注解失效了，这里用代码演示一下问题出现的现象 xml version="1.0" encoding="UTF-8"?> beans xmlns="http://www.springframework.org/schema/beans"     xml
【Spring】context:component-scan包扫描问题
qq_27579471的博客
11-13 3791
Spring 项目bean 无法注入或者初始化，可能是扫描问题，下面分两种情况研究 1.配置的bean 没有被扫描 先说一下<context:component-scan base-package=“com.summer”> ,这个标签有一个use-default-filters属性，该属性默认为true(表示扫描到有@Component @Controller@Service @Re...
Spring配置项之<context:component-scan base-package="..."/>
www.hohode.com
02-16 669
Spring配置项之
context:component-scan base-package
最新发布
03-16
这是Spring框架中的一个注解，用于自动扫描指定包下的组件（包括类、接口、注解等），并将其注册为Spring容器中的Bean。其中，base-package参数指定要扫描的包路径。这样可以方便地管理和使用组件，提高开发效率。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值