第十章 annotation-config、component-scan

最新推荐文章于 2021-09-07 15:56:53 发布
最新推荐文章于 2021-09-07 15:56:53 发布
阅读量192 收藏
点赞数
分类专栏： spring源码分析 文章标签： spring annotation-config/ component
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_30561643/article/details/101671502
版权

annotation-config、component-scan

解析开始

Tips

spring使用篇中第二章介绍该便标签的使用，后面介绍源码分析

annotation-config

org.springframework.beans.factory.xml.NamespaceHandlerSupport#parse

public BeanDefinition parse(Element element, ParserContext parserContext) {
		// 第一步:  根据元素的类型查询对应的解析器
		BeanDefinitionParser parser = findParserForElement(element, parserContext);
		// 第二步:  解析....
		return (parser != null ? parser.parse(element, parserContext) : null);
}

注册类：
org.springframework.context.annotation.AnnotationConfigBeanDefinitionParser#parse

  • org.springframework.context.annotation.internalConfigurationAnnotationProcessor
  • org.springframework.context.annotation.internalAutowiredAnnotationProcessor
  • org.springframework.context.annotation.internalCommonAnnotationProcessor
  • org.springframework.context.annotation.internalPersistenceAnnotationProcessor
  • org.springframework.context.event.internalEventListenerProcessor
  • org.springframework.context.event.internalEventListenerFactory

主要解析的注解：

  • @Autowired
  • @Resource
  • @PostConstruct
  • @PreDestroy
public BeanDefinition parse(Element element, ParserContext parserContext) {
		Object source = parserContext.extractSource(element);
		// Obtain bean definitions for all relevant BeanPostProcessors.
		// 注册注解处理器 org.springframework.context.support.ClassPathXmlApplicationContext
		Set<BeanDefinitionHolder> processorDefinitions =
				AnnotationConfigUtils.registerAnnotationConfigProcessors(parserContext.getRegistry(), source);
		// Register component for the surrounding <context:annotation-config> element.
		//
		CompositeComponentDefinition compDefinition = new CompositeComponentDefinition(element.getTagName(), source);
		parserContext.pushContainingComponent(compDefinition);

		// Nest the concrete beans in the surrounding component.
		for (BeanDefinitionHolder processorDefinition : processorDefinitions) {
			parserContext.registerComponent(new BeanComponentDefinition(processorDefinition));
		}

		// Finally register the composite component.
		parserContext.popAndRegisterContainingComponent();
		return null;
	}

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

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

注解： 主要是介绍bean的依赖注入

component-scan

public BeanDefinition parse(Element element, ParserContext parserContext) {
		// 第一步:  根据元素的类型查询对应的解析器
		BeanDefinitionParser parser = findParserForElement(element, parserContext);
		// 第二步:  解析....
		return (parser != null ? parser.parse(element, parserContext) : null);
	}

org.springframework.context.annotation.ComponentScanBeanDefinitionParser#parse

public BeanDefinition parse(Element element, ParserContext parserContext) {
		// 第一步: 获取base-package属性
		String basePackage = element.getAttribute(BASE_PACKAGE_ATTRIBUTE);
        // 第二步: 替换占位符
		basePackage = parserContext.getReaderContext().getEnvironment().resolvePlaceholders(basePackage);
		// 第三步: 分割包路径
		String[] basePackages = StringUtils.tokenizeToStringArray(basePackage,
				ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);

		// Actually scan for bean definitions and register them.
		// 第四步: 扫描bean定义注册
		ClassPathBeanDefinitionScanner scanner = configureScanner(parserContext, element);
		// 第五步: bean定义扫描
		Set<BeanDefinitionHolder> beanDefinitions = scanner.doScan(basePackages);
		// 第六步: 注册组件
		registerComponents(parserContext.getReaderContext(), beanDefinitions, element);

		return null;
	}

org.springframework.context.annotation.ComponentScanBeanDefinitionParser#configureScanner

