EnableAutoConfiguration注解

啟用SpringBoot自動裝配功能，嘗試猜測和配置可能需要的組件Bean，

自動裝配類通常是根據類路徑和定義的Bean來應用的，例如，如果類路徑上有tomcat-embedded.jar，那么可能需要一個TomcatServletWebServerFactory(除非已經定義了自己的Servlet WebServerFactory Bean)，

自動裝配試圖盡可能地智能化，并將隨著開發者定義自己的配置而取消自動裝配相沖突的配置，開發者可以使用exclude()排除不想使用的配置，也可以通過spring.autoconfig.exclude屬性排除這些配置，自動裝配總是在用戶定義的Bean注冊之后應用，

用@EnableAutoConfiguration注解標注的類所在包具有特定的意義，通常用作默認掃描的包，通常建議將@EnableAutoConfiguration(如果沒有使用@SpringBootApplication注解)放在根包中，以便可以搜索所有子包和類，

自動裝配類是普通的Spring @Configuration類，使用SpringFactoriesLoader機制定位，通常使用@Conditional方式裝配，最常用的是@ConditionalOnClass和@ConditionalOnMissingBean注解，

@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {

	/**
	 * Exclude specific auto-configuration classes such that they will never be applied.
	 */
	Class<?>[] exclude() default {};

	/**
	 * Exclude specific auto-configuration class names such that they will never be
	 * applied.
	 * 當類路徑下沒有指定的類時，可以使用這個屬性指定排除的類
	 */
	String[] excludeName() default {};
}

該注解Import了AutoConfigurationImportSelector類，AutoConfigurationImportSelector類實作了DeferredImportSelector介面，

Import注解和DeferredImportSelector介面在之前的"Spring @Import注解原始碼分析"中詳細分析過，此處在介紹它們，只分析AutoConfigurationImportSelector的作業流程，

AutoConfigurationImportSelector類

DeferredImportSelector介面

A variation of ImportSelector that runs after all @Configuration beans have been processed. This type of selector can be particularly useful when the selected imports are @Conditional.

Implementations can also extend the org.springframework.core.Ordered interface or use the org.springframework.core.annotation.Order annotation to indicate a precedence against other DeferredImportSelectors.

Implementations may also provide an import group which can provide additional sorting and filtering logic across different selectors.

AutoConfigurationGroup類

AutoConfigurationImportSelector的getImportGroup方法回傳了AutoConfigurationGroup類，

private static class AutoConfigurationGroup implements 
		DeferredImportSelector.Group, BeanClassLoaderAware, BeanFactoryAware, ResourceLoaderAware {

	private final Map<String, AnnotationMetadata> entries = new LinkedHashMap<>();

	private final List<AutoConfigurationEntry> autoConfigurationEntries = new ArrayList<>();

	// ... 略

	@Override
	public void process(
			AnnotationMetadata annotationMetadata,
			DeferredImportSelector deferredImportSelector) {

		// AutoConfigurationEntry類使用List保存Configuration類
		AutoConfigurationEntry autoConfigurationEntry =
            ((AutoConfigurationImportSelector) deferredImportSelector)
				.getAutoConfigurationEntry(annotationMetadata);

		this.autoConfigurationEntries.add(autoConfigurationEntry);
		for (String importClassName : autoConfigurationEntry.getConfigurations()) {
			this.entries.putIfAbsent(importClassName, annotationMetadata);
		}
	}

	@Override
	public Iterable<Entry> selectImports() {
		// 查找排除的配置類
		Set<String> allExclusions = this.autoConfigurationEntries.stream()
				.map(AutoConfigurationEntry::getExclusions)
				.flatMap(Collection::stream)
				.collect(Collectors.toSet());
		// 所有配置類
		Set<String> processedConfigurations = this.autoConfigurationEntries.stream()
				.map(AutoConfigurationEntry::getConfigurations)
				.flatMap(Collection::stream)
				.collect(Collectors.toCollection(LinkedHashSet::new));
		// 將排除的配置類移除掉
		processedConfigurations.removeAll(allExclusions);

		// 排序
		return sortAutoConfigurations(processedConfigurations, getAutoConfigurationMetadata()).stream()
				.map((importClassName) -> new Entry(this.entries.get(importClassName), importClassName))
				.collect(Collectors.toList());
	}

	// ... 略
}

從上面的代碼可以看出，查找自動裝配類的邏輯在getAutoConfigurationEntry方法中，

getAutoConfigurationEntry方法

從META-INF/spring.factories檔案決議EnableAutoConfiguration配置，

META-INF/spring.factories檔案示例：

protected AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {
	AnnotationAttributes attributes = getAttributes(annotationMetadata);
	// 查找自動裝配類
	List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
	// 以下幾行為查找排除類、過濾等操作
	configurations = removeDuplicates(configurations);
	Set<String> exclusions = getExclusions(annotationMetadata, attributes);
	checkExcludedClasses(configurations, exclusions);
	configurations.removeAll(exclusions);
	// 這里的Filter是從META-INF/spring.factories檔案決議出來的
	configurations = getConfigurationClassFilter().filter(configurations);
	// 觸發事件
	fireAutoConfigurationImportEvents(configurations, exclusions);
	return new AutoConfigurationEntry(configurations, exclusions);
}

protected List<String> getCandidateConfigurations(
		AnnotationMetadata metadata, AnnotationAttributes attributes) {
	// 從META-INF/spring.factories檔案查找EnableAutoConfiguration配置
	List<String> configurations = SpringFactoriesLoader.loadFactoryNames(
						getSpringFactoriesLoaderFactoryClass(), getBeanClassLoader());
	return configurations;
}

SpringFactoriesLoader類loadFactoryNames方法

Load the fully qualified class names of factory implementations of the given type from "META-INF/spring.factories", using the given class loader.

public static List<String> loadFactoryNames(Class<?> factoryType, ClassLoader classLoader) {
	String factoryTypeName = factoryType.getName();
	return loadSpringFactories(classLoader).getOrDefault(factoryTypeName, Collections.emptyList());
}

private static Map<String, List<String>> loadSpringFactories(ClassLoader classLoader) {
	MultiValueMap<String, String> result = cache.get(classLoader);
	if (result != null) {
		return result;
	}

	try {
		// FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories"
		// 從類路徑下查找META-INF/spring.factories檔案
		Enumeration<URL> urls = (classLoader != null ?
				classLoader.getResources(FACTORIES_RESOURCE_LOCATION) :
				ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));
		result = new LinkedMultiValueMap<>();
		while (urls.hasMoreElements()) {
			URL url = urls.nextElement();
			UrlResource resource = new UrlResource(url);
			// 獲取properties配置
			Properties properties = PropertiesLoaderUtils.loadProperties(resource);
			for (Map.Entry<?, ?> entry : properties.entrySet()) {
				String factoryTypeName = ((String) entry.getKey()).trim();
				for (String factoryImplementationName :
                     StringUtils.commaDelimitedListToStringArray((String) entry.getValue())) {
					result.add(factoryTypeName, factoryImplementationName.trim());
				}
			}
		}
		// 把配置添加快取
		cache.put(classLoader, result);
		return result;
	} catch (IOException ex) {
		throw new IllegalArgumentException("Unable to load factories from location [" +
				FACTORIES_RESOURCE_LOCATION + "]", ex);
	}
}

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/555743.html

標籤：其他

上一篇：Spring原始碼核心剖析