【Spring源代码阅读之五】解析配置类的内部类、@PropertySource、@ComponentScan，处理@ImportResource注解
解析配置类的内部类、@PropertySource、@ComponentScan
- 导图
- ConfigurationClassParser#processMemberClasses
- ConfigurationClassParser#processPropertySource
- ConfigurationClassParser#addPropertySource
- MutablePropertySources#addBefore
- ComponentScanAnnotationParser#parse
- ClassPathBeanDefinitionScanner#doScan
- ClassPathScanningCandidateComponentProvider#findCandidateComponents
- ClassPathScanningCandidateComponentProvider#scanCandidateComponents
- isCandidateComponent
导图
ConfigurationClassParser#processMemberClasses
/**
* 处理配置类的内部类
*/
private void processMemberClasses(ConfigurationClass configClass, SourceClass sourceClass) throws IOException {
/**
* 获取配置类的内部类的SourceClass实例集合
*/
Collection<SourceClass> memberClasses = sourceClass.getMemberClasses();
/**
* 如果存在内部类，则对内部类进行解析
*/
if (!memberClasses.isEmpty()) {
/**
* 构建需要处理的集合
*/
List<SourceClass> candidates = new ArrayList<>(memberClasses.size());
/**
* 遍历所有的内部类，如果内部类是配置类，即配置了一些配置注解
* 并且内部类的列名和宿主类的类名不同时放入处理集合中
*/
for (SourceClass memberClass : memberClasses) {
if (ConfigurationClassUtils.isConfigurationCandidate(memberClass.getMetadata()) &&
!memberClass.getMetadata().getClassName().equals(configClass.getMetadata().getClassName())) {
candidates.add(memberClass);
}
}
/**
* 对需要处理的内部配置类集合进行排序
*/
OrderComparator.sort(candidates);
/**
* 对内部类进行处理
*/
for (SourceClass candidate : candidates) {
/**
* 如果import队列里面存在内部类宿主类，则证明宿主类正在等待处理或者正在处理
* 这时产生问题报告，此种情况是异常的
*/
if (this.importStack.contains(configClass)) {
this.problemReporter.error(new CircularImportProblem(configClass, this.importStack));
}
/**
* 否则的话就加入处理队列中并解析内部配置类
* 最后在处理队列中弹出处理完成的宿主类
* 这里注意宿主类
* class A{
* class B {
* class C {}
* }
* }
* B的宿主类是A，C的宿主类是B
* 这里实际上是一个递归调用，因为内部类也可能有内部类(这种情况很少)
* pop函数弹出的永远是最后处理内部类的宿主类
*/
else {
this.importStack.push(configClass);
try {
processConfigurationClass(candidate.asConfigClass(configClass));
}
finally {
this.importStack.pop();
}
}
}
}
}
ConfigurationClassParser#processPropertySource
/**
* 解析@PropertySource注解
*/
private void processPropertySource(AnnotationAttributes propertySource) throws IOException {
/**
* 获得name参数值
*/
String name = propertySource.getString("name");
if (!StringUtils.hasLength(name)) {
name = null;
}
/**
* 获得encoding参数值，编码格式
*/
String encoding = propertySource.getString("encoding");
if (!StringUtils.hasLength(encoding)) {
encoding = null;
}
/**
* 提取value属性，配置文本，并保证value属性有值，没有值则抛异常
*/
String[] locations = propertySource.getStringArray("value");
Assert.isTrue(locations.length > 0, "At least one @PropertySource(value) location is required");
/**
* 获取ignoreResourceNotFound值，是否忽略未找到的资源，默认是false
*/
boolean ignoreResourceNotFound = propertySource.getBoolean("ignoreResourceNotFound");
/**
* 获取属性源解析工厂，若没有指定则使用默认的
*/
Class<? extends PropertySourceFactory> factoryClass = propertySource.getClass("factory");
PropertySourceFactory factory = (factoryClass == PropertySourceFactory.class ?
DEFAULT_PROPERTY_SOURCE_FACTORY : BeanUtils.instantiateClass(factoryClass));
/**
* 遍历配置文本
*/
for (String location : locations) {
try {
/**
* 对配置文本中的$占位符做解析，替换成代表的值
*/
String resolvedLocation = this.environment.resolveRequiredPlaceholders(location);
/**
* 将配置文本指向的配置文件转化为属性源Resource对象
*/
Resource resource = this.resourceLoader.getResource(resolvedLocation);
/**
* 将属性源添加到环境中
*/
addPropertySource(factory.createPropertySource(name, new EncodedResource(resource, encoding)));
}
catch (IllegalArgumentException | FileNotFoundException | UnknownHostException ex) {
// Placeholders not resolvable or resource not found when trying to open it
if (ignoreResourceNotFound) {
if (logger.isInfoEnabled()) {
logger.info("Properties location [" + location + "] not resolvable: " + ex.getMessage());
}
}
else {
throw ex;
}
}
}
}
ConfigurationClassParser#addPropertySource
/**
* 将配置添加到容器中
*/
private void addPropertySource(PropertySource<?> propertySource) {
/**
* 获取配置名
*/
String name = propertySource.getName();
/**
* 获取容器环境中的配置
*/
MutablePropertySources propertySources = ((ConfigurableEnvironment) this.environment).getPropertySources();
/**
* 在容器环境中是否有同名的配置
*/
if (this.propertySourceNames.contains(name)) {
// We've already added a version, we need to extend it
/**
* 根据名称获取环境中的配置
*/
PropertySource<?> existing = propertySources.get(name);
/**
* 确定环境中的配置不为空
*/
if (existing != null) {
/**
* 这里暂时看不懂
*/
PropertySource<?> newSource = (propertySource instanceof ResourcePropertySource ?
((ResourcePropertySource) propertySource).withResourceName() : propertySource);
/**
* 如果环境中同名称的资源实现了CompositePropertySource接口，Spring则会将新加入的配置
* 作为首选，则之前的配置作为备选，具体可以查看addFirstPropertySource()方法，实际上里面
* 包含了一个List集合，Spring巧妙的将新的配置放置在0坐标上
*/
if (existing instanceof CompositePropertySource) {
((CompositePropertySource) existing).addFirstPropertySource(newSource);
}
/**
* 如果环境之前存在的配置不是复合配置，则转换成复合配置
*/
else {
/**
* 这里也暂时看不懂
*/
if (existing instanceof ResourcePropertySource) {
existing = ((ResourcePropertySource) existing).withResourceName();
}
/**
* 构建一个复合配置对象，实际上里面维护了一个List列表
* 然后放入配置，将新的配置放在第一位首选，之前存在于环境中的配置放在后面，作为备选
* 并且将环境中的配置替换为复合配置对象
*/
CompositePropertySource composite = new CompositePropertySource(name);
composite.addPropertySource(newSource);
composite.addPropertySource(existing);
propertySources.replace(name, composite);
}
return;
}
}
/**
* 如果环境中的配置名称是空的，则证明还没有配置放置到环境中，这时这个配置是最低优先级的配置
* 因为一旦有同名称新的配置加入的话，这个配置就成为备选配置了
*/
if (this.propertySourceNames.isEmpty()) {
propertySources.addLast(propertySource);
}
else {
/**
* 获取最低优先级的属性源名称
*/
String firstProcessed = this.propertySourceNames.get(this.propertySourceNames.size() - 1);
/**
* 将新加入的配置放到配置源列表中
*/
propertySources.addBefore(firstProcessed, propertySource);
}
this.propertySourceNames.add(name);
}
MutablePropertySources#addBefore
/**
* 添加新加入的属性源，他的搜索优先级高于相对属性源(相对属性源我的理解是默认属性源)
*/
public void addBefore(String relativePropertySourceName, PropertySource<?> propertySource) {
if (logger.isDebugEnabled()) {
logger.debug("Adding PropertySource '" + propertySource.getName() +
"' with search precedence immediately higher than '" + relativePropertySourceName + "'");
}
/**
* 判断他两个的属性源名称是否一致，如果一致的话则抛异常
*/
assertLegalRelativeAddition(relativePropertySourceName, propertySource);
/**
* 从属性源列表中删除这个属性，严谨判断，因为在之前的判断中都是使用的名称比较
*/
removeIfPresent(propertySource);
/**
* 获得相对属性源的坐标
*/
int index = assertPresentAndGetIndex(relativePropertySourceName);
/**
* 向指定坐标添加配置，相对属性源将向后移位
*/
addAtIndex(index, propertySource);
}
private void addAtIndex(int index, PropertySource<?> propertySource) {
removeIfPresent(propertySource);
this.propertySourceList.add(index, propertySource);
}
ComponentScanAnnotationParser#parse
/**
* 对ComponentScan中描述的包中的类进行扫描解析成BeanDefinition
* 本方法主要是对扫描器设置必要的配置，具体的扫描解析调用的是扫描器中的方法
*/
public Set<BeanDefinitionHolder> parse(AnnotationAttributes componentScan, final String declaringClass) {
/**
* 定义一个扫描器
*/
ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(this.registry,
componentScan.getBoolean("useDefaultFilters"), this.environment, this.resourceLoader);
/**
* 获取@ComponentScan注解中设置的BeanName生成器
*/
Class<? extends BeanNameGenerator> generatorClass = componentScan.getClass("nameGenerator");
boolean useInheritedGenerator = (BeanNameGenerator.class == generatorClass);
scanner.setBeanNameGenerator(useInheritedGenerator ? this.beanNameGenerator :
BeanUtils.instantiateClass(generatorClass));
/**
* 设置代理模型，关于web的设置
*/
ScopedProxyMode scopedProxyMode = componentScan.getEnum("scopedProxy");
if (scopedProxyMode != ScopedProxyMode.DEFAULT) {
scanner.setScopedProxyMode(scopedProxyMode);
}
else {
Class<? extends ScopeMetadataResolver> resolverClass = componentScan.getClass("scopeResolver");
scanner.setScopeMetadataResolver(BeanUtils.instantiateClass(resolverClass));
}
/**
* 设置符合扫描条件的类文件，即定义哪些类文件可以被扫描到
* 通过阅读@ComponentScan注解源码，内容就是"**\/*.class"就是哪些后缀名的文件可被扫描进来
*/
scanner.setResourcePattern(componentScan.getString("resourcePattern"));
/**
* 设置指定包下的类可被扫描进来的过滤器，这个属性将扫描的范围进一步缩小
*/
for (AnnotationAttributes filter : componentScan.getAnnotationArray("includeFilters")) {
for (TypeFilter typeFilter : typeFiltersFor(filter)) {
scanner.addIncludeFilter(typeFilter);
}
}
/**
* 设置指定包下的类不能被扫描进来的过滤器
*/
for (AnnotationAttributes filter : componentScan.getAnnotationArray("excludeFilters")) {
for (TypeFilter typeFilter : typeFiltersFor(filter)) {
scanner.addExcludeFilter(typeFilter);
}
}
/**
* 设置包下扫描到的类是否需要懒加载,默认不需要
*/
boolean lazyInit = componentScan.getBoolean("lazyInit");
if (lazyInit) {
scanner.getBeanDefinitionDefaults().setLazyInit(true);
}
/**
* 这里是解析扫描包的路径
* 注意：@ComponentScan注解中value属性值为扫描的包，这个属性是一个数组，可以给一个数组扫描多个包
* 还有一种方式为给一个字符串，通过分割符分割，以达到扫描多个包的目的，分割符Spring中默认的有逗号、分号和换行符
* 还有一种方式是给一个数组，数组中每个字符串又指定了多个包，只不过是以分隔符分割的
* 我们可以使用多种方式实现，Spring都能给你解析，放到basePackages集合中待处理
*/
Set<String> basePackages = new LinkedHashSet<>();
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);
}
/**
* 获取@ComponentScan注解的basePackageClasses属性，这个属性中放置的是类的Class，如果设置了这个属性
* Spring会将这个类所在包加到扫描包路径的集合中
* 也就是说，我们配置扫描包的路径时，可以给value属性设置路径，也可以在包路径下写一个类(只是一个空类，无逻辑)
* 把这个类给basePackageClasses属性，Spring会解析这个类的包路径加到扫描集合中待扫描
*/
for (Class<?> clazz : componentScan.getClassArray("basePackageClasses")) {
basePackages.add(ClassUtils.getPackageName(clazz));
}
/**
* 通过以上步骤后，需要进行待扫描包的集合中却没有需要扫描的包，此时，Spring会认为@ComponentScan注解中没有关于
* 需要扫描包的配置，那么Spring会将加了@ComponentScan注解类的所在包路径加到集合中待扫描
*/
if (basePackages.isEmpty()) {
basePackages.add(ClassUtils.getPackageName(declaringClass));
}
/**
* 无论扫描包的路径是什么，需要将配置了这个扫描包的类排除，因为这个类不需要再次被扫描进来
*/
scanner.addExcludeFilter(new AbstractTypeHierarchyTraversingFilter(false, false) {
@Override
protected boolean matchClassName(String className) {
return declaringClass.equals(className);
}
});
/**
* 调用扫描器的方法进行扫描
*/
return scanner.doScan(StringUtils.toStringArray(basePackages));
}
ClassPathBeanDefinitionScanner#doScan
/**
* 正式执行扫描包，注意的是，扫描出来的BeanDefinition已经在此方法中完成了注册到环境中
*/
protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
Assert.notEmpty(basePackages, "At least one base package must be specified");
/**
* 装载BeanDefinitionHolder集合
*/
Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>();
/**
* 循环包的路径依次扫描包
*/
for (String basePackage : basePackages) {
/**
* 扫描包下的类转换成BeanDefinition
*/
Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
/**
* 遍历扫描出来的BeanDefinition
*/
for (BeanDefinition candidate : candidates) {
/**
* 设置动态代理模式
*/
ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
candidate.setScope(scopeMetadata.getScopeName());
/**
* 根据Name生成器生成类名，一般是首字母小写
*/
String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
/**
* 如果BeanDefinition是AbstractBeanDefinition类型
* 则将@ComponentScan中设置的配置给到BeanDefinition中
* 这些配置是在ComponentScanAnnotationParser#parse()中初始化类扫描器后设置到扫描器中的全局变量中的
* 注意：这里是一定会进的，因为扫描出来的BeanDefinition是ScannedGenericBeanDefinition类型
*/
if (candidate instanceof AbstractBeanDefinition) {
postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
}
/**
* 如果BeanDefinition是AnnotatedBeanDefinition类型，则根据类上的注解设置信息
* 注意：这里的if和上面的if并不是排它关系，Spring会先设置全局值，如果类上再有注解
* 则注解的配置会覆盖扫描器全局配置，则对于类的BeanDefinition来说，
* 上面保证了扫描到的类的全局配置，这里保证了扫描到的类的个性化配置
*/
if (candidate instanceof AnnotatedBeanDefinition) {
AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
}
/**
* 判断BeanDefinition是否有加载冲突
*
*
*/
if (checkCandidate(beanName, candidate)) {
/**
* 构建一个BeanDefinitionHolder封装类封装信息
*/
BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
/**
* 获取此BeanDefinition的需要动态代理模型的Holder放到最终的集合中
* 如果此BeanDefinition不需要动态代理模型，则放入的是此BeanDefinition的Holder
*/
definitionHolder =
AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
beanDefinitions.add(definitionHolder);
/**
* 向DefaultListableBeanFactory工厂中注册BeanDefinition
*/
registerBeanDefinition(definitionHolder, this.registry);
}
}
}
return beanDefinitions;
}
ClassPathScanningCandidateComponentProvider#findCandidateComponents
/**
* 将包路径下的类扫描成BeanDefinition
*/
public Set<BeanDefinition> findCandidateComponents(String basePackage) {
if (this.componentsIndex != null && indexSupportsIncludeFilters()) {
return addCandidateComponentsFromIndex(this.componentsIndex, basePackage);
}
else {
return scanCandidateComponents(basePackage);
}
}
ClassPathScanningCandidateComponentProvider#scanCandidateComponents
/**
* 执行包的扫描操作
*/
private Set<BeanDefinition> scanCandidateComponents(String basePackage) {
/**
* 定义集合，用来存放扫描到并可以放到容器中的类
*/
Set<BeanDefinition> candidates = new LinkedHashSet<>();
try {
/**
* 定义扫描的全路径，即相对于系统的全路径(如果是Windows系统的话就包括盘符)
*/
String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
resolveBasePackage(basePackage) + '/' + this.resourcePattern;
/**
* 执行扫描操作，转换成一个个Resource对象，这个数组中是包含路径下所有的class文件的
* 注意：这里Spring使用的是ASM技术，此技术相当牛逼
*/
Resource[] resources = getResourcePatternResolver().getResources(packageSearchPath);
/**
* 获取日志的打印级别
*/
boolean traceEnabled = logger.isTraceEnabled();
boolean debugEnabled = logger.isDebugEnabled();
/**
* 遍历扫描出来的类
*/
for (Resource resource : resources) {
/**
* trace日志级别打印
*/
if (traceEnabled) {
logger.trace("Scanning " + resource);
}
/**
* 如果文件是可读的，就处理
*/
if (resource.isReadable()) {
try {
/**
* 获得类的元数据读取器
*/
MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource);
/**
* 判断元信息是否符合加载条件
*/
if (isCandidateComponent(metadataReader)) {
/**
* 通过构造函数构建一个BeanDefinition
*/
ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
sbd.setResource(resource);
sbd.setSource(resource);
/**
* 判断BeanDefinition是否符合Spring实例化的规则，即是否是可实例化的类
* 符合的话就加入到客家仔队列中
*/
if (isCandidateComponent(sbd)) {
if (debugEnabled) {
logger.debug("Identified candidate component class: " + resource);
}
candidates.add(sbd);
}
else {
if (debugEnabled) {
logger.debug("Ignored because not a concrete top-level class: " + resource);
}
}
}
else {
if (traceEnabled) {
logger.trace("Ignored because not matching any filter: " + resource);
}
}
}
catch (Throwable ex) {
throw new BeanDefinitionStoreException(
"Failed to read candidate component class: " + resource, ex);
}
}
else {
if (traceEnabled) {
logger.trace("Ignored because not readable: " + resource);
}
}
}
}
catch (IOException ex) {
throw new BeanDefinitionStoreException("I/O failure during classpath scanning", ex);
}
return candidates;
}
isCandidateComponent
/**
* 判断是否符合添加的条件，就是执行@ComponentScan注解中配置的excludeFilters排除条件和includeFilters加入条件
*/
protected boolean isCandidateComponent(MetadataReader metadataReader) throws IOException {
/**
* 如果程序员没有添加的话，此处会有一个excludeFilter，是在执行ComponentScanAnnotationParser#parse()中添加的
* 主要是过滤排除@ComponentScan注解类的重复加载
*/
for (TypeFilter tf : this.excludeFilters) {
if (tf.match(metadataReader, getMetadataReaderFactory())) {
return false;
}
}
/**
* 如果程序员没有添加并且@ComponentScan注解中useDefaultFilters属性为默认true的话
* 会包含一个Spring默认的加载过滤器，此时此处会有一个includeFilter，
* 是在执行ComponentScanAnnotationParser#parse()的83行
* 创建ClassPathBeanDefinitionScanner扫描器实例时经过调用链生成的，具体请看这个类的构造方法
*/
for (TypeFilter tf : this.includeFilters) {
if (tf.match(metadataReader, getMetadataReaderFactory())) {
return isConditionMatch(metadataReader);
}
}
return false;
}
ClassPathBeanDefinitionScanner构造方法
/**
* 构建了一个路径扫描成BeanDefinition的类
*/
public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters,
Environment environment, @Nullable ResourceLoader resourceLoader) {
Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
this.registry = registry;
/**
* 是否使用默认的过滤规则，@ComponentScan中是默认使用的
*/
if (useDefaultFilters) {
registerDefaultFilters();
}
setEnvironment(environment);
setResourceLoader(resourceLoader);
}
registerDefaultFilters
/**
* 配置默认的扫描规则
*/
protected void registerDefaultFilters() {
/**
* 添加一个包含过滤器，这里使用的是@Component注解，即扫描出来的类需要有此注解可加载到容器中
* 注意，@Controller、@Service、@Repository、@Configuration都含有此注解
*/
this.includeFilters.add(new AnnotationTypeFilter(Component.class));
ClassLoader cl = ClassPathScanningCandidateComponentProvider.class.getClassLoader();
/**
* 如果存在JSR-250或者JSR-330相关的包，则加入他们相关的包含过滤器
* 注解为@ManagedBean、@Named
*/
try {
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 {
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.
}
}