Spring源码情操陶冶-ComponentScanBeanDefinitionParser文件扫描解析器

context:component-scan

ComponentScanBeanDefinitionParser#私有属性

context:component-scan

private static final String BASE_PACKAGE_ATTRIBUTE = "base-package";

private static final String RESOURCE_PATTERN_ATTRIBUTE = "resource-pattern";

private static final String USE_DEFAULT_FILTERS_ATTRIBUTE = "use-default-filters";

private static final String ANNOTATION_CONFIG_ATTRIBUTE = "annotation-config";

private static final String NAME_GENERATOR_ATTRIBUTE = "name-generator";

private static final String SCOPE_RESOLVER_ATTRIBUTE = "scope-resolver";

private static final String SCOPED_PROXY_ATTRIBUTE = "scoped-proxy";

private static final String EXCLUDE_FILTER_ELEMENT = "exclude-filter";

private static final String INCLUDE_FILTER_ELEMENT = "include-filter";

private static final String FILTER_TYPE_ATTRIBUTE = "type";

private static final String FILTER_EXPRESSION_ATTRIBUTE = "expression";

ComponentScanBeanDefinitionParser#parse()-主方法

parse()

@Override
public BeanDefinition parse(Element element, ParserContext parserContext) {
//解析base-package属性值，扫描的包可以,;分隔
String[] basePackages = StringUtils.tokenizeToStringArray(element.getAttribute(BASE_PACKAGE_ATTRIBUTE),         ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);

// Actually scan for bean definitions and register them.
ClassPathBeanDefinitionScanner scanner = configureScanner(parserContext, element);
//通过ClassPathBeanDefinitionScanner扫描类来获取包名下的所有class并将他们注册到spring的bean工厂中
Set<BeanDefinitionHolder> beanDefinitions = scanner.doScan(basePackages);
//注册其他注解组件
registerComponents(parserContext.getReaderContext(), beanDefinitions, element);

return null;
}

ComponentScanBeanDefinitionParser#configureScanner()

ClassPathBeanDefinitionScanner#doScan()

ComponentScanBeanDefinitionParser#configureScanner()-创建扫描器

protected ClassPathBeanDefinitionScanner configureScanner(ParserContext parserContext, Element element) {
XmlReaderContext readerContext = parserContext.getReaderContext();
//默认使用spring自带的注解过滤
boolean useDefaultFilters = true;
//解析`use-default-filters`，类型为boolean
if (element.hasAttribute(USE_DEFAULT_FILTERS_ATTRIBUTE)) {
useDefaultFilters = Boolean.valueOf(element.getAttribute(USE_DEFAULT_FILTERS_ATTRIBUTE));
}

// Delegate bean definition registration to scanner class.
//此处如果`use-default-filters`为true，则添加`@Component`、`@Service`、`@Controller`、`@Repository`、`@ManagedBean`、`@Named`添加到includeFilters的集合过滤
ClassPathBeanDefinitionScanner scanner = createScanner(readerContext, useDefaultFilters);
scanner.setResourceLoader(readerContext.getResourceLoader());
scanner.setEnvironment(parserContext.getDelegate().getEnvironment());
scanner.setBeanDefinitionDefaults(parserContext.getDelegate().getBeanDefinitionDefaults());
scanner.setAutowireCandidatePatterns(parserContext.getDelegate().getAutowireCandidatePatterns());
//设置`resource-pattern`属性，扫描资源的模式匹配，支持正则表达式
if (element.hasAttribute(RESOURCE_PATTERN_ATTRIBUTE)) {
scanner.setResourcePattern(element.getAttribute(RESOURCE_PATTERN_ATTRIBUTE));
}

try {
//解析name-generator属性 beanName生成器
parseBeanNameGenerator(element, scanner);
}
catch (Exception ex) {
readerContext.error(ex.getMessage(), readerContext.extractSource(element), ex.getCause());
}

try {
//解析scope-resolver属性和scoped-proxy属性，但两者只可存在其一
//后者值为targetClass：cglib代理、interfaces：JDK代理、no：不使用代理
parseScope(element, scanner);
}
catch (Exception ex) {
readerContext.error(ex.getMessage(), readerContext.extractSource(element), ex.getCause());
}
//解析子节点`context:include-filter`、`context:exclude-filter`主要用于对扫描class类的过滤
//例如<context:include-filter type="annotation" expression="org.springframework.stereotype.Controller.RestController" />
parseTypeFilters(element, scanner, readerContext, parserContext);

return scanner;
}

ClassPathBeanDefinitionScanner#doScan()-扫描操作

protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
//表明base-package属性是需要被指定的
Assert.notEmpty(basePackages, "At least one base package must be specified");
Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<BeanDefinitionHolder>();
for (String basePackage : basePackages) {
//对每个基础包都进行扫描寻找并且对基础包下的所有class都注册为BeanDefinition
/**
**
**并对得到的candidates集合进行过滤，此处便用到include-filters和exclude-filters
*/
Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
for (BeanDefinition candidate : candidates) {
//解析一个bean的scope属性，代表作用范围
//prototype->每次请求都创建新的对象 singleton->单例模式，处理多请求
ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
candidate.setScope(scopeMetadata.getScopeName());
//使用beanName生成器生成
String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
/**
**对注册的bean进行另外的赋值处理，比如默认属性的配置
*返回的candidate类型为ScannedGenericBeanDefinition，下面两者
*条件满足
*/
if (candidate instanceof AbstractBeanDefinition) {
//设置lazy-init/autowire-code默认属性，从spring配置的<beans>节点属性读取
postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
}
if (candidate instanceof AnnotatedBeanDefinition) {
//读取bean上的注解，比如`@Lazy`、`@Dependson`的值设置相应的属性
AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
}
//查看是否已注册
if (checkCandidate(beanName, candidate)) {
BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
//默认采取cglib来做代理
definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
beanDefinitions.add(definitionHolder);
//注册bean信息到工厂中
registerBeanDefinition(definitionHolder, this.registry);
}
}
}
return beanDefinitions;
}