protected ClassPathBeanDefinitionScanner configureScanner(ParserContext parserContext, Element element) {
		boolean useDefaultFilters = true;
		//  如果有这个use-default-filters属性 使用默认的filter进行包扫描
		if (element.hasAttribute(USE_DEFAULT_FILTERS_ATTRIBUTE)) {
			useDefaultFilters = Boolean.valueOf(element.getAttribute(USE_DEFAULT_FILTERS_ATTRIBUTE));
		}

		// Delegate bean definition registration to scanner class.
		// 创建bean定义扫描器
		ClassPathBeanDefinitionScanner scanner = createScanner(parserContext.getReaderContext(), useDefaultFilters);
		scanner.setBeanDefinitionDefaults(parserContext.getDelegate().getBeanDefinitionDefaults());
		// 设置自动装配模式
		scanner.setAutowireCandidatePatterns(parserContext.getDelegate().getAutowireCandidatePatterns());
        //
		if (element.hasAttribute(RESOURCE_PATTERN_ATTRIBUTE)) {
			scanner.setResourcePattern(element.getAttribute(RESOURCE_PATTERN_ATTRIBUTE));
		}

		try {
			// 解析beanName生成器
			parseBeanNameGenerator(element, scanner);
		}
		catch (Exception ex) {
			parserContext.getReaderContext().error(ex.getMessage(), parserContext.extractSource(element), ex.getCause());
		}

		try {
			// 解析bean的scope
			parseScope(element, scanner);
		}
		catch (Exception ex) {
			parserContext.getReaderContext().error(ex.getMessage(), parserContext.extractSource(element), ex.getCause());
		}

		//
		parseTypeFilters(element, scanner, parserContext);

		return scanner;
	}

org.springframework.context.annotation.ComponentScanBeanDefinitionParser#createScanner

protected ClassPathBeanDefinitionScanner createScanner(XmlReaderContext readerContext, boolean useDefaultFilters) {
		return new ClassPathBeanDefinitionScanner(readerContext.getRegistry(), useDefaultFilters,
				readerContext.getEnvironment(), readerContext.getResourceLoader());
	}

org.springframework.context.annotation.ClassPathBeanDefinitionScanner#ClassPathBeanDefinitionScanner(org.springframework.beans.factory.support.BeanDefinitionRegistry, boolean, org.springframework.core.env.Environment, org.springframework.core.io.ResourceLoader)

	public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters,
			Environment environment, @Nullable ResourceLoader resourceLoader) {

		Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
		this.registry = registry;

		if (useDefaultFilters) {
			registerDefaultFilters();
		}
		setEnvironment(environment);
		setResourceLoader(resourceLoader);
	}

org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider#registerDefaultFilters

