所有文章
https://www.cnblogs.com/lay2017/p/11478237.html
正文
上一篇文章，我们知道了解析过程将从解析main方法所在的主类开始。在文章的最后我们稍微看了一下ConfigurationClassParser这个解析器的parse方法
protected final void parse(AnnotationMetadata metadata, String beanName) throws IOException {
processConfigurationClass(new ConfigurationClass(metadata, beanName));
}
本文将从这个parse方法继续下去，看看解析main方法所在的主类这个过程主要发生了什么。
跟进processConfigurationClass方法
protected void processConfigurationClass(ConfigurationClass configClass) throws IOException {
//
// 由main方法所在的主类开始，向超类逐层向上递归解析
SourceClass sourceClass = asSourceClass(configClass);
do {
// 这里包含了解析单个配置类的核心逻辑
sourceClass = doProcessConfigurationClass(configClass, sourceClass);
} while (sourceClass != null);
//
}
我们注意到，doProcessConfigurationClass方法将会完成解析的主要工作，但是又会返回一个新的sourceClass用于解析。而这个新的sourceClass会是当前上一个sourceClass的父类。所在解析过程是一个递归过程，由主类开始，向超类逐层向上递归解析处理。
继续跟进doProcessConfigurationClass方法，我们看看这个核心的解析逻辑。代码量对较多，我们只关注两个点
1）@ComponentScan注解解析，扫描并注册BeanDefinition
2）获取超类向上递归
protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass)
throws IOException {
//
// 处理@ComponentScan注解
Set<AnnotationAttributes> componentScans = AnnotationConfigUtils.attributesForRepeatable(sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
if (!componentScans.isEmpty() &&
!this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
// 遍历@ComponentScan的属性值
for (AnnotationAttributes componentScan : componentScans) {
// 解析扫描
Set<BeanDefinitionHolder> scannedBeanDefinitions = this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
//
}
}
//
// 判断是否有超类
if (sourceClass.getMetadata().hasSuperClass()) {
String superclass = sourceClass.getMetadata().getSuperClassName();
if (superclass != null && !superclass.startsWith("java") &&
!this.knownSuperclasses.containsKey(superclass)) {
this.knownSuperclasses.put(superclass, configClass);
// 返回待解析的超类
return sourceClass.getSuperClass();
}
}
// 没有超类，则解析完毕
return null;
}
首先我们main方法所在的主类是被@SpringbootApplication注解所标注的，而@SpringbootApplication组合了@ComponentScan。所谓解析主类的时候将会处理@ComponentScan注解。解析@ComponentScan的主要工作的实现由ComponentScanAnnotationParser这个解析器来完成。通常这个解析器完成之后，被扫描到的BeanDefinition将会被注册到BeanFactory当中。
doProcessConfigurationClass方法的最后一部分是从当前被解析的类元数据中获取超类，如果超类存在且需要被解析那么就当做返回值返回回去，从而被外层的方法给递归处理。
@ComponentScan注解解析
下面，我们跟进ComponentScanAnnotationParser这个解析器的parse方法，看看@ComponentScan的处理过程
public Set<BeanDefinitionHolder> parse(
AnnotationAttributes componentScan,
final String declaringClass) {
ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(this.registry, componentScan.getBoolean("useDefaultFilters"), this.environment, this.resourceLoader);
//
Set<String> basePackages = new LinkedHashSet<>();
// 从basePackages配置获取扫描路径
String[] basePackagesArray = componentScan.getStringArray("basePackages");
for (String pkg : basePackagesArray) {
String[] tokenized = StringUtils.tokenizeToStringArray(this.environment.resolvePlaceholders(pkg),
ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
Collections.addAll(basePackages, tokenized);
}
// 从basePackageClasses获取扫描路径
for (Class<?> clazz : componentScan.getClassArray("basePackageClasses")) {
basePackages.add(ClassUtils.getPackageName(clazz));
}
if (basePackages.isEmpty()) {
// 默认添加当前被解析类的路径作为根路径
basePackages.add(ClassUtils.getPackageName(declaringClass));
}
//
// 扫描目标路径
return scanner.doScan(StringUtils.toStringArray(basePackages));
}
这里获取了一个扫描器，然后找到了待扫描的路径，最后利用扫描器去扫描路径。
跟进doScan方法
protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>();
for (String basePackage : basePackages) {
// 扫描获取BeanDefinition
Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
for (BeanDefinition candidate : candidates) {
//
if (checkCandidate(beanName, candidate)) {
BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
beanDefinitions.add(definitionHolder);
// 注册BeanDefinition到BeanFactory
registerBeanDefinition(definitionHolder, this.registry);
}
}
}
return beanDefinitions;
}
我们看到，findCandidateComponents方法将会根据扫描路径获取BeanDefinition，而扫描出来的BeanDefinition将会进入注册方法registerBeanDefinition。
我们先跟进findCandidateComponents方法看看如何扫描获取
public Set<BeanDefinition> findCandidateComponents(String basePackage) {
if (this.componentsIndex != null && indexSupportsIncludeFilters()) {
return addCandidateComponentsFromIndex(this.componentsIndex, basePackage);
} else {
// 进入
return scanCandidateComponents(basePackage);
}
}
再跟进scanCandidateComponents方法
private Set<BeanDefinition> scanCandidateComponents(String basePackage) {
Set<BeanDefinition> candidates = new LinkedHashSet<>();
try {
// 拼接出搜索路径，例如：classpath*:cn/lay/springbootlearn/**/*.class
String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX + resolveBasePackage(basePackage) + ‘/‘ + this.resourcePattern;
// 获取搜索路径下待处理资源
Resource[] resources = getResourcePatternResolver().getResources(packageSearchPath);
//
for (Resource resource : resources) {
//
if (resource.isReadable()) {
try {
MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource);
if (isCandidateComponent(metadataReader)) {
// 转化成BeanDefinition
ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
//
} else {
//
}
} catch (Throwable ex) {
//
}
} else {
//
}
}
} catch (IOException ex) {
//
}
return candidates;
}
basePackage将会被拼接成搜索路径，如：classpath*:cn/lay/springbootlearn/**/*.class。而getResources方法将会从搜索路径中获取相应的资源对象，这些资源对象并最终被读取并转化为BeanDefinition。
到这里，@ComponentScan扫描的Bean就已经成为了BeanDefinition，但是还有一步就是将BeanDefinition注册到BeanFactory当中。
我们回到doScan方法，并跟进registerBeanDefinition方法，看看注册过程
protected void registerBeanDefinition(BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry) {
BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, registry);
}
继续跟进registerBeanDefinition
public static void registerBeanDefinition(
BeanDefinitionHolder definitionHolder,
BeanDefinitionRegistry registry) throws BeanDefinitionStoreException {
String beanName = definitionHolder.getBeanName();
registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
// 省略
}
我们看到这里直接注册到了BeanDefinitionRegistry中去了，其实就是注册到BeanFactory当中。BeanFactory的默认实现类DefaultListableBeanFactory实现了BeanDefinitionRegistry，所以DefaultListableBeanFactory即是BeanDefinition的注册位置。
跟进DefaultListableBeanFactory的registerBeanDefinition方法
private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);
public void registerBeanDefinition(
String beanName,
BeanDefinition beanDefinition) throws BeanDefinitionStoreException {
//
if (existingDefinition != null) {
//
} else {
if (hasBeanCreationStarted()) {
// Cannot modify startup-time collection elements anymore (for stable iteration)
synchronized (this.beanDefinitionMap) {
this.beanDefinitionMap.put(beanName, beanDefinition);
//
}
} else {
//
}
//
}
//
}
最终，也就是将BeanDefinition添加到一个key-value的集合当中，这样就完成了注册工作。
总结
到这里，ioc容器refresh过程部分就结束了。我们略过不少东西，将解析主类、解析@ComponentScan扫描Bean定义、注册到BeanFactory这个主要的流程过了一遍。当然，在这里可能还存在一个比较困惑的点。前面的文章中，我们提过几次：配置 -> BeanDefinition -> Bean这样一个过程。ioc的refresh过程却只有从配置 -> BeanDefinition这样一个过程，那么BeanDefinition -> Bean这个过程又在哪里呢？后面ioc容器注入部分将说明这部分内容。
原文地址：https://www.cnblogs.com/lay2017/p/11504047.html