ClassPathScanningCandidateComponentProvider#findCandidateComponents

BeanDefinition

ClassPathScanningCandidateComponentProvider#findCandidateComponents()-找寻符合条件的资源文件

includeFilters

excludeFilters

public Set<BeanDefinition> findCandidateComponents(String basePackage) {
Set<BeanDefinition> candidates = new LinkedHashSet<BeanDefinition>();
try {
//值类似为classpath*:com/question/sky/**/*.class
String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +resolveBasePackage(basePackage) + "/" + this.resourcePattern;
//通过PathMatchingResourcePatternResolver来找寻资源
//常用的Resource为FileSystemResource
Resource[] resources = this.resourcePatternResolver.getResources(packageSearchPath);
boolean traceEnabled = logger.isTraceEnabled();
boolean debugEnabled = logger.isDebugEnabled();
for (Resource resource : resources) {

if (resource.isReadable()) {
try {
//生成MetadataReader对象->SimpleMetadataReader，内部包含AnnotationMetadataReadingVisitor注解访问处理类
MetadataReader metadataReader = this.metadataReaderFactory.getMetadataReader(resource);
//判断class是否不属于excludeFilters集合内但至少符合一个includeFilters集合
if (isCandidateComponent(metadataReader)) {
//包装为ScannedGenericBeanDefinition对象
ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
//保存文件资源
sbd.setResource(resource);
sbd.setSource(resource);
//判断class文件是否不为接口或者抽象类并且是独立的
if (isCandidateComponent(sbd)) {
//完成验证加入集合中
candidates.add(sbd);
}
}
}
catch (Throwable ex) {
throw new BeanDefinitionStoreException(
"Failed to read candidate component class: " + resource, ex);
}
}
}
}
catch (IOException ex) {
throw new BeanDefinitionStoreException("I/O failure during classpath scanning", ex);
}
return candidates;
}

protected boolean isCandidateComponent(MetadataReader metadataReader) throws IOException {
for (TypeFilter tf : this.excludeFilters) {
//满足excludeFilter集合中的一个便返回false，表示不对对应的beanDefinition注册
if (tf.match(metadataReader, this.metadataReaderFactory)) {
return false;
}
}
for (TypeFilter tf : this.includeFilters) {
//首先满足其中includeFilter集合中的一个
if (tf.match(metadataReader, this.metadataReaderFactory)) {
//判断对应的beanDifinition不存在@Conditional注解或者满足@Conditional中指定的条件，则返回true
//@Conditional注解的使用可自行查看相关资料
return isConditionMatch(metadataReader);
}
}
return false;
}

protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {
//非抽象类、接口类并且有独立特性[它是一个顶级类还是一个嵌套类(静态内部类)，可以独立于封闭类构造。]
return (beanDefinition.getMetadata().isConcrete() && beanDefinition.getMetadata().isIndependent());
}

ComponentScanBeanDefinitionParser#registerComponents-注册其他组件

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

Object source = readerContext.extractSource(element);
//包装为CompositeComponentDefinition对象，内置多ComponentDefinition对象
CompositeComponentDefinition compositeDef = new CompositeComponentDefinition(element.getTagName(), source);
//将已注册的所有beanDefinitionHolder对象放到上述对象中
for (BeanDefinitionHolder beanDefHolder : beanDefinitions) {
compositeDef.addNestedComponent(new BeanComponentDefinition(beanDefHolder));
}

// Register annotation config processors, if necessary.
boolean annotationConfig = true;
//获取annotation-config的属性值，默认为true
if (element.hasAttribute(ANNOTATION_CONFIG_ATTRIBUTE)) {
annotationConfig = Boolean.valueOf(element.getAttribute(ANNOTATION_CONFIG_ATTRIBUTE));
}
if (annotationConfig) {
//注册多个BeanPostProcessor接口，具体什么可自行查看，返回的是包含BeanPostProcessor接口的beanDefinitionHolder对象集合
Set<BeanDefinitionHolder> processorDefinitions = AnnotationConfigUtils.registerAnnotationConfigProcessors(readerContext.getRegistry(), source);
//继续装入CompositeComponentDefinition对象
for (BeanDefinitionHolder processorDefinition : processorDefinitions) {
compositeDef.addNestedComponent(new BeanComponentDefinition(processorDefinition));
}
}
//此处为空
readerContext.fireComponentRegistered(compositeDef);
}

@Configuration

@Configuration

@Autowired/@Value

@Required

@Resource

小结

context:component-scan

,;

@Component

**/*.class

scope-proxy

scope-resolver

context:component-scan

@Service

ConfigurationClassPostProcessor

@Configuration

AutowiredAnnotationBeanPostProcessor

@Autowired

@Value

RequiredAnnotationBeanPostProcessor

@Required

CommonAnnotationBeanPostProcessor

@Resource

PersistenceAnnotationBeanPostProcessor