protected void registerDefaultFilters() {
		// 注册@Component类型的过滤器，只要带有这个注解的bean定义都会被扫描，也包括包装这个注解的注解
		this.includeFilters.add(new AnnotationTypeFilter(Component.class));
		ClassLoader cl = ClassPathScanningCandidateComponentProvider.class.getClassLoader();
		try {
			// @ManagedBean也会被扫描
			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 {
			// @Named也会被扫描
			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.
		}
	}

org.springframework.context.annotation.ComponentScanBeanDefinitionParser#parseBeanNameGenerator

protected void parseBeanNameGenerator(Element element, ClassPathBeanDefinitionScanner scanner) {
		//获取这个属性name-generator，如果没有指定beanName生成器就用AnnotationBeanNameGenerator这个
		if (element.hasAttribute(NAME_GENERATOR_ATTRIBUTE)) {
			BeanNameGenerator beanNameGenerator = (BeanNameGenerator) instantiateUserDefinedStrategy(
					element.getAttribute(NAME_GENERATOR_ATTRIBUTE), BeanNameGenerator.class,
					scanner.getResourceLoader().getClassLoader());
			scanner.setBeanNameGenerator(beanNameGenerator);
		}
	}

org.springframework.context.annotation.ComponentScanBeanDefinitionParser#parseScope

parseScope(element, scanner);

protected void parseScope(Element element, ClassPathBeanDefinitionScanner scanner) {
		// Register ScopeMetadataResolver if class name provided.
		// scope-resolver
		if (element.hasAttribute(SCOPE_RESOLVER_ATTRIBUTE)) {
			// scoped-proxy
			if (element.hasAttribute(SCOPED_PROXY_ATTRIBUTE)) {
				throw new IllegalArgumentException(
						"Cannot define both 'scope-resolver' and 'scoped-proxy' on <component-scan> tag");
			}
			ScopeMetadataResolver scopeMetadataResolver = (ScopeMetadataResolver) instantiateUserDefinedStrategy(
					element.getAttribute(SCOPE_RESOLVER_ATTRIBUTE), ScopeMetadataResolver.class,
					scanner.getResourceLoader().getClassLoader());
			scanner.setScopeMetadataResolver(scopeMetadataResolver);
		}

		if (element.hasAttribute(SCOPED_PROXY_ATTRIBUTE)) {
			String mode = element.getAttribute(SCOPED_PROXY_ATTRIBUTE);
			if ("targetClass".equals(mode)) {
				scanner.setScopedProxyMode(ScopedProxyMode.TARGET_CLASS);
			}
			else if ("interfaces".equals(mode)) {
				scanner.setScopedProxyMode(ScopedProxyMode.INTERFACES);
			}
			else if ("no".equals(mode)) {
				scanner.setScopedProxyMode(ScopedProxyMode.NO);
			}
			else {
				throw new IllegalArgumentException("scoped-proxy only supports 'no', 'interfaces' and 'targetClass'");
			}
		}
	}

parseTypeFilters(element, scanner, parserContext);

org.springframework.context.annotation.ComponentScanBeanDefinitionParser#parseTypeFilters

protected void parseTypeFilters(Element element, ClassPathBeanDefinitionScanner scanner, ParserContext parserContext) {
		// Parse exclude and include filter elements.
		ClassLoader classLoader = scanner.getResourceLoader().getClassLoader();
		NodeList nodeList = element.getChildNodes();
		for (int i = 0; i < nodeList.getLength(); i++) {
			Node node = nodeList.item(i);
			if (node.getNodeType() == Node.ELEMENT_NODE) {
				String localName = parserContext.getDelegate().getLocalName(node);
				try {
					// include-filter节点
					if (INCLUDE_FILTER_ELEMENT.equals(localName)) {
						TypeFilter typeFilter = createTypeFilter((Element) node, classLoader, parserContext);
						scanner.addIncludeFilter(typeFilter);
					}
					// exclude-filter节点
					else if (EXCLUDE_FILTER_ELEMENT.equals(localName)) {
						TypeFilter typeFilter = createTypeFilter((Element) node, classLoader, parserContext);
						scanner.addExcludeFilter(typeFilter);
					}
				}
				catch (ClassNotFoundException ex) {
					parserContext.getReaderContext().warning(
							"Ignoring non-present type filter class: " + ex, parserContext.extractSource(element));
				}
				catch (Exception ex) {
					parserContext.getReaderContext().error(
							ex.getMessage(), parserContext.extractSource(element), ex.getCause());
				}
			}
		}
	}

org.springframework.context.annotation.ComponentScanBeanDefinitionParser#createTypeFilter

protected TypeFilter createTypeFilter(Element element, @Nullable ClassLoader classLoader,
			ParserContext parserContext) throws ClassNotFoundException {
        // 获取type属性
		String filterType = element.getAttribute(FILTER_TYPE_ATTRIBUTE);
		//  获取expression属性
		String expression = element.getAttribute(FILTER_EXPRESSION_ATTRIBUTE);

		expression = parserContext.getReaderContext().getEnvironment().resolvePlaceholders(expression);
		//   注解类型
		if ("annotation".equals(filterType)) {
			return new AnnotationTypeFilter((Class<Annotation>) ClassUtils.forName(expression, classLoader));
		}
		//    指定类或接口的全名
		else if ("assignable".equals(filterType)) {
			return new AssignableTypeFilter(ClassUtils.forName(expression, classLoader));
		}
		// aspectj表达式
		else if ("aspectj".equals(filterType)) {
			return new AspectJTypeFilter(expression, classLoader);
		}
		// 正则表达式
		else if ("regex".equals(filterType)) {
			return new RegexPatternTypeFilter(Pattern.compile(expression));
		}
		// TypeFilter自定义实现
		else if ("custom".equals(filterType)) {
			Class<?> filterClass = ClassUtils.forName(expression, classLoader);
			if (!TypeFilter.class.isAssignableFrom(filterClass)) {
				throw new IllegalArgumentException(
						"Class is not assignable to [" + TypeFilter.class.getName() + "]: " + expression);
			}
			return (TypeFilter) BeanUtils.instantiateClass(filterClass);
		}
		else {
			throw new IllegalArgumentException("Unsupported filter type: " + filterType);
		}
	}

org.springframework.context.annotation.ClassPathBeanDefinitionScanner#doScan

	// 第五步: bean定义扫描
		Set<BeanDefinitionHolder> beanDefinitions = scanner.doScan(basePackages);

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) {
			//  解析scope的metadata信息
			Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
			for (BeanDefinition candidate : candidates) {
				ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
				candidate.setScope(scopeMetadata.getScopeName());
				//   解析beanName
				String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
				if (candidate instanceof AbstractBeanDefinition) {
					//  解析一般的bean定义属性
					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);
					//  注册bean定义
					registerBeanDefinition(definitionHolder, this.registry);
				}
			}
		}
		return beanDefinitions;
	}

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) {
			//  解析scope的metadata信息
			Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
			for (BeanDefinition candidate : candidates) {
				//   解析scope的metadata信息
				ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
				candidate.setScope(scopeMetadata.getScopeName());
				//   解析beanName
				String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
				if (candidate instanceof AbstractBeanDefinition) {
					//  解析一般的bean定义属性
					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);
					//  注册bean定义
					registerBeanDefinition(definitionHolder, this.registry);
				}
			}
		}
		return beanDefinitions;
	}

