1
@Configuration
2
// 核心：加载 classpath 下的 custom.properties 文件
3
// encoding = "UTF-8" 非常重要！否则中文会乱码
4
// value 可以为数组
5
@PropertySource(value = "classpath:custom.properties", encoding = "UTF-8")
6
public class MyConfig {
7

8
    // 加载进来后，就可以用 @Value 读取了
9
    @Value("${my.app.name}")
10
    private String appName;
11

12
    public void print() {
13
        System.out.println("加载到的应用名：" + appName);
14
    }
15
}

1
<dependency>
2
    <groupId>org.springframework.boot</groupId>
3
    <artifactId>spring-boot-starter-validation</artifactId>
4
</dependency>

1
@Data
2
@AllArgsConstructor
3
@NoArgsConstructor
4
public class Person {
5
    @NotNull(message = "classId 不能为空")
6
    private String classId;
7

8
    @Size(max = 33)
9
    @NotNull(message = "name 不能为空")
10
    private String name;
11

12
    @Pattern(regexp = "((^Man$|^Woman$|^UGM$))", message = "sex 值不在可选范围")
13
    @NotNull(message = "sex 不能为空")
14
    private String sex;
15

16
    @Email(message = "email 格式不正确")
17
    @NotNull(message = "email 不能为空")
18
    private String email;
19
}
20

21

22
@RestController
23
@RequestMapping("/api")
24
public class PersonController {
25
    @PostMapping("/person")
26
    public Result<Person> getPerson(@RequestBody @Valid Person person) {
27
        return Result.ok(person);
28
    }
29
}

1
@RestController
2
@RequestMapping("/api")
3
@Validated
4
public class PersonController {
5

6
    @GetMapping("/person/{id}")
7
    public Result<Integer> getPersonByID(
8
            @PathVariable("id")
9
            @Max(value = 5, message = "ID 不能超过 5")
10
            Integer id
11
    ) {
12
        return Result.ok(id);
13
    }
14

15
    @GetMapping("/person")
16
    public Result<String> findPersonByName(
17
            @RequestParam("name")
18
            @NotBlank(message = "姓名不能为空")
19
            @Size(max = 10, message = "姓名长度不能超过 10")
20
            String name
21
    ) {
22
        return Result.ok("Find the person : " + name);
23
    }
24
}

1
// ...
2
@SpringBootConfiguration
3
@EnableAutoConfiguration
4
@ComponentScan(
5
    excludeFilters = {@Filter(
6
    type = FilterType.CUSTOM,
7
    classes = {TypeExcludeFilter.class}
8
), @Filter(
9
    type = FilterType.CUSTOM,
10
    classes = {AutoConfigurationExcludeFilter.class}
11
)}
12
)
13
public @interface SpringBootApplication {
14
  // ...
15
}

1
// ...
2
@AutoConfigurationPackage
3
@Import({AutoConfigurationImportSelector.class})
4
public @interface EnableAutoConfiguration {
5
    String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";
6

7
    Class<?>[] exclude() default {};
8

9
    String[] excludeName() default {};
10
}

1
public class AutoConfigurationImportSelector implements DeferredImportSelector, ... {
2
  public String[] selectImports(AnnotationMetadata annotationMetadata) {
3
      if (!this.isEnabled(annotationMetadata)) {
4
          return NO_IMPORTS;
5
      } else {
6
          AutoConfigurationEntry autoConfigurationEntry = this.getAutoConfigurationEntry(annotationMetadata);
7
          return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
8
      }
9
  }
10

11
  // ...
12
}

1
AutoConfigurationEntry getAutoConfigurationEntry(AutoConfigurationMetadata autoConfigurationMetadata,
2
                                                  AnnotationMetadata annotationMetadata) {
3
    // 检查自动配置是否启用（enabled）
4
    // 如果注解 @EnableAutoConfiguration 被禁用（通过属性 spring.boot.enableautoconfiguration=false）
5
    // 就直接返回一个空的 AutoConfigurationEntry，不进行自动配置
6
    if (!this.isEnabled(annotationMetadata)) {
7
        return EMPTY_ENTRY;
8
    } else {
9
        // 获取 @EnableAutoConfiguration 的注解属性
10
        // 例如 exclude / excludeName 等，用于后续筛选候选自动配置类
11
        AnnotationAttributes attributes = this.getAttributes(annotationMetadata);
12

13
        // 获取候选的自动配置类列表
14
        // 主要从 META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports 文件读取
15
        // 这些类都是可能需要导入的自动配置类
16
        List<String> configurations = this.getCandidateConfigurations(annotationMetadata, attributes);
17

18
        // 对候选自动配置类进行处理
19
        // 去重，避免重复注册
20
        configurations = this.removeDuplicates(configurations);
21

22
        // 获取用户通过 exclude/excludeName 指定的排除类
23
        Set<String> exclusions = this.getExclusions(annotationMetadata, attributes);
24

25
        // 校验排除类是否合法，抛异常提示错误配置
26
        this.checkExcludedClasses(configurations, exclusions);
27

28
        // 从候选类列表中移除排除类
29
        configurations.removeAll(exclusions);
30

31
        // 根据条件注解（如 @ConditionalOnClass / @ConditionalOnMissingBean）过滤候选类
32
        configurations = this.filter(configurations, autoConfigurationMetadata);
33

34
        // 发布 AutoConfigurationImportEvent 事件，允许监听器获取导入和排除的类信息
35
        this.fireAutoConfigurationImportEvents(configurations, exclusions);
36

37
        // 返回最终的 AutoConfigurationEntry，包括最终导入的配置类和排除的类
38
        return new AutoConfigurationImportSelector.AutoConfigurationEntry(configurations, exclusions);
39
    }
40
}