Spring组件扫描--源码跟踪
看这篇文章之前可以先了解之前的跟踪流程，https://www.jianshu.com/p/4934233f0ead
代码过宽，可以shift + 鼠标滚轮 左右滑动查看
这篇文章主要跟踪spring配置文件中component-scan标签，查看它是怎样被解析扫描生成对应的beanDefinition。
在applicationContext.xml中做以下配置：
<!-- 启动组件扫描，排除@Controller组件，该组件由SpringMVC配置文件扫描 -->
<context:component-scan base-package="cn.mrdear">
<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller" />
<context:exclude-filter type="annotation" expression="org.springframework.web.bind.annotation.RestController" />
</context:component-scan>
以DefaultBeanDefinitionDocumentReader类中的parseBeanDefinitions方法作为开始，向下跟踪。
/**
* Parse the elements at the root level in the document:
* "import", "alias", "bean".
*
* 解析在文档中根层级的元素："import", "alias", "bean".
*/
protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
//默认名称空间是"http://www.springframework.org/schema/beans"
//进入条件
if (delegate.isDefaultNamespace(root)) {
//获取根元素下的子Node，注意，Node不一定是子标签，可能是回车，可能是注释
NodeList nl = root.getChildNodes();
for (int i = 0; i < nl.getLength(); i++) {
Node node = nl.item(i);
if (node instanceof Element) {
//拿到了<beans>下的子标签
Element ele = (Element) node;
if (delegate.isDefaultNamespace(ele)) {
//如果该标签属于beans的名称空间，则进入这个方法
//xmlns="http://www.springframework.org/schema/beans"
parseDefaultElement(ele, delegate);
}
else {
//如果该标签属于其他的名称空间比如：context,aop等
//xmlns:aop="http://www.springframework.org/schema/aop"
//xmlns:context="http://www.springframework.org/schema/context"
delegate.parseCustomElement(ele);
}
}
}
}
else {
delegate.parseCustomElement(root);
}
}
对以上方法不太了解的可以先看下这篇文章：
https://www.jianshu.com/p/a0cfaedf3fc5
因为component-scan标签属于context名称空间，所以走这个方法。
delegate.parseCustomElement(ele);
这个方法的实现在BeanDefinitionParserDelegate类中
public BeanDefinition parseCustomElement(Element ele) {
return parseCustomElement(ele, null);
}
//containingBd入参传递为null
public BeanDefinition parseCustomElement(Element ele, BeanDefinition containingBd) {
//获取标签所属的名称空间
//http://www.springframework.org/schema/context
String namespaceUri = getNamespaceURI(ele);
//每个名称空间对应一个处理器，拿到对应context的处理器
NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
if (handler == null) {
error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", ele);
return null;
}
//进入这个方法
return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
}
虽然context对应的处理器是ContextNamespaceHandler，但实际上是调用其父类NamespaceHandlerSupport类中的parse方法。
/**
* Parses the supplied {@link Element} by delegating to the {@link BeanDefinitionParser} that is
* registered for that {@link Element}.
*
* 通过委派给BeanDefinitionParser来解析元素，并为该元素注册
*/
@Override
public BeanDefinition parse(Element element, ParserContext parserContext) {
return findParserForElement(element, parserContext).parse(element, parserContext);
}
先查看findParserForElement方法，此方法还是在NamespaceHandlerSupport类中。
/**
* Locates the {@link BeanDefinitionParser} from the register implementations using
* the local name of the supplied {@link Element}.
*
* 通过元素的部分名称，去从注册器实现中定位BeanDefinitionParser
*/
private BeanDefinitionParser findParserForElement(Element element, ParserContext parserContext) {
//拿到标签的名称（不包含名称空间）
//component-scan
String localName = parserContext.getDelegate().getLocalName(element);
//parsers是一个HashMap，
//在生成处理器的时候，会初始化一系列解析器，每一个解析器对应着一个标签名称
//以名称做key，解析器作为value，放入到parsers属性中
//这里可以通过标签名称拿到对应的解析器
BeanDefinitionParser parser = this.parsers.get(localName);
if (parser == null) {
parserContext.getReaderContext().fatal(
"Cannot locate BeanDefinitionParser for element [" + localName + "]", element);
}
return parser;
}
找到解析器后，调用解析器的parse方法。
parse(零)
这里的解析器是ComponentScanBeanDefinitionParser类，进入parse方法查看
/**
* 解析指定的Element，然后注册结果BeanDefinition到内嵌在ParserContext里的bean factory中。
*/
@Override
public BeanDefinition parse(Element element, ParserContext parserContext) {
//获取component-scan标签的base-package属性值
//cn.mrdear
String basePackage = element.getAttribute(BASE_PACKAGE_ATTRIBUTE);
//如果有占位符，则解析所有的占位符
basePackage = parserContext.getReaderContext().getEnvironment().resolvePlaceholders(basePackage);
//字符串中有" ,;\n\t"等符号就看做分隔符,分割成数组
String[] basePackages = StringUtils.tokenizeToStringArray(basePackage,
ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
// Actually scan for bean definitions and register them.
// 扫描bean definition 并注册它们
// 1.配置扫描器
ClassPathBeanDefinitionScanner scanner = configureScanner(parserContext, element);
// 2.利用扫描器扫描包，并注册bean definition
Set<BeanDefinitionHolder> beanDefinitions = scanner.doScan(basePackages);
// 3. 注册组件
registerComponents(parserContext.getReaderContext(), beanDefinitions, element);
return null;
}
1.configureScanner
跟踪标记1的方法
此方法在ComponentScanBeanDefinitionParser类中实现
// 1.配置扫描器
ClassPathBeanDefinitionScanner scanner = configureScanner(parserContext, element);
//进入方法
protected ClassPathBeanDefinitionScanner configureScanner(ParserContext parserContext, Element element) {
boolean useDefaultFilters = true;
//拿到component-scan标签的use-default-filters属性，没有配置则为true
if (element.hasAttribute(USE_DEFAULT_FILTERS_ATTRIBUTE)) {
useDefaultFilters = Boolean.valueOf(element.getAttribute(USE_DEFAULT_FILTERS_ATTRIBUTE));
}
// Delegate bean definition registration to scanner class.
// 1.1将bean definition的工厂委派给scanner类
ClassPathBeanDefinitionScanner scanner = createScanner(parserContext.getReaderContext(), useDefaultFilters);
//这里将阅读器上下文中拿到的根web应用上下文作为scanner的ResourceLoader，
//根web应用上下文默认实现为XmlWebApplicationContext，实现了ResourceLoader接口，
//所以可以作为ResourceLoader
scanner.setResourceLoader(parserContext.getReaderContext().getResourceLoader());
//初始化scanner时使用默认的StandardEnvironment作为environment，
//这里拿到了阅读器上下文中的environment，StandardServletEnvironment
//其实阅读器中的environment拿的是XmlWebApplicationContext的environment
scanner.setEnvironment(parserContext.getReaderContext().getEnvironment());
//获取代理类的defaults属性中，对标签属性的一些默认设置
scanner.setBeanDefinitionDefaults(parserContext.getDelegate().getBeanDefinitionDefaults());
//这里为null
scanner.setAutowireCandidatePatterns(parserContext.getDelegate().getAutowireCandidatePatterns());
//拿到component-scan标签的resource-pattern属性，这里没有设置
if (element.hasAttribute(RESOURCE_PATTERN_ATTRIBUTE)) {
scanner.setResourcePattern(element.getAttribute(RESOURCE_PATTERN_ATTRIBUTE));
}
try {
//1.2解析name-generator属性
parseBeanNameGenerator(element, scanner);
}
catch (Exception ex) {
parserContext.getReaderContext().error(ex.getMessage(), parserContext.extractSource(element), ex.getCause());
}
try {
//1.3解析Scope
parseScope(element, scanner);
}
catch (Exception ex) {
parserContext.getReaderContext().error(ex.getMessage(), parserContext.extractSource(element), ex.getCause());
}
//1.4解析类过滤器
parseTypeFilters(element, scanner, parserContext);
return scanner;
}
1.1 createScanner
跟踪标记1.1的方法
此方法在ComponentScanBeanDefinitionParser类中实现
// 1.1将bean definition的注册委派给scanner类
ClassPathBeanDefinitionScanner scanner = createScanner(parserContext.getReaderContext(), useDefaultFilters);
//入参传递了bean工厂，useDefaultFilters为true
protected ClassPathBeanDefinitionScanner createScanner(XmlReaderContext readerContext, boolean useDefaultFilters) {
return new ClassPathBeanDefinitionScanner(readerContext.getRegistry(), useDefaultFilters);
}
看下ClassPathBeanDefinitionScanner类的构造实现
//因为默认的工厂DefaultListableBeanFactory没有实现EnvironmentCapable接口
//所以重新创建了一个environment，与上下文的StandardServletEnvironment不同，
//这个environment是StandardEnvironment类型，在environment初始化的同时，会将
//systemProperties和systemEnvironment读取到environment内部
public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters) {
this(registry, useDefaultFilters, getOrCreateEnvironment(registry));
}
public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters, Environment environment) {
//调用了父类的构造
super(useDefaultFilters, environment);
Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
//拿到bean工厂的引用
this.registry = registry;
// Determine ResourceLoader to use.
// 默认bean工厂没有实现ResourceLoader接口，这里默认使用PathMatchingResourcePatternResolver
// 作为ResourceLoader
if (this.registry instanceof ResourceLoader) {
setResourceLoader((ResourceLoader) this.registry);
}
}
再进入父类构造中查看初始化了哪些属性
进入ClassPathScanningCandidateComponentProvider类中，查看对应的构造方法
public ClassPathScanningCandidateComponentProvider(boolean useDefaultFilters, Environment environment) {
//因为useDefaultFilters设置为了true，所以下面的方法会被调用
if (useDefaultFilters) {
registerDefaultFilters();
}
Assert.notNull(environment, "Environment must not be null");
//拿到先前新建的StandardEnvironment引用
this.environment = environment;
}
/**
* Register the default filter for {@link Component @Component}.
* <p>This will implicitly register all annotations that have the
* {@link Component @Component} meta-annotation including the
* {@link Repository @Repository}, {@link Service @Service}, and
* {@link Controller @Controller} stereotype annotations.
* <p>Also supports Java EE 6's {@link javax.annotation.ManagedBean} and
* JSR-330's {@link javax.inject.Named} annotations, if available.
*
* 为@Component注解注册默认的过滤器。
* 隐式的注册所有包含@Component元注解的注解，包括@Repository、@Service、@Controller
* 等老旧的注解。
* 也支持Java EE 6的javax.annotation.ManagedBean和JSR-330的javax.inject.Named注解
*/
@SuppressWarnings("unchecked")
protected void registerDefaultFilters() {
//includeFilters是一个LinkedList，存放注解类型过滤器，
//只有符合过滤器的注解类型才能生成bean definition
//1.1.1了解下AnnotationTypeFilter的构造实现，注解类型为Component
this.includeFilters.add(new AnnotationTypeFilter(Component.class));
//拿到该类的类加载器
ClassLoader cl = ClassPathScanningCandidateComponentProvider.class.getClassLoader();
try {
//1.1.2查看注解类型为ManagedBean的AnnotationTypeFilter构造实现
this.includeFilters.add(new AnnotationTypeFilter(
((Class<? extends Annotation>) ClassUtils.forName("javax.annotation.ManagedBean", cl)), false));
logger.debug("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注解同1.1.2，
//但是这里没有相关jar包，所以没有javax.inject.Named这个类，抛出异常，空捕获跳出
this.includeFilters.add(new AnnotationTypeFilter(
((Class<? extends Annotation>) ClassUtils.forName("javax.inject.Named", cl)), false));
logger.debug("JSR-330 'javax.inject.Named' annotation found and supported for component scanning");
}
catch (ClassNotFoundException ex) {
// JSR-330 API not available - simply skip.
}
}
1.1.1 AnnotationTypeFilter
跟踪标记1.1.1的方法
//1.1.1了解下AnnotationTypeFilter的构造实现
new AnnotationTypeFilter(Component.class)
/**
* Create a new AnnotationTypeFilter for the given annotation type.
* This filter will also match meta-annotations. To disable the
* meta-annotation matching, use the constructor that accepts a
* '{@code considerMetaAnnotations}' argument. The filter will
* not match interfaces.
*
* 通过给定的注解类型创建一个新的注解类型过滤器
* 这个过滤器还会匹配元注解
* 如果要禁用元注解匹配，可以使用接受considerMetaAnnotations参数的构造方法。
* 这个过滤器不会匹配接口
*/
public AnnotationTypeFilter(Class<? extends Annotation> annotationType) {
this(annotationType, true, false);
}
/**
* 注意上一层调用构造时的入参，默认considerMetaAnnotations为true，considerInterfaces为false
* 这说明注解中如果它的元注解匹配过滤器，那么也算是匹配。
* 过滤的时候不考虑是接口的情况
*/
public AnnotationTypeFilter(Class<? extends Annotation> annotationType, boolean considerMetaAnnotations, boolean considerInterfaces) {
//isAnnotationPresent方法是用来查看annotationType上是否有Inherited注解
//其boolean值赋值给父类AbstractTypeHierarchyTraversingFilter的属性considerInherited中
super(annotationType.isAnnotationPresent(Inherited.class), considerInterfaces);
this.annotationType = annotationType;
this.considerMetaAnnotations = considerMetaAnnotations;
}
1.1.2 AnnotationTypeFilter
跟踪标记1.1.2的方法
//1.1.2查看注解类型为ManagedBean的AnnotationTypeFilter构造实现
new AnnotationTypeFilter(
((Class<? extends Annotation>) ClassUtils.forName("javax.annotation.ManagedBean", cl)), false);
首先通过forName方法，拿到字符串javax.annotation.ManagedBean对应的Class，然后调用AnnotationTypeFilter的构造。
/**
* 上一层传参时considerMetaAnnotations为false，说明不用考虑注解上的元注解，这个注解不匹配过滤器就过滤掉
*/
public AnnotationTypeFilter(Class<? extends Annotation> annotationType, boolean considerMetaAnnotations) {
this(annotationType, considerMetaAnnotations, false);
}
//considerInterfaces依然为false
public AnnotationTypeFilter(Class<? extends Annotation> annotationType, boolean considerMetaAnnotations, boolean considerInterfaces) {
//ManagedBean的元注解上依然没有Inherited，所以considerInherited为false
super(annotationType.isAnnotationPresent(Inherited.class), considerInterfaces);
this.annotationType = annotationType;
this.considerMetaAnnotations = considerMetaAnnotations;
}
1.2 parseBeanNameGenerator
跟踪标记1.2的方法
在ComponentScanBeanDefinitionParser类中实现
//1.2解析name-generator属性
parseBeanNameGenerator(element, scanner);
protected void parseBeanNameGenerator(Element element, ClassPathBeanDefinitionScanner scanner) {
//component-scan标签的name-generator属性,这里没有设置，跳过
if (element.hasAttribute(NAME_GENERATOR_ATTRIBUTE)) {
BeanNameGenerator beanNameGenerator = (BeanNameGenerator) instantiateUserDefinedStrategy(
element.getAttribute(NAME_GENERATOR_ATTRIBUTE), BeanNameGenerator.class,
scanner.getResourceLoader().getClassLoader());
scanner.setBeanNameGenerator(beanNameGenerator);
}
}
1.3 parseScope
跟踪标记1.3的方法
在ComponentScanBeanDefinitionParser类中实现
//1.3 解析Scope
parseScope(element, scanner);
protected void parseScope(Element element, ClassPathBeanDefinitionScanner scanner) {
// Register ScopeMetadataResolver if class name provided.
// 如果类名被提供，则注册ScopeMetadataResolver
// 标签上有无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);
}
// 标签上有无scoped-proxy属性
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'");
}
}
}
1.4 parseTypeFilters
跟踪标记1.4的方法
在ComponentScanBeanDefinitionParser类中实现
//1.4解析类过滤器
parseTypeFilters(element, scanner, parserContext);
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 (Exception ex) {
parserContext.getReaderContext().error(
ex.getMessage(), parserContext.extractSource(element), ex.getCause());
}
}
}
}
跟踪createTypeFilter方法
protected TypeFilter createTypeFilter(Element element, ClassLoader classLoader, ParserContext parserContext) {
//获取标签上的type属性和expression属性对应的值
String filterType = element.getAttribute(FILTER_TYPE_ATTRIBUTE);
String expression = element.getAttribute(FILTER_EXPRESSION_ATTRIBUTE);
//expression可能带有占位符，如果有则解析占位符
expression = parserContext.getReaderContext().getEnvironment().resolvePlaceholders(expression);
try {
//xml文件中type填写的是annotation，所以走这个方法
if ("annotation".equals(filterType)) {
//将xml中的"org.springframework.stereotype.Controller"字符串解析为Class
//构造已经看过，默认considerMetaAnnotations为true，considerInterfaces为false
return new AnnotationTypeFilter((Class<Annotation>) classLoader.loadClass(expression));
}
else if ("assignable".equals(filterType)) {
return new AssignableTypeFilter(classLoader.loadClass(expression));
}
else if ("aspectj".equals(filterType)) {
return new AspectJTypeFilter(expression, classLoader);
}
else if ("regex".equals(filterType)) {
return new RegexPatternTypeFilter(Pattern.compile(expression));
}
else if ("custom".equals(filterType)) {
Class<?> filterClass = classLoader.loadClass(expression);
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);
}
}
catch (ClassNotFoundException ex) {
throw new FatalBeanException("Type filter class not found: " + expression, ex);
}
}
最后scanner的includeFilters属性中，默认添加了org.springframework.stereotype.Component的注解过滤器和javax.annotation.ManagedBean的注解过滤器。
scanner的excludeFilters属性中，自定义添加了xml配置文件中的org.springframework.stereotype.Controller注解过滤器和org.springframework.web.bind.annotation.RestController注解过滤器。
2.doScan
跟踪标记2的方法
此方法在ClassPathBeanDefinitionScanner类中实现
// 2.利用扫描器扫描包，并注册bean definition
Set<BeanDefinitionHolder> beanDefinitions = scanner.doScan(basePackages);
/**
* Perform a scan within the specified base packages,
* returning the registered bean definitions.
* <p>This method does <i>not</i> register an annotation config processor
* but rather leaves this up to the caller.
*
* 扫描指定包，返回被注册的bean definitions
* 这个方法不会注册annotation config processor，交由调用者处理
*/
protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
Assert.notEmpty(basePackages, "At least one base package must be specified");
Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<BeanDefinitionHolder>();
//根据配置，这里就只有一个"cn.mrdear"
for (String basePackage : basePackages) {
//2.1扫描候选者的class path
Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
for (BeanDefinition candidate : candidates) {
//2.2解析@scope注解
ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
candidate.setScope(scopeMetadata.getScopeName());
//2.3AnnotatedBeanDefinition的默认名称生成规则
String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
if (candidate instanceof AbstractBeanDefinition) {
//2.4给beanDefinition设置默认值、自动注入的候选者
postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
}
if (candidate instanceof AnnotatedBeanDefinition) {
//2.5拿到类上其他的context名称空间的注解，如果有的话，获取其value属性
AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
}
//2.6检查beanName是否正确匹配对应的bean Definition,该名称是否已经被注册
if (checkCandidate(beanName, candidate)) {
BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
//应用Scope代理模式
definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
beanDefinitions.add(definitionHolder);
//注册bean definition
registerBeanDefinition(definitionHolder, this.registry);
}
}
}
return beanDefinitions;
}
2.1 findCandidateComponents
跟踪标记2.1的方法
在ClassPathScanningCandidateComponentProvider类中实现
ClassPathScanningCandidateComponentProvider是ClassPathBeanDefinitionScanner的父类
//2.1扫描候选者的class path
Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
public Set<BeanDefinition> findCandidateComponents(String basePackage) {
Set<BeanDefinition> candidates = new LinkedHashSet<BeanDefinition>();
try {
//给包名添加上"classpath*:"的前缀和"**/*.class"的后缀
//最后结果：classpath*:cn/mrdear/**/*.class
String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
resolveBasePackage(basePackage) + "/" + this.resourcePattern;
//将包下的所有class文件用Resource的方式描述
//Resource--资源描述符
//里面的实现非常大，有兴趣可以自己看看。
//主要是将packageSearchPath分成classpath，包名，后缀名三部分进行处理，又根据有无*或者？
//等表达式，处理方式有所不同
Resource[] resources = this.resourcePatternResolver.getResources(packageSearchPath);
boolean traceEnabled = logger.isTraceEnabled();
boolean debugEnabled = logger.isDebugEnabled();
//对每个class进行处理
for (Resource resource : resources) {
if (traceEnabled) {
logger.trace("Scanning " + resource);
}
//是否非目录，可读
if (resource.isReadable()) {
try {
//这个metadataReader包含class文件中，类上的注解
//方法的注解，所使用注解的元注解等描述
//在获取metadataReader的同时，在CachingMetadataReaderFactory类的
//metadataReaderCache属性中存放了一份。此属性是LinkedHashMap
MetadataReader metadataReader = this.metadataReaderFactory.getMetadataReader(resource);
//2.1.1判断metadataReader能否通过注解类型过滤器过滤
if (isCandidateComponent(metadataReader)) {
//创建bean definition，拿到metadataReader的beanClass
//保存metadataReader的annotationMetadata的引用
ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
//取得资源描述符的引用
sbd.setResource(resource);
sbd.setSource(resource);
//2.1.2查看类是否具体且独立
if (isCandidateComponent(sbd)) {
if (debugEnabled) {
//确定候选组件class
logger.debug("Identified candidate component class: " + resource);
}
candidates.add(sbd);
}
else {
if (debugEnabled) {
//被忽略，不是一个具体的顶层class
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) {
//扫描类路径时IO异常
throw new BeanDefinitionStoreException("I/O failure during classpath scanning", ex);
}
//最后返回候选的bean definition
return candidates;
}
我这里返回的就只有两个类，加了@ControllerAdvice的GlobalException、加了@Service的BookServiceImpl。
其余的要么是接口，要么没被扫描，要么被过滤器过滤了，以下是我项目中所有class：
2.1.1 isCandidateComponent
跟踪标记2.1.1的方法
在ClassPathScanningCandidateComponentProvider类中实现
//2.1.1判断metadataReader能否通过注解类型过滤器过滤
isCandidateComponent(metadataReader)
/**
* Determine whether the given class does not match any exclude filter
* and does match at least one include filter.
*
* 不匹配任何exclude filter，至少匹配一个include filter.
* 才能确定其为候选人
*/
protected boolean isCandidateComponent(MetadataReader metadataReader) throws IOException {
for (TypeFilter tf : this.excludeFilters) {
//2.1.1.1跟踪match方法
//如果metadataReader中有注解匹配exclude过滤器的注解，则返回false
if (tf.match(metadataReader, this.metadataReaderFactory)) {
return false;
}
}
for (TypeFilter tf : this.includeFilters) {
//如果metadataReader中有注解匹配include过滤器的注解，则进入条件
if (tf.match(metadataReader, this.metadataReaderFactory)) {
//2.1.1.2是否有@Conditional注解，进行相关处理
return isConditionMatch(metadataReader);
}
}
return false;
}
过滤器中存放的都是AnnotationTypeFilter类型
TypeFilter是其顶层接口
match方法主要是在AbstractTypeHierarchyTraversingFilter抽象类中实现
2.1.1.1 match
跟踪标记2.1.1.1的方法
在AbstractTypeHierarchyTraversingFilter类中实现
//2.1.1.1跟踪match方法
tf.match(metadataReader, this.metadataReaderFactory)
@Override
public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory)
throws IOException {
// This method optimizes avoiding unnecessary creation of ClassReaders
// as well as visiting over those readers.
// 此方法做了优化，避免不必要的ClassReaders创建以及对它们的访问
// matchSelf方法判断metadataReader中相关class的注解有没有包含这个过滤器的注解
// 如果没有，但是过滤器的considerMetaAnnotations属性设置为true，
// 那么再判断class所有注解的元注解中，有没有包含这个过滤器的注解
// 有就返回true，进入条件
if (matchSelf(metadataReader)) {
return true;
}
ClassMetadata metadata = metadataReader.getClassMetadata();
// 默认返回false，不进入条件
if (matchClassName(metadata.getClassName())) {
return true;
}
//considerInherited这个属性前面跟踪的过滤器中都为false
//和过滤器的注解有关，其元注解包含Inherited，
//那么considerInherited属性就为true
if (this.considerInherited) {
if (metadata.hasSuperClass()) {
// Optimization to avoid creating ClassReader for super class.
Boolean superClassMatch = matchSuperClass(metadata.getSuperClassName());
if (superClassMatch != null) {
if (superClassMatch.booleanValue()) {
return true;
}
}
else {
// Need to read super class to determine a match...
try {
if (match(metadata.getSuperClassName(), metadataReaderFactory)) {
return true;
}
}
catch (IOException ex) {
logger.debug("Could not read super class [" + metadata.getSuperClassName() +
"] of type-filtered class [" + metadata.getClassName() + "]");
}
}
}
}
//considerInterfaces属性在AnnotationTypeFilter构造器中都默认被设置为false
if (this.considerInterfaces) {
for (String ifc : metadata.getInterfaceNames()) {
// Optimization to avoid creating ClassReader for super class
Boolean interfaceMatch = matchInterface(ifc);
if (interfaceMatch != null) {
if (interfaceMatch.booleanValue()) {
return true;
}
}
else {
// Need to read interface to determine a match...
try {
if (match(ifc, metadataReaderFactory)) {
return true;
}
}
catch (IOException ex) {
logger.debug("Could not read interface [" + ifc + "] for type-filtered class [" +
metadata.getClassName() + "]");
}
}
}
}
return false;
}
2.1.1.2 isConditionMatch
跟踪标记2.1.1.2的方法
在ClassPathScanningCandidateComponentProvider类中实现
//2.1.1.2是否有@Conditional注解，进行相关处理
isConditionMatch(metadataReader);
/**
* Determine whether the given class is a candidate component based on any
* {@code @Conditional} annotations.
*
* 确定指定类是否是基于任何@Conditional注解的候选组件
*/
private boolean isConditionMatch(MetadataReader metadataReader) {
if (this.conditionEvaluator == null) {
this.conditionEvaluator = new ConditionEvaluator(getRegistry(), getEnvironment(), getResourceLoader());
}
//跟踪这个方法
return !this.conditionEvaluator.shouldSkip(metadataReader.getAnnotationMetadata());
}
于是进入ConditionEvaluator的shouldSkip方法
/**
* 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})
*
* 根据@Conditional注解确定一个子项是否应该被跳过
* 从子项的类型可以推导ConfigurationPhase，比如@Configuration class就是
* ConfigurationPhase#PARSE_CONFIGURATION--解析配置
*/
public boolean shouldSkip(AnnotatedTypeMetadata metadata) {
return shouldSkip(metadata, null);
}
//这个方法就不跟了，如果要了解condition注解的用法，可以详细了解该方法
public boolean shouldSkip(AnnotatedTypeMetadata metadata, 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 = 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();
}
if (requiredPhase == null || requiredPhase == phase) {
if (!condition.matches(this.context, metadata)) {
return true;
}
}
}
return false;
}
2.1.2 isCandidateComponent
跟踪标记2.1.2的方法
在ClassPathScanningCandidateComponentProvider类中实现
//2.1.2查看类是否具体且独立
isCandidateComponent(sbd)
/**
* Determine whether the given bean definition qualifies as candidate.
* <p>The default implementation checks whether the class is concrete
* (i.e. not abstract and not an interface). Can be overridden in subclasses.
*
* 确定bean definition qualifies能否作为候选
* 默认实现会检查class是否具体（不是抽象、不是接口）。可以被子类覆盖
*/
protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {
//看下这两个判断的含义
return (beanDefinition.getMetadata().isConcrete() && beanDefinition.getMetadata().isIndependent());
}
//不能是接口和抽象类
public boolean isConcrete() {
return !(this.isInterface || this.isAbstract);
}
//要么是顶层class，要么是被嵌套的class（静态内部类）,但是被嵌套的class必须能够从
//封闭的class中独立构造，才能说明此class是独立的。
public boolean isIndependent() {
//没有封闭的class或者是独立的内部类
return (this.enclosingClassName == null || this.independentInnerClass);
}
2.2 resolveScopeMetadata
跟踪标记2.2的方法
在AnnotationScopeMetadataResolver类中实现
//2.2解析@scope注解
ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
/**
* Resolve the {@link ScopeMetadata} appropriate to the supplied
* bean {@code definition}.
* <p>Implementations can of course use any strategy they like to
* determine the scope metadata, but some implementations that spring
* immediately to mind might be to use source level annotations
* present on {@link BeanDefinition#getBeanClassName() the class} of the
* supplied {@code definition}, or to use metadata present in the
* {@link BeanDefinition#attributeNames()} of the supplied {@code definition}.
*
* 解析适用于BeanDefinition的ScopeMetadata
* 实现当然可以使用任何喜欢的策略去确定scope metadata，但是spring的实现立马
* 想到的是使用source level注解在BeanDefinition对应的class上
* 或者将metadata存放于BeanDefinition的属性中
*/
public ScopeMetadata resolveScopeMetadata(BeanDefinition definition) {
//默认单例，无代理
ScopeMetadata metadata = new ScopeMetadata();
if (definition instanceof AnnotatedBeanDefinition) {
AnnotatedBeanDefinition annDef = (AnnotatedBeanDefinition) definition;
//拿到指定类上的@scope注解的所有属性
AnnotationAttributes attributes = AnnotationConfigUtils.attributesFor(
annDef.getMetadata(), this.scopeAnnotationType);
if (attributes != null) {
metadata.setScopeName(attributes.getString("value"));
ScopedProxyMode proxyMode = attributes.getEnum("proxyMode");
if (proxyMode == null || proxyMode == ScopedProxyMode.DEFAULT) {
proxyMode = this.defaultProxyMode;
}
metadata.setScopedProxyMode(proxyMode);
}
}
return metadata;
}
2.3 generateBeanName
跟踪标记2.3的方法
在AnnotationBeanNameGenerator类中实现
//2.3AnnotatedBeanDefinition的默认名称生成规则
String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
public String generateBeanName(BeanDefinition definition, BeanDefinitionRegistry registry) {
if (definition instanceof AnnotatedBeanDefinition) {
//先进入这个方法查看
String beanName = determineBeanNameFromAnnotation((AnnotatedBeanDefinition) definition);
if (StringUtils.hasText(beanName)) {
// Explicit bean name found.
// 发现明确bean Name
return beanName;
}
}
// Fallback: generate a unique default bean name.
// 回退：生成一个唯一的默认beanName
return buildDefaultBeanName(definition, registry);
}
/**
* Derive a bean name from one of the annotations on the class.
*
* 从类上的一个注解中，派生出bean name
*/
protected String determineBeanNameFromAnnotation(AnnotatedBeanDefinition annotatedDef) {
AnnotationMetadata amd = annotatedDef.getMetadata();
//嘉定拿的是org.springframework.web.bind.annotation.ControllerAdvice
Set<String> types = amd.getAnnotationTypes();
String beanName = null;
for (String type : types) {
//拿到@ControllerAdvice上的所有的属性
AnnotationAttributes attributes = AnnotationConfigUtils.attributesFor(amd, type);
//将@ControllerAdvice注解名，@ControllerAdvice的元注解，@ControllerAdvice上的属性
//当做参数传递
//进入这个方法
if (isStereotypeWithNameValue(type, amd.getMetaAnnotationTypes(type), attributes)) {
//获取注解上的value属性对应的值
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 + "'");
}
//用value属性对应的值作为beanName
beanName = strVal;
}
}
}
}
return beanName;
}
/**
* Check whether the given annotation is a stereotype that is allowed
* to suggest a component name through its annotation {@code value()}.
*
* 检查注解是不是stereotype类型，如果是的话，可以用注解的value()属性，作为组件名称
*/
protected boolean isStereotypeWithNameValue(String annotationType,
Set<String> metaAnnotationTypes, Map<String, Object> attributes) {
//注解是不是stereotype类型，主要看他是不是component注解、ManagedBean注解或者Named注解
//或者注解的元注解包含component注解
boolean isStereotype = annotationType.equals(COMPONENT_ANNOTATION_CLASSNAME) ||
(metaAnnotationTypes != null && metaAnnotationTypes.contains(COMPONENT_ANNOTATION_CLASSNAME)) ||
annotationType.equals("javax.annotation.ManagedBean") ||
annotationType.equals("javax.inject.Named");
//是stereotype类型，且有value属性的注解，返回true
return (isStereotype && attributes != null && attributes.containsKey("value"));
}
上面看了beanDefinition是AnnotatedBeanDefinition类型情况下，beanName怎样生成。但是如果class上的stereotype注解，没有给value属性赋值，那么又是怎样生成beanName的？
查看其默认的beanName生成方式：
buildDefaultBeanName(definition, registry);
此方法的实现还是在AnnotationBeanNameGenerator类中：
/**
* Derive a default bean name from the given bean definition.
* <p>The default implementation delegates to {@link #buildDefaultBeanName(BeanDefinition)}.
*
* 从给定的bean definition派生一个默认bean Name
*/
protected String buildDefaultBeanName(BeanDefinition definition, BeanDefinitionRegistry registry) {
return buildDefaultBeanName(definition);
}
/**
* Derive a default bean name from the given bean definition.
* <p>The default implementation simply builds a decapitalized version
* of the short class name: e.g. "mypackage.MyJdbcDao" -> "myJdbcDao".
* <p>Note that inner classes will thus have names of the form
* "outerClassName.InnerClassName", which because of the period in the
* name may be an issue if you are autowiring by name.
*
* 默认的实现是构建一个首字母小写（像变量一样的命名方式）的简短类名。
* 注意内部类因此会是这样的格式"outerClassName.InnerClassName"
* 如果通过名称自动注入，中间的点就可能引发问题
*/
protected String buildDefaultBeanName(BeanDefinition definition) {
//cn.mrdear.exception.GlobalException => GlobalException
String shortClassName = ClassUtils.getShortName(definition.getBeanClassName());
//此方法将字符串首字符大写转小写，但是如果第二个字符也是大写就不进行转换，因为他可能是
//这样的格式--> "URL"
return Introspector.decapitalize(shortClassName);
}
2.4 postProcessBeanDefinition
跟踪标记2.4的方法
在ClassPathBeanDefinitionScanner类中实现
//2.4给beanDefinition设置默认值，自动注入的候选者
postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
/**
* Apply further settings to the given bean definition,
* beyond the contents retrieved from scanning the component class.
*
* 除从组件class扫描检索的内容外，应用更多的设置到bean definition
*/
protected void postProcessBeanDefinition(AbstractBeanDefinition beanDefinition, String beanName) {
//扫描器中的Defaults应用到beanDefinition中
beanDefinition.applyDefaults(this.beanDefinitionDefaults);
if (this.autowireCandidatePatterns != null) {
//设置自动注入候选者
beanDefinition.setAutowireCandidate(PatternMatchUtils.simpleMatch(this.autowireCandidatePatterns, beanName));
}
}
2.5 processCommonDefinitionAnnotations
跟踪标记2.5的方法
在AnnotationConfigUtils类中实现
//2.5拿到类上其他的context名称空间的注解，如果有的话，获取其value属性
AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
public static void processCommonDefinitionAnnotations(AnnotatedBeanDefinition abd) {
processCommonDefinitionAnnotations(abd, abd.getMetadata());
}
static void processCommonDefinitionAnnotations(AnnotatedBeanDefinition abd, AnnotatedTypeMetadata metadata) {
//类上是否有Lazy注解，或者注解的元注解上有Lazy注解
if (metadata.isAnnotated(Lazy.class.getName())) {
//拿到@Lazy注解上的所有属性，获取其value属性的值
abd.setLazyInit(attributesFor(metadata, Lazy.class).getBoolean("value"));
}
//metadata不属于abd的情况
else if (abd.getMetadata() != metadata && abd.getMetadata().isAnnotated(Lazy.class.getName())) {
abd.setLazyInit(attributesFor(abd.getMetadata(), Lazy.class).getBoolean("value"));
}
//类上是否有Primary注解，或者注解的元注解上有Primary注解
if (metadata.isAnnotated(Primary.class.getName())) {
abd.setPrimary(true);
}
//类上是否有DependsOn注解，或者注解的元注解上有DependsOn注解
if (metadata.isAnnotated(DependsOn.class.getName())) {
//拿到@DependsOn注解上的所有属性，获取其value属性的值
abd.setDependsOn(attributesFor(metadata, DependsOn.class).getStringArray("value"));
}
if (abd instanceof AbstractBeanDefinition) {
AbstractBeanDefinition absBd = (AbstractBeanDefinition) abd;
//类上是否有Role注解，或者注解的元注解上有Role注解
if (metadata.isAnnotated(Role.class.getName())) {
//拿到@Role注解上的所有属性，获取其value属性的值
absBd.setRole(attributesFor(metadata, Role.class).getNumber("value").intValue());
}
//类上是否有Description注解，或者注解的元注解上有Role注解
if (metadata.isAnnotated(Description.class.getName())) {
//拿到@Description注解上的所有属性，获取其value属性的值
absBd.setDescription(attributesFor(metadata, Description.class).getString("value"));
}
}
}
2.6 checkCandidate
跟踪标记2.6的方法
在ClassPathBeanDefinitionScanner类中实现
//2.6检查beanName是否正确匹配对应的bean Definition,该名称是否已经被注册
checkCandidate(beanName, candidate)
protected boolean checkCandidate(String beanName, BeanDefinition beanDefinition) throws IllegalStateException {
//工厂中没有注册这个beanName，返回true
if (!this.registry.containsBeanDefinition(beanName)) {
return true;
}
BeanDefinition existingDef = this.registry.getBeanDefinition(beanName);
BeanDefinition originatingDef = existingDef.getOriginatingBeanDefinition();
if (originatingDef != null) {
existingDef = originatingDef;
}
//如果已存在的和入参的beanDefinition能够兼容，就返回false，否则抛出异常
if (isCompatible(beanDefinition, existingDef)) {
return false;
}
throw new ConflictingBeanDefinitionException("Annotation-specified bean name '" + beanName +
"' for bean class [" + beanDefinition.getBeanClassName() + "] conflicts with existing, " +
"non-compatible bean definition of same name and class [" + existingDef.getBeanClassName() + "]");
}
3.registerComponents
跟踪标记3的方法
此方法在ComponentScanBeanDefinitionParser类中实现
// 3. 注册组件
registerComponents(parserContext.getReaderContext(), beanDefinitions, element);
protected void registerComponents(
XmlReaderContext readerContext, Set<BeanDefinitionHolder> beanDefinitions, Element element) {
//这里返回的是null
Object source = readerContext.extractSource(element);
//拿到组合组件定义对象，以完整标签名做为name
CompositeComponentDefinition compositeDef = new CompositeComponentDefinition(element.getTagName(), source);
for (BeanDefinitionHolder beanDefHolder : beanDefinitions) {
//分两部分看
//3.1bean组件定义的构造初始化
//将创建好的BeanComponentDefinition放入到组合组件定义的nestedComponents中
//nestedComponents是一个LinkedList
compositeDef.addNestedComponent(new BeanComponentDefinition(beanDefHolder));
}
// Register annotation config processors, if necessary.
// 如果必要的话，注册注解配置处理器
boolean annotationConfig = true;
//拿到component-scan标签的annotation-config属性
if (element.hasAttribute(ANNOTATION_CONFIG_ATTRIBUTE)) {
//默认设置为true
annotationConfig = Boolean.valueOf(element.getAttribute(ANNOTATION_CONFIG_ATTRIBUTE));
}
if (annotationConfig) {
//3.2查看怎么注册注解配置处理器
Set<BeanDefinitionHolder> processorDefinitions =
AnnotationConfigUtils.registerAnnotationConfigProcessors(readerContext.getRegistry(), source);
for (BeanDefinitionHolder processorDefinition : processorDefinitions) {
//如果有为被注册的处理器，注册完成后再添加到组合组件定义中
compositeDef.addNestedComponent(new BeanComponentDefinition(processorDefinition));
}
}
//这里空实现
readerContext.fireComponentRegistered(compositeDef);
}
3.1 BeanComponentDefinition
跟踪标记3.1的方法
进入BeanComponentDefinition的构造方法
//3.1bean组件定义的构造初始化
new BeanComponentDefinition(beanDefHolder)
public BeanComponentDefinition(BeanDefinitionHolder holder) {
//先看父类构造做了什么操作
super(holder);
//找到这个class中，属性为注册到工厂中的bean deifiniion或者BeanReference的集合
findInnerBeanDefinitionsAndBeanReferences(holder.getBeanDefinition());
}
/**
* 其实BeanComponentDefinition就是BeanDefinitionHolder的子类
*
* Copy constructor: Create a new BeanDefinitionHolder with the
* same contents as the given BeanDefinitionHolder instance.
* <p>Note: The wrapped BeanDefinition reference is taken as-is;
* it is {@code not} deeply copied.
*
* 复制构造：利用给定的beanDefinitionHolder实例，创建一个新的BeanDefinitionHolder
*/
public BeanDefinitionHolder(BeanDefinitionHolder beanDefinitionHolder) {
Assert.notNull(beanDefinitionHolder, "BeanDefinitionHolder must not be null");
this.beanDefinition = beanDefinitionHolder.getBeanDefinition();
this.beanName = beanDefinitionHolder.getBeanName();
this.aliases = beanDefinitionHolder.getAliases();
}
然后再了解下findInnerBeanDefinitionsAndBeanReferences方法做了什么事情
private void findInnerBeanDefinitionsAndBeanReferences(BeanDefinition beanDefinition) {
List<BeanDefinition> innerBeans = new ArrayList<BeanDefinition>();
List<BeanReference> references = new ArrayList<BeanReference>();
PropertyValues propertyValues = beanDefinition.getPropertyValues();
//拿到类中所有的属性值，如果属性为在bean工厂中注册的bean definition、或者
//有BeanReference--非实体bean只是逻辑上的引用，则放入集合
for (int i = 0; i < propertyValues.getPropertyValues().length; i++) {
PropertyValue propertyValue = propertyValues.getPropertyValues()[i];
Object value = propertyValue.getValue();
if (value instanceof BeanDefinitionHolder) {
innerBeans.add(((BeanDefinitionHolder) value).getBeanDefinition());
}
else if (value instanceof BeanDefinition) {
innerBeans.add((BeanDefinition) value);
}
else if (value instanceof BeanReference) {
references.add((BeanReference) value);
}
}
this.innerBeanDefinitions = innerBeans.toArray(new BeanDefinition[innerBeans.size()]);
this.beanReferences = references.toArray(new BeanReference[references.size()]);
}
3.2 registerAnnotationConfigProcessors
跟踪标记3.2的方法
进入AnnotationConfigUtils的构造方法
//3.2查看怎么注册注解配置处理器
Set<BeanDefinitionHolder> processorDefinitions =
AnnotationConfigUtils.registerAnnotationConfigProcessors(readerContext.getRegistry(), source);
/**
* Register all relevant annotation post processors in the given registry.
*
* 注册所有相关的注解后处理器到指定工厂中
*/
public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
BeanDefinitionRegistry registry, Object source) {
DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
if (beanFactory != null) {
//bean工厂的依赖比较器不是AnnotationAwareOrderComparator的实例，
//就换成AnnotationAwareOrderComparator
if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
}
//bean工厂的自动注入候选解析器不是ContextAnnotationAutowireCandidateResolver的实例，
//就换成ContextAnnotationAutowireCandidateResolver
if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
}
}
Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<BeanDefinitionHolder>(4);
//工厂中没有注册internalConfigurationAnnotationProcessor，则注册
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));
}
//工厂中没有注册internalAutowiredAnnotationProcessor，则注册
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));
}
//工厂中没有注册internalRequiredAnnotationProcessor，则注册
if (!registry.containsBeanDefinition(REQUIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition(RequiredAnnotationBeanPostProcessor.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, REQUIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
}
// Check for JSR-250 support, and if present add the CommonAnnotationBeanPostProcessor.
// 检查是否支持JSR-250，如果有则添加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.
// 检查JPA支持，如果有则添加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));
}
//工厂中没有注册internalEventListenerProcessor，则注册
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));
}
//工厂中没有注册internalEventListenerFactory，则注册
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;
}
到这里也就跟踪完了。
其实还有很多种情况没有分析，只能先把握整体的脉络，遇到具体的情况再做具体分析。
总结
- 获取标签
context:component-scan上的base-package属性，有占位符的进行解析，并切分为数组形式 - 1.配置扫描器
- 2.利用扫描器扫描包，注册 BeanDefinition
- 3.注册组件
——————————————————————————————————
- 1
- 创建一个扫描器，默认情况下会注册几个过滤器，其实就是在扫描器的 includeFilters 属性中保存几个 AnnotationTypeFilter 类型的过滤器，其中包括注解
Component。 - 解析子标签
context:exclude-filter和context:exclude-filter，根据子标签上的 type 属性创建不同的类型过滤器。并添加到扫描器的 excludeFilters 属性或 includeFilters 属性中。 - 添加其他属性等
——————————————————————————————————
- 2
- 遍历所有的
base-package，通过base-package获取 Resource 对象数组，对符合条件的 Resource 组装成 BeanDefinition ，并将 BeanDefinition 集合返回。条件：不匹配 excludeFilters 中的过滤器，匹配 includeFilters 的过滤器的同时，如果有@Conditional注解需要满足限制。 - 解析
@Scope等注解以及元注解，设置属性 - 包装 BeanDefinition 生成 DefinitionHolder，注册 BeanDefinition 和别名到工厂中，返回 DefinitionHolder 集合
——————————————————————————————————
- 3
- 新建一个扫描组件，添加标签名，并把 DefinitionHolder 集合包装后一一放入到组件中
- 如果有没被注册的后处理器，注册到工厂后再添加到扫描组件中
Spring组件扫描--源码跟踪的更多相关文章
- spring security 认证源码跟踪
spring security 认证源码跟踪 在跟踪认证源码之前,我们先根据官网说明一下security的内部原理,主要是依据一系列的filter来实现,大家可以根据https://docs.sp ...
- Spring组件BeanDefinition 源码解析
BeanDefinition 继承图 继承的接口 BeanMetadataElement接口 将由承载配置源对象的bean元数据元素的类实现. 包含一个getSource的方法,可以获取到MetaDa ...
- spring security之 默认登录页源码跟踪
spring security之 默认登录页源码跟踪 2021年的最后2个月,立个flag,要把Spring Security和Spring Security OAuth2的应用及主流程源码研究透 ...
- spring security 授权方式(自定义)及源码跟踪
spring security 授权方式(自定义)及源码跟踪 这节我们来看看spring security的几种授权方式,及简要的源码跟踪.在初步接触spring security时,为了实现它的 ...
- spring security 之自定义表单登录源码跟踪
上一节我们跟踪了security的默认登录页的源码,可以参考这里:https://www.cnblogs.com/process-h/p/15522267.html 这节我们来看看如何自定义单表认 ...
- Spring IOC 容器源码分析
声明!非原创,本文出处 Spring 最重要的概念是 IOC 和 AOP,本篇文章其实就是要带领大家来分析下 Spring 的 IOC 容器.既然大家平时都要用到 Spring,怎么可以不好好了解 S ...
- Spring IOC 容器源码分析(转)
原文地址 Spring 最重要的概念是 IOC 和 AOP,本篇文章其实就是要带领大家来分析下 Spring 的 IOC 容器.既然大家平时都要用到 Spring,怎么可以不好好了解 Spring 呢 ...
- Feign 系列（05）Spring Cloud OpenFeign 源码解析
Feign 系列(05)Spring Cloud OpenFeign 源码解析 [TOC] Spring Cloud 系列目录(https://www.cnblogs.com/binarylei/p/ ...
- Spring IOC容器源码分析
注:本文转自https://javadoop.com/post/spring-ioc Spring 最重要的概念是 IOC 和 AOP,本篇文章其实就是要带领大家来分析下 Spring 的 IOC 容 ...
随机推荐
- 【网寻】mui - 点击事件
//本来是需要这样的,结果点击无响应 $(".mui-control-item").on("click",function(event){ alert(1) } ...
- 获取当前表中的最大自增id的下一个自增id值
SELECT auto_increment FROM information_schema.`TABLES` WHERE TABLE_SCHEMA='{$db_name}' AND TABLE_NAM ...
- 夯实Java基础系列目录
自进入大学以来,学习的编程语言从最初的C语言.C++,到后来的Java,. NET.而在学习编程语言的同时也逐渐决定了以后自己要学习的是哪一门语言(Java).到现在为止,学习Java语言也有很长一段 ...
- Laravel 验证 教程
英文源文章: https://www.techiediaries.com/laravel-authentication-tutorial/ 在上一篇教程中,我们已经接触过Laravel,同时介绍了最新 ...
- SpringMvc 视图解析器常见功能、类型转换、格式化
springmvc.xml <?xml version="1.0" encoding="UTF-8"?> <beans xmlns=" ...
- .net工作流设计器
源码地址 Github: https://github.com/chengderen/Smartflow-Sharp 简要说明 https://www.smartflow-sharp.com/doc. ...
- Qt编译Curl
1.下载Curl,下载地址:https://curl.haxx.se/download.html,windows下载.zip压缩包,解压到E盘. 2.在”开始菜单“—>”所有程序“->”Q ...
- JS中，跨域调用（本地）另一个项目的方法
IP地址,因为是本地的项目,所以我一开始写的是127.0.0.1...,但不对.应该写本机的IP地址才对!
- JS垂直落体回弹原理
/* *JS垂直落体回弹原理 */ <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" " ...
- 3.Sprint 代理对象与原始对象的异常错误
代码案例分析 Service层添加了注解@Transactional @Service @Transactional public class CustomerService extends Base ...