AutoConfigurationImportSelector
AutoConfigurationImportSelector 类实现 DeferredImportSelector接口，在项目启动过程中，会自动调用其 selectImports 方法，找出需要自动注入的类信息，下面将对其执行过程进行简要分析。
selectImports
该方法比较简单，主要核心逻辑在 getAutoConfigurationEntry 中。
public String[] selectImports(AnnotationMetadata annotationMetadata) {
// 判断是否需要进行自动注册
if (!isEnabled(annotationMetadata)) {
return NO_IMPORTS;
}
// 获取自动配置的元数据
AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader
.loadMetadata(this.beanClassLoader);
AutoConfigurationEntry autoConfigurationEntry = getAutoConfigurationEntry(autoConfigurationMetadata,
annotationMetadata);
return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
}
protected boolean isEnabled(AnnotationMetadata metadata) {
// 判断当前类是否是 AutoConfigurationImportSelector
if (getClass() == AutoConfigurationImportSelector.class) {
// 判断 spring.boot.enableautoconfiguration 配置是否为 true
return getEnvironment().getProperty(EnableAutoConfiguration.ENABLED_OVERRIDE_PROPERTY, Boolean.class, true);
}
return true;
}
getAutoConfigurationEntry
该方法主要是获取自动配置的信息，主要包含需要注入的以及需要排除掉的类信息，主要过程如下：
protected AutoConfigurationEntry getAutoConfigurationEntry(AutoConfigurationMetadata autoConfigurationMetadata,
AnnotationMetadata annotationMetadata) {
// 判断是否需要进行自动注入
if (!isEnabled(annotationMetadata)) {
return EMPTY_ENTRY;
}
// 获取元数据的参数
AnnotationAttributes attributes = getAttributes(annotationMetadata);
// 获取候选需要注入的类
List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
// 类去重, 通过 Set 实现
configurations = removeDuplicates(configurations);
// 获取需要排除不加载的类
Set<String> exclusions = getExclusions(annotationMetadata, attributes);
// exclusions 类进行检查
checkExcludedClasses(configurations, exclusions);
// 从 configurations 中去除掉不需要加载的类
configurations.removeAll(exclusions);
// configurations 通过过滤器进行过滤，只留下符合要求的类
configurations = filter(configurations, autoConfigurationMetadata);
// 发布自动注入的消息事件，有监听器对其事件进行处理
fireAutoConfigurationImportEvents(configurations, exclusions);
// 新建AutoConfigurationEntry对象返回
return new AutoConfigurationEntry(configurations, exclusions);
}
1、getAttributes
protected AnnotationAttributes getAttributes(AnnotationMetadata metadata) {
// getAnnotationClass() 返回的内容为 EnableAutoConfiguration.class
String name = getAnnotationClass().getName();
// 获取注解里的参数信息
AnnotationAttributes attributes = AnnotationAttributes.fromMap(metadata.getAnnotationAttributes(name, true));
Assert.notNull(attributes, () -> "No auto-configuration attributes found. Is " + metadata.getClassName()
+ " annotated with " + ClassUtils.getShortName(name) + "?");
return attributes;
}
此方法主要获取参数的信息。
2、getCandidateConfigurations
protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
// 通过SpringFactoriesLoader加载出需要自动导入的类信息
// getSpringFactoriesLoaderFactoryClass() 返回的是 EnableAutoConfiguration.class
List<String> configurations = SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(),
getBeanClassLoader());
Assert.notEmpty(configurations, "No auto configuration classes found in META-INF/spring.factories. If you "
+ "are using a custom packaging, make sure that file is correct.");
return configurations;
}
简要来说，configurations 主要是通过 SpringFactoriesLoader 所加载出来的，具体的原理详见文章~
3、getExclusions
protected Set<String> getExclusions(AnnotationMetadata metadata, AnnotationAttributes attributes) {
Set<String> excluded = new LinkedHashSet<>();
// 获取 exclude 配置的类
excluded.addAll(asList(attributes, "exclude"));
// 获取 excludeName 配置的类
excluded.addAll(Arrays.asList(attributes.getStringArray("excludeName")));
// 获取 spring.autoconfigure.exclude 配置的类
excluded.addAll(getExcludeAutoConfigurationsProperty());
return excluded;
}
此方法获取不需要进行自动注入的类，通过提取注解里所配置的类以及配置文件里面所配置的类。
4、checkExcludedClasses
private void checkExcludedClasses(List<String> configurations, Set<String> exclusions) {
List<String> invalidExcludes = new ArrayList<>(exclusions.size());
// 遍历所有排除的类
for (String exclusion : exclusions) {
// 如果类能被加载，但是候选类里面不包含此类 将其加入到无效的集合中
if (ClassUtils.isPresent(exclusion, getClass().getClassLoader()) && !configurations.contains(exclusion)) {
invalidExcludes.add(exclusion);
}
}
// 如果存在无效类，则抛出异常 IllegalStateException
if (!invalidExcludes.isEmpty()) {
handleInvalidExcludes(invalidExcludes);
}
}
此方法主要是检查排除的类是否合理，如果存在不满足要求的类，则抛出异常。
5、filter
private List<String> filter(List<String> configurations, AutoConfigurationMetadata autoConfigurationMetadata) {
long startTime = System.nanoTime();
String[] candidates = StringUtils.toStringArray(configurations);
// skip 用来记录是否有需要跳过不加载
boolean[] skip = new boolean[candidates.length];
// skipped 用来记录是否有类不需要被加载
boolean skipped = false;
// getAutoConfigurationImportFilters（）该方法是获取自动注入的过滤器
// 同样是通过 SpringFactoriesLoader 进行加载
for (AutoConfigurationImportFilter filter : getAutoConfigurationImportFilters()) {
// 对过滤器进行一些初始赋值设置
invokeAwareMethods(filter);
// 过滤器对每个候选类进行匹配，match 用来记录匹配结果
boolean[] match = filter.match(candidates, autoConfigurationMetadata);
for (int i = 0; i < match.length; i++) {
if (!match[i]) {
skip[i] = true;
candidates[i] = null;
skipped = true;
}
}
}
// 如果都需要被加载，则可以直接返回 configurations
if (!skipped) {
return configurations;
}
// 否则需要将不需要加载的类剔除
List<String> result = new ArrayList<>(candidates.length);
for (int i = 0; i < candidates.length; i++) {
if (!skip[i]) {
result.add(candidates[i]);
}
}
if (logger.isTraceEnabled()) {
int numberFiltered = configurations.size() - result.size();
logger.trace("Filtered " + numberFiltered + " auto configuration class in "
+ TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - startTime) + " ms");
}
return new ArrayList<>(result);
}
此方法主要是通过 SpringFactoriesLoader 对过滤器进行加载，通过过滤器对候选的类进行下一步的过滤。我们知道Bean的注入我们可以添加一些条件，比如说 @Condition 注解 ，这里过滤器就是对每个候选类的注入条件进行检查，将不满足要求的类进行排除。
6、fireAutoConfigurationImportEvents
private void fireAutoConfigurationImportEvents(List<String> configurations, Set<String> exclusions) {
// 获取监听器，这里同样是通过 SpringFactoriesLoader 进行加载
List<AutoConfigurationImportListener> listeners = getAutoConfigurationImportListeners();
if (!listeners.isEmpty()) {
// 新建一个 AutoConfigurationImportEvent 事件
AutoConfigurationImportEvent event = new AutoConfigurationImportEvent(this, configurations, exclusions);
// 遍历每个监听器，如果能够处理该事件类型，则会对其进行响应
for (AutoConfigurationImportListener listener : listeners) {
invokeAwareMethods(listener);
listener.onAutoConfigurationImportEvent(event);
}
}
}
此方法主要用到的是监听器，通过发布事件，让对应能够监听该事件类型的监听器对其进行响应，额外增加一些操作。
7、new AutoConfigurationEntry(configurations, exclusions)
最后是新建一个 AutoConfigurationEntry 对象，这里包含需要主动注入的类和需要排除的类，在 selectImports 方法的最后，也是将 configurations 提出，转成数组进行返回，该数组记录的就是经过筛选后的需要导入的类的全限定名。
总结
整个自动导入的过程，回过头来看的话，其实并不是很复杂，但是很值得学习。有些方法看似很简单，就是获取某某某内容，但是去看如何去获取，其实又是一个新的知识点。在学习的过程中，其实有很多不明白的概念，也是希望多查，尽量不要留下不明白的知识点，茅塞顿开的感觉才是最开心的点。以下是我觉得需要进一步学习的内容，本文包含一部分内容的链接，当然源码更需要的是自己去理解，别人的内容都是仅供参考。
1、SpringFactoriesLoader.loadFactoryNames 方法，看一下它是如果找到我们要加载的类信息；
2、了解监听器的概念，发布事件、监听器响应等过程，其中 SpringBoot在启动过程中就有许多发布事件的过程，可以仔细学习；
3、过滤器如果对候选类进行筛选；
4、SpringBoot在启动过程中，何时去调用 selectImports 方法。
