【重写SpringFramework】配置类2：属性文件与组件扫描（chapter 3-6）属性文件和组件扫描都是对已有
1. 前言
本节我们继续讨论配置类解析中的两种情况，属性文件和组件扫描。在 beans 模块中，我们实现了 @Value 注解的功能，当时刻意忽略了环境变量中属性项的来源问题。通过 @PropertySource 注解的处理，可以把配置文件作为环境变量属性项的来源之一。组件扫描则是配置类集成了 ClassPathBeanDefinitionScanner 组件，通过 @ComponentScan 注解以声明的方式批量加载 Bean。
2. 属性文件
2.1 概述
属性文件是一种特殊的文件类型，后缀名为 .properties。属性文件的格式比较简单，每一行都是一个键值对，连接符为等号，比如 foo=bar。属性文件可以被解析成 java.util.Properties 类型，这是 Map 接口的实现类，其中键和值都是 String 类型。属性文件可以存放一些配置信息，比如数据库连接的配置。
url=jdbc:mysql:///spring-wheel
username=root
password=root
配置类通过 @PropertySource 注解来加载属性文件，然后解析属性文件中的键值对，并存放到环境变量中。我们可以在字段上声明 @Value 注解自动注入属性值，也可以通过调用 Enviroment 对象的 getProperty 方法，手动获得属性值。@PropertySource 注解有三个属性，如下所示：
value属性：指定多个属性文件的路径，必填项name属性：资源的描述信息，可以为空encoding属性：资源的编码格式，可以为空，解析时默认使用UTF-8编码
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface PropertySource {
String[] value();
String name() default "";
String encoding() default "";
}
2.2 代码实现
回到 ConfigurationClassParser 的 doProcessConfigurationClass 方法，在处理属性文件时，先检查配置类上是否声明了 @PropertySource 注解。只有声明了相关注解，才能调用 processPropertySource 方法进一步处理。接下来的操作可以分为三步，首先是加载资源，然后对资源进行解析，最后将各项属性值添加到环境变量中。
//所属类[cn.stimd.spring.context.annotation.ConfigurationClassParser]
//处理配置类
protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass) throws IOException {
//1. 处理内部类（略）
//2. 处理配置文件@PropertySource
AnnotationAttributes propertySource = AnnotationConfigUtils.attributesFor(metadata, PropertySource.class);
if(propertySource != null){
processPropertySource(propertySource);
}
}
第一步，先解析 @PropertySource 注解，主要是 value 属性，得到属性文件的路径。这是一个数组，需要进行遍历。在循环中使用 ResourceLoader 加载属性文件，得到一个 Resource 对象。之前讲过，Resource 接口是 Spring 对资源的统一抽象，此时的 Resource 对象还只是原始的二进制流，需要进一步处理。
//step-2 处理属性文件
private void processPropertySource(AnnotationAttributes attrs) throws IOException {
String name = attrs.getString("name");
if (!StringUtils.hasLength(name)) {
name = null;
}
String encoding = attrs.getString("encoding");
if (!StringUtils.hasLength(encoding)) {
encoding = null;
}
String[] locations = attrs.getStringArray("value");
for (String location : locations) {
String resolvedLocation = this.environment.resolveRequiredPlaceholders(location);
//1. 加载属性文件
Resource resource = this.resourceLoader.getResource(resolvedLocation);
//2. 将二进制流转换成Properties对象（以PropertySource接口的形式存在）
addPropertySource(this.propertySourceFactory.createPropertySource(name, new EncodedResource(resource, encoding)));
}
}
//将属性值添加到环境变量中
private void addPropertySource(org.springframework.core.env.PropertySource<?> propertySource) {
String name = propertySource.getName();
MutablePropertySources propertySources = ((ConfigurableEnvironment) this.environment).getPropertySources();
if(!propertySources.contains(name)){
//3. 将属性文件中的键值对添加到环境变量中
propertySources.addLast(propertySource);
}
}
第二步，我们需要将 Resource 对象转换成 org.springframework.core.env.PropertySource 对象。需要注意的是，PropertySource 接口是 Spring 核心包提供的，不要和本节出现的 @PropertySource 注解混为一谈。PropertySource 接口代表一组属性（配置项）的来源，这里指的是一个属性文件中的所有配置项。
转换的工作是由 PropertySourceFactory 的 createPropertySource 完成的，这是一个工厂方法，工厂类的实际类型为 DefaultPropertySourceFactory，工厂方法创建了 ResourcePropertySource 实例。在 ResourcePropertySource 的构造方法中，调用了工具类 PropertiesLoaderUtils 的 loaderProperties 方法，从这里可以看出，属性文件的字节流被解析成了 Properties 对象。
public class DefaultPropertySourceFactory implements PropertySourceFactory {
@Override
public PropertySource<?> createPropertySource(String name, EncodedResource resource) throws IOException {
return (name != null ? new ResourcePropertySource(name, resource) : new ResourcePropertySource(resource));
}
}
public class ResourcePropertySource extends PropertiesPropertySource {
public ResourcePropertySource(EncodedResource resource) throws IOException {
//将资源转换成Properties 形式
super(getNameForResource(resource.getResource()), PropertiesLoaderUtils.loadProperties(resource));
this.resourceName = null;
}
}
第三步，将 PropertySource 对象添加到环境变量 Enviroment 中。在使用时我们可以调用 Enviroment 的 getProperty 方法获取属性值，更简便的方法则是在字段上声明 @Value 注解。
2.3 流程分析
从图中可以看到，属性文件中的内容经过了三次形态的变换。首先是磁盘文件中的一组键值对，形式为 key=value，然后以 Resource 接口形式出现的字节流，接着以 PropertySource 接口形式出现的 Properties 对象，最后被添加到环境变量 Enviroment 中。
我们发现 ResourceLoader、PropertySourceFactory、Enviroment 这些组件都是 Spring 核心包提供的，@Value 注解则是在 beans 模块中已实现的功能。在属性文件的整个处理过程中，ConfigurationClassParser 只是利用现有的组件，以及自动装配的机制，完成了所有的操作。这是 Spring 的常规操作。很多独立的组件或功能分散在各个模块中。在某个比较复杂的操作中，充分利用已存在的组件和功能，以一定的方式组合起来，完成较为复杂的操作。这是 Spring 系统化和模块化思维的一种体现，我们已经介绍了很多示例，后续还会碰到更多的例子。
3. 组件扫描
3.1 概述
我们通过 ClassPathBeanDefinitionScanner 组件的 scan 方法扫描加载指定目录下的所有 Bean，这是编程式的操作，与之对应的 @ComponentScan 注解则是声明式的操作。@ComponentScan 注解最重要的工作是指定扫描的根目录，基本属性如下：
value属性：扫描的根路径，数组类型，可以指定多个扫描根路径basePackages属性：是value属性的别名，两者可以通用basePackageClasses属性：表示将指定类所在的目录作为扫描的根路径，数组类型，可以指定多个扫描根路径
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface ComponentScan {
@AliasFor("basePackages")
String[] value() default {};
@AliasFor("value")
String[] basePackages() default {};
Class<?>[] basePackageClasses() default {};
}
2.3 代码实现
首先检查配置类上是否声明了 @ComponentScan 注解，如果存在，则将具体解析过程交给 ComponentScanAnnotationParser 处理。我们先不管具体的解析过程，最终得到了一组 BeanDefinitionHolder 集合。在扫描加载的组件中，可能存在其他配置类，因此需要递归地调用 ConfigurationClassParser 的 parse 方法，对配置类进行解析。
class ConfigurationClassParser {
//用于处理@ComponentScan注解
private final ComponentScanAnnotationParser componentScanParser;
protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass) throws IOException {
//1. 处理内部类（略）
//2. 处理配置文件@PropertySource
//3. 组件扫描@ComponentScan
AnnotationAttributes componentScan = AnnotationConfigUtils.attributesFor(metadata, ComponentScan.class);
//TODO 条件判定相关（待实现）
if(componentScan != null){
Set<BeanDefinitionHolder> holders = this.componentScanParser.parse(componentScan, metadata.getClassName());
//检查扫描的组件中是否存在Configuration类，如果存在递归处理
for (BeanDefinitionHolder holder : holders) {
if(ConfigurationClassUtils.checkConfigurationClassCandidate(holder.getBeanDefinition(), this.metadataReaderFactory)){
parse(holder.getBeanDefinition().getBeanClassName(), holder.getBeanName());
}
}
}
}
}
在 ComponentScanAnnotationParser 的 parse 方法中，主要做了三件事，其中前两件可以看作准备工作。一是确定扫描的路径，二是添加排除规则，三是扫描和加载组件。具体步骤如下：
- 检查
@ComponentScan注解的basePackages和basePackageClasses属性，如果存在则将对应的路径添加到待扫描的路径集合中。如果没有指定这两个属性，则以声明类（也就是入参declaringClass）所在的目录作为扫描的根路径。 - 需要排除当前类，否则在组件扫描时会重复加载该类。
- 将实际的扫描和加载工作委托给
ClassPathBeanDefinitionScanner处理，该组件的实现已详细介绍过，不赘述。
public class ComponentScanAnnotationParser {
/**
* 解析@ComponnentScan注解，扫描并加载相关组件
* @param componentScan @ComponentScan注解上的属性信息
* @param declaringClass @ComponentScan注解所在的配置类的全类名
*/
public Set<BeanDefinitionHolder> parse(AnnotationAttributes componentScan, final String declaringClass) {
ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(this.registry, this.environment);
Set<String> basePackages = new LinkedHashSet<>();
//1. 指定需要扫描的路径
//1.1 处理basePackages
String[] basePackagesArray = componentScan.getStringArray("basePackages");
basePackages.addAll(Arrays.asList(basePackagesArray));
//1.2 处理basePackageClasses
for (Class<?> clazz : componentScan.getClassArray("basePackageClasses")) {
basePackages.add(ClassUtils.getPackageName(clazz));
}
//1.3 没有指定任何属性，则以声明类作为扫描路径
if(basePackages.isEmpty()){
basePackages.add(ClassUtils.getPackageName(declaringClass));
}
//2. 扫描时排除当前类
scanner.addExcludeFilter(new AbstractTypeHierarchyTraversingFilter(false, false) {
@Override
protected boolean matchClassName(String className) {
return declaringClass.equals(className);
}
});
//3. 扫描并加载组件
return scanner.doScan(StringUtils.toStringArray(basePackages));
}
}
4. 再论 Resource
本节所涉及的属性文件和扫描加载的组件，表面上看没有联系，实际上都是资源的不同表现形式。对于任意的资源来说，处理过程都可以分为三步，即加载资源、解析资源、使用资源。由于各种资源的形式和内容不尽相同，在具体细节的处理上也有所区别。
- 加载资源：对于字节码和 properties 文件来说，都以
Resource的形式加载到程序中 - 解析资源：字节码对应的资源被解析为注解元数据，properties 文件对应的资源为解析为
PropertySource - 使用资源：字节码文件最终被转换成
BeanDefinition注册到 Spring 容器中，properties 文件则作为环境变量的属性项存在
事实上，Spring 框架可以处理的资源远不止此，比如在 web 应用中，js、css 等静态资源以及 jsp 模板文件都被视为资源。我们可以根据上述总结举一反三，具体内容在第六章 webmvc 模块进行介绍。
5. 测试
5.1 属性文件处理
首先声明一个配置类，使用 @PropertySource 注解指定配置文件的路径。在配置类中声明字段，使用 @Value 注解来获取配置文件中的某个值。此外，配置文件 jdbc.properties 在第三节测试资源加载时已经存在。
//测试类
@Configuration
@PropertySource("jdbc.properties")
public class PropsConfig {
@Value("${url}")
private String url;
public String getUrl() {
return url;
}
}
测试方法比较简单，将配置类 PropsConfig 注册到 Spring 容器中即可。
//测试方法
@Test
public void testPropertySource(){
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(PropsConfig.class);
PropsConfig propsConfig = context.getBean("propsConfig", PropsConfig.class);
System.out.println("加载配置文件测试: " + propsConfig.getUrl());
}
从测试结果来看，配置文件得到了加载和解析，说明 @PropertySource 注解的处理是正常的。
加载配置文件测试: jdbc:mysql:///spring-wheel
5.2 组件扫描处理
在配置类上声明了 @ComponentScan 注解，指定扫描的根目录。
//测试类，指定组件扫描的根目录
@Configuration
@ComponentScan(basePackages = "context.basic")
public class PropsConfig {}
在测试方法中，扫描加载 UserController 和 UserService，并进行依赖解析。
//测试方法
@Test
public void testComponentScan(){
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(PropsConfig.class);
UserController userController = (UserController) context.getBean("userController");
System.out.println("组件扫描测试: " + userController.getUser());
}
从测试结果可以看到，指定目录下的组件都被加载到了 Spring 容器中，说明 @ComponentScan 注解起到了组件扫描的作用。
组件扫描测试: context.test.basic.User@6c3708b3
6. 总结
本节我们讨论配置类的两大功能，属性文件和组件扫描。属性文件的作用是以环境变量为中间桥梁，将配置文件中的属性项和依赖注入的字段联系起来，这样做的好处是避免了硬编码。比如我们可以通过配置文件来构建 JDBC 数据源。如果数据源发生改变，只需要修改配置文件即可，不需要对代码进行改动。
组件扫描也是非常重要的功能，用户定义的大多数组件都是通过这种方式加载的。需要注意的是，组件扫描加载的 Bean 可能是一个配置类，因此需要递归地进行解析。总的来说，属性文件和组件扫描的实现都是在已有功能的基础上进行整合。配置类实际上充当门面的角色，使得用户可以一站式地解决 Spring 应用配置相关的问题。
7. 项目结构
新增修改一览，新增（4），修改（3）。
context
└─ src
├─ main
│ └─ java
│ └─ cn.stimd.spring.context
│ └─ annotation
│ ├─ ComponentScan.java (+)
│ ├─ ComponentScanAnnotationParser.java (+)
│ ├─ ConfigurationClassParser.java (*)
│ ├─ ConfigurationClassUtils.java (*)
│ └─ PropertySource.java (+)
└─ test
└─ java
└─ context
└─ config
├─ ConfigTest.java (*)
└─ PropsConfig.java (+)
注：+号表示新增、*表示修改
注：项目的 master 分支会跟随教程的进度不断更新，如果想查看某一节的代码，请选择对应小节的分支代码。
欢迎关注公众号【Java编程探微】，加群一起讨论。
原创不易，觉得内容不错请关注、点赞、收藏。
转载自:https://juejin.cn/post/7404421025810087971