org.springframework.context.annotation.AnnotationBeanNameGenerator#generateBeanName

public String generateBeanName(BeanDefinition definition, BeanDefinitionRegistry registry) {

		if (definition instanceof AnnotatedBeanDefinition) {
			//      从注解中获取beanName
			String beanName = determineBeanNameFromAnnotation((AnnotatedBeanDefinition) definition);
			if (StringUtils.hasText(beanName)) {
				// Explicit bean name found.
				return beanName;
			}
		}
		// Fallback: generate a unique default bean name.
		return buildDefaultBeanName(definition, registry);
	}

org.springframework.context.annotation.AnnotationBeanNameGenerator#determineBeanNameFromAnnotation

protected String determineBeanNameFromAnnotation(AnnotatedBeanDefinition annotatedDef) {
		AnnotationMetadata amd = annotatedDef.getMetadata();
		Set<String> types = amd.getAnnotationTypes();
		String beanName = null;
		for (String type : types) {
			AnnotationAttributes attributes = AnnotationConfigUtils.attributesFor(amd, type);
			if (attributes != null && isStereotypeWithNameValue(type, amd.getMetaAnnotationTypes(type), attributes)) {
				Object value = attributes.get("value");
				if (value instanceof String) {
					String strVal = (String) value;
					if (StringUtils.hasLength(strVal)) {
						if (beanName != null && !strVal.equals(beanName)) {
							throw new IllegalStateException("Stereotype annotations suggest inconsistent " +
									"component names: '" + beanName + "' versus '" + strVal + "'");
						}
						beanName = strVal;
					}
				}
			}
		}
		//从注解配置中获取beanName
		return beanName;
	}

org.springframework.context.annotation.AnnotationBeanNameGenerator#buildDefaultBeanName(org.springframework.beans.factory.config.BeanDefinition, org.springframework.beans.factory.support.BeanDefinitionRegistry)

buildDefaultBeanName(definition, registry);

org.springframework.context.annotation.AnnotationBeanNameGenerator#buildDefaultBeanName(org.springframework.beans.factory.config.BeanDefinition)

