SpringBoot自动配置源码深入刨析讲解

@Override
	public String[] selectImports(AnnotationMetadata annotationMetadata) {
		// 会在所有@Configuration都解析完了之后才执行
		if (!isEnabled(annotationMetadata)) {
			return NO_IMPORTS;
		}
		// 获取自动配置类（spring.factories中所导入的）
		AutoConfigurationEntry autoConfigurationEntry = getAutoConfigurationEntry(annotationMetadata);
		return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
	}

protected AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {
		if (!isEnabled(annotationMetadata)) {
			return EMPTY_ENTRY;
		}
		// 获取@EnableAutoConfiguration的属性
		AnnotationAttributes attributes = getAttributes(annotationMetadata);
		// 获取spring.factories中所有的AutoConfiguration
		List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
		// 去重（也就是按类名去重）
		configurations = removeDuplicates(configurations);
		// 获取需要排除的AutoConfiguration，可以通过@EnableAutoConfiguration注解的exclude属性，或者spring.autoconfigure.exclude来配置
		Set<String> exclusions = getExclusions(annotationMetadata, attributes);
		// 排除
		checkExcludedClasses(configurations, exclusions);
		configurations.removeAll(exclusions);
		// 获取spring.factories中的AutoConfigurationImportFilter对AutoConfiguration进行过滤
		// 默认会拿到OnBeanCondition、OnClassCondition、OnWebApplicationCondition
		// 这三个会去判断上面的AutoConfiguration是否符合它们自身所要求的条件，不符合的会过滤掉，表示不会进行解析了
		// 会利用spring-autoconfigure-metadata.properties中的配置来进行过滤
		// spring-autoconfigure-metadata.properties文件中的内容是利用Java中的AbstractProcessor技术在编译时生成出来的
		configurations = getConfigurationClassFilter().filter(configurations);
		// configurations表示合格的，exclusions表示被排除的，把它们记录在ConditionEvaluationReportAutoConfigurationImportListener中
		fireAutoConfigurationImportEvents(configurations, exclusions);

		// 最后返回的AutoConfiguration都是符合条件的
		return new AutoConfigurationEntry(configurations, exclusions);
	}

protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
		//核心方法 传入EnableAutoConfiguration类和类加载器
		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;
	}
//返回EnableAutoConfiguration
protected Class<?> getSpringFactoriesLoaderFactoryClass() {
		return EnableAutoConfiguration.class;
	}
public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
		ClassLoader classLoaderToUse = classLoader;
		if (classLoaderToUse == null) {
			//获取类加载器
			classLoaderToUse = SpringFactoriesLoader.class.getClassLoader();
		}
		//这个name就是EnableAutoConfiguration
		String factoryTypeName = factoryType.getName();
		//这部分代码具体的去加载自动配置类
		return loadSpringFactories(classLoaderToUse).getOrDefault(factoryTypeName, Collections.emptyList());
	}

protected final <T> List<T> removeDuplicates(List<T> list) {
		return new ArrayList<>(new LinkedHashSet<>(list));
	}

protected Set<String> getExclusions(AnnotationMetadata metadata, AnnotationAttributes attributes) {
		Set<String> excluded = new LinkedHashSet<>();
		//获取EnableAutoConfiguration注解的exclude属性的值 添加到排除集合当中
		excluded.addAll(asList(attributes, "exclude"));
		//获取EnableAutoConfiguration注解的excludeName属性的值 添加到排除集合当中
		excluded.addAll(Arrays.asList(attributes.getStringArray("excludeName")));
		//从配置文件中获取spring.autoconfigure.exclude 的值 添加到排除集合中
		excluded.addAll(getExcludeAutoConfigurationsProperty());
		return excluded;
	}

private ConfigurationClassFilter getConfigurationClassFilter() {
		if (this.configurationClassFilter == null) {
			//获取自动配置类的过滤器
			List<AutoConfigurationImportFilter> filters = getAutoConfigurationImportFilters();
			for (AutoConfigurationImportFilter filter : filters) {
				invokeAwareMethods(filter);
			}
			//将所有过滤器封装成 ConfigurationClassFilter
			this.configurationClassFilter = new ConfigurationClassFilter(this.beanClassLoader, filters);
		}
		return this.configurationClassFilter;
	}
protected List<AutoConfigurationImportFilter> getAutoConfigurationImportFilters() {
		//底层从 META-INF/spring.factories中加载 AutoConfigurationImportFilter的值
		return SpringFactoriesLoader.loadFactories(AutoConfigurationImportFilter.class, this.beanClassLoader);
	}

List<String> filter(List<String> configurations) {
			long startTime = System.nanoTime();
			//把自动配置类的名称封装成数组
			String[] candidates = StringUtils.toStringArray(configurations);
			boolean skipped = false;
			// 逐个利用AutoConfigurationImportFilter来判断所有的自动配置类的条件是否匹配，匹配结果存在match数组中
			// 先利用OnBeanCondition进行过滤
			// 再利用OnClassCondition进行过滤
			// 再利用OnWebApplicationCondition进行过滤
			for (AutoConfigurationImportFilter filter : this.filters) {
				//把过滤的结果 放入到boolean的数组中
				boolean[] match = filter.match(candidates, this.autoConfigurationMetadata);
				for (int i = 0; i < match.length; i++) {
					if (!match[i]) {
						//如果匹配失败 排除掉该自动配置类
						candidates[i] = null;
						skipped = true;
					}
				}
			}
			// 全部都匹配
			if (!skipped) {
				return configurations;
			}
			// 把匹配的记录在result集合中，最后返回
			List<String> result = new ArrayList<>(candidates.length);
			for (String candidate : candidates) {
				if (candidate != null) {
					result.add(candidate);
				}
			}
			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 result;
		}
	}

AutoConfigurationEntry(Collection<String> configurations, Collection<String> exclusions) {
			this.configurations = new ArrayList<>(configurations);
			this.exclusions = new HashSet<>(exclusions);
		}
		public List<String> getConfigurations() {
			return this.configurations;
		}
		public Set<String> getExclusions() {
			return this.exclusions;
		}