// 默认生成的beanName是类的简单名称
	protected String buildDefaultBeanName(BeanDefinition definition) {
		String beanClassName = definition.getBeanClassName();
		Assert.state(beanClassName != null, "No bean class name set");
		String shortClassName = ClassUtils.getShortName(beanClassName);
		return Introspector.decapitalize(shortClassName);
	}

org.springframework.context.annotation.ClassPathBeanDefinitionScanner#postProcessBeanDefinition

//  解析一般的bean定义属性
postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);

org.springframework.context.annotation.AnnotationConfigUtils#processCommonDefinitionAnnotations(org.springframework.beans.factory.annotation.AnnotatedBeanDefinition)

public static void processCommonDefinitionAnnotations(AnnotatedBeanDefinition abd) {
		processCommonDefinitionAnnotations(abd, abd.getMetadata());
	}

static void processCommonDefinitionAnnotations(AnnotatedBeanDefinition abd, AnnotatedTypeMetadata metadata) {
		//    解析lazy注解
		AnnotationAttributes lazy = attributesFor(metadata, Lazy.class);
		if (lazy != null) {
			abd.setLazyInit(lazy.getBoolean("value"));
		}
		else if (abd.getMetadata() != metadata) {
			lazy = attributesFor(abd.getMetadata(), Lazy.class);
			if (lazy != null) {
				abd.setLazyInit(lazy.getBoolean("value"));
			}
		}

		//    获取Primary注解值
		if (metadata.isAnnotated(Primary.class.getName())) {
			abd.setPrimary(true);
		}
		//   解析DependsOn注解
		AnnotationAttributes dependsOn = attributesFor(metadata, DependsOn.class);
		if (dependsOn != null) {
			abd.setDependsOn(dependsOn.getStringArray("value"));
		}
       // 解析Role注解
		AnnotationAttributes role = attributesFor(metadata, Role.class);
		if (role != null) {
			abd.setRole(role.getNumber("value").intValue());
		}
		//        解析Description注解
		AnnotationAttributes description = attributesFor(metadata, Description.class);
		if (description != null) {
			// 获取value属性值
			abd.setDescription(description.getString("value"));
		}
	}

org/springframework/context/annotation/ClassPathBeanDefinitionScanner.java:292

definitionHolder =
							AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);

org.springframework.context.annotation.AnnotationConfigUtils#applyScopedProxyMode

static BeanDefinitionHolder applyScopedProxyMode(
			ScopeMetadata metadata, BeanDefinitionHolder definition, BeanDefinitionRegistry registry) {
		// 如果没有开启动态代理，直接返回bean定义
		ScopedProxyMode scopedProxyMode = metadata.getScopedProxyMode();
		if (scopedProxyMode.equals(ScopedProxyMode.NO)) {
			return definition;
		}
		//    如果是cglib动态代理
		boolean proxyTargetClass = scopedProxyMode.equals(ScopedProxyMode.TARGET_CLASS);
		// 创建动态代理
		return ScopedProxyCreator.createScopedProxy(definition, registry, proxyTargetClass);
	}

org.springframework.context.annotation.ComponentScanBeanDefinitionParser#parse

public BeanDefinition parse(Element element, ParserContext parserContext) {
		// 第一步: 获取base-package属性
		String basePackage = element.getAttribute(BASE_PACKAGE_ATTRIBUTE);
        // 第二步: 替换占位符
		basePackage = parserContext.getReaderContext().getEnvironment().resolvePlaceholders(basePackage);
		// 第三步: 分割包路径
		String[] basePackages = StringUtils.tokenizeToStringArray(basePackage,
				ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);

		// Actually scan for bean definitions and register them.
		// 第四步: 扫描bean定义注册
		ClassPathBeanDefinitionScanner scanner = configureScanner(parserContext, element);
		// 第五步: bean定义扫描
		Set<BeanDefinitionHolder> beanDefinitions = scanner.doScan(basePackages);
		// 第六步: 注册组件
		registerComponents(parserContext.getReaderContext(), beanDefinitions, element);

		return null;
	}


registerComponents(parserContext.getReaderContext(), beanDefinitions, element);

org.springframework.context.annotation.ComponentScanBeanDefinitionParser#registerComponents

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

		Object source = readerContext.extractSource(element);
		CompositeComponentDefinition compositeDef = new CompositeComponentDefinition(element.getTagName(), source);

		for (BeanDefinitionHolder beanDefHolder : beanDefinitions) {
			compositeDef.addNestedComponent(new BeanComponentDefinition(beanDefHolder));
		}

		// Register annotation config processors, if necessary.
		boolean annotationConfig = true;
		// 节点有annotation-config属性
		if (element.hasAttribute(ANNOTATION_CONFIG_ATTRIBUTE)) {
			annotationConfig = Boolean.valueOf(element.getAttribute(ANNOTATION_CONFIG_ATTRIBUTE));
		}
		if (annotationConfig) {
			// 注册注解解析器
			Set<BeanDefinitionHolder> processorDefinitions =
					AnnotationConfigUtils.registerAnnotationConfigProcessors(readerContext.getRegistry(), source);
			for (BeanDefinitionHolder processorDefinition : processorDefinitions) {
				compositeDef.addNestedComponent(new BeanComponentDefinition(processorDefinition));
			}
		}
         // 出发组件注册事件
		readerContext.fireComponentRegistered(compositeDef);
	}
享知
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
异常解决:错误:namespace element 'annotation-config' … on JDK 1.5 and higher
08-14
2. **XML配置问题**：确保你的Spring配置文件（如`applicationContext.xml`）正确包含了`<context:component-scan>`或`<context:annotation-config>`元素，它们是启用注解配置的关键。 3. **编译器设置**：检查你的...
第十章 Spring 配置元信息（Configuration Metadata）1
08-03
此外，`<context:annotation-config>`和`<context:component-scan>`分别用于启用注解驱动和扫描特定包下的@Component注解。 6. **基于Java注解装载配置元信息**：Java配置类通过`@Configuration`、`@Bean`等注解...
annotation-config和component-scan
weixin_33696822的博客
04-23 107
　　以前学到<context:annotation-config></context:annotation-config>和<context:component-scan base-package="" ></context:component-scan>和两个配置的时候，只知道，annotation-config是用来开启xml配置中的bean对注...
Spring配置中context:annotation-config VS context:component-scan
阿飞云漫步
07-30 2180
Spring 中在使用注解（Annotation）会涉及到< context:annotation-config> 和 < context:component-scan>配置，下面就对这两个配置进行诠释。
annotation-config 与 component-scan 标签
万物皆字节
06-19 338
标签解析入口 org.springframework.context.annotation.ComponentScanBeanDefinitionParser 主方法很简洁，如下 public BeanDefinition parse(Element element, ParserContext parserContext) { String[] basePackages = StringUtils.tokenizeToStringArray(element.getAttribute(B
Spring 开启Annotation <context:annotation-config> 和 <context:component-scan>诠释及区别
rznice的专栏
04-29 3286
<context:annotation-config> 和 <context:component-scan>的区别
annotation-driven,annotation-config,component-scan的区别与作用
赶路人儿
01-30 851
mvc:annotation-driven/> 相当于注册了DefaultAnnotationHandlerMapping和AnnotationMethodHandlerAdapter两个bean，配置一些messageconverter。即解决了@Controller注解的使用前提配置。 一般在springmvc项目中的spring-mvc.xml中配置。 =======
spring @Component注解原理解析
08-25
在 Spring 框架中，还有一个非常重要的配置文件，即 application.xml 文件，在这个文件中，我们可以使用 <context:annotation-config /> 元素来启用注解驱动的 Bean Discovery，例如： ```xml <context:annotation-...
关于Spring的spring-beans-xsd和tx-xsd aop-xsd等
07-31
它包括了如`<context:component-scan>`、`<context:annotation-config>`等元素，使得我们可以方便地启用注解驱动的配置和组件扫描，发现并自动装配带有特定注解的类。此外，它还支持消息源、AOP代理、事件监听等特性...
Spring的Annotation配置相关讲义
11-09
`<context:component-scan>`元素用于指定需要扫描的包，这样Spring会自动发现这些包下标记了如`@Component`、`@Service`、`@Repository`等注解的类，并将它们注册为Bean。 接着，我们看DAO层的配置。使用`@...
component-scan 和 annotation-config 配置
大龙的博客
11-22 1721
一、前沿 使用 SpringMVC 时，相信大家一定使用过<context:component-scan/> 和 <context:annotation-config/> 这两个配置，它们的作用到底是什么呢？它们之前的区别在哪？下面分别为大家分析一下 二、作用 <context:annotation-config/> ：用于激活哪些已经在 Spring...
annotation之context:annotation-config与 context:component-scan的区别与联系
林海静的博客
09-28 708
注解的作用基本有三个：1、生成文档：是java 最早提供的注解。常用的有 @see @param @return 等2、跟踪代码依赖性，实现替代配置文件功能：比较常见的是spring 2.5 开始的基于注解配置。作用就是减少配置。现在的框架基本都使用了这种配置来减少配置文件的数量。3、在编译时进行格式检查：如@override 放在方法前，如果你这个方法并不是覆盖了超类方法，则编译时就能检查出。 ...
@Component、@ComponentScan、@Configuration
qq_53021270的博客
05-05 525
1、@ComponentScan 这个是Spring的原生注解，主要用来指明哪些路径下的包要交给spring管理，注册到ioc容器中 在配置文件就相当于： context:componet-scan属性 <context:componet-scan base-package="com.sff.app" use-default-filters="true"> <!--不扫描@Controller注解的类--> <context:exclude-fi
第三章 component-scan&annotation-config>
qq_30561643的博客
09-29 95
component-scan&annotation-config> 他们之间的区别 context:annotation-config 他的作用是激活一下注解 @Resource @Autowired注解 <context:component-scan base-package=“com.ext”></context:component-scan> ba...
applicationContext.xml中<context:annotation-config> 和 <context:component-scan>的区别
阿O、不拽
08-14 176
Difference between &lt;context:annotation-config&gt; vs &lt;context:component-scan&gt;   &lt;context:annotation-config&gt; 是用于激活那些已经在spring容器里注册过的bean（无论是 通过xml的方式还是通过package sanning的方式）上面的注解。 &...
spring配置中annotation-config与component-scan区别
normol的博客
07-21 352
stackoverflow上相关问题连接自己总结如下： annotation-config对@Required, @Autowired etc 这类注解有效，但一定要注意的是，使用此类注解的bean一定是要在bean容器中注册过了的（比如xml中自定义的bean，或者后文提到的注解方式） Annotation config main job is to activate all the anno
spring注解annotation-config 和 component-scan的不同
oook
02-08 268
1.&lt;context:annotation-config/&gt;的作用：它是对已注册Bean的进行操作的配置，也就是说，Bean需要首先通过某种方式（比如Xml配置，或者其他注解）被注册，然后使用这个配置，可以对已注册的Bean进行进一步操作（比如注入到某个类的内部），也就是说，这个配置是用于“激活”已注册的Bean的，让已注册的Bean开始工作。 2.&lt;context:compon...
Spring MVC: <context:annotation-config> 和 <context:component-scan>区别
maoyeqiu的专栏
10-26 1904
在这篇文章中，我将介绍和标签的区别，将来再使用它们的时候能够清楚的知道你在干什么 首先，是用来激活已经在application context中注册的bean。注意，不管你使用那种注册的方式都是可以的，比如使用或者在application-context.xml中定义。 第二个区别是是由第一个差异导致的，它确实在context中注册beans，它也在beans内扫描注解并且激活他们，所以做了要
spring配置注解context:annotation-config和context:component-scan区别
qq_45869707的博客
09-07 96
详细看博客(13条消息) Spring配置中context:annotation-config VS context:component-scan_阿飞云-CSDN博客
context:annotation-config
最新发布
03-31
This element is typically used in conjunction with the component-scan element, which scans the classpath for annotated classes and registers them as Spring beans. The annotation-config element is ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值