// 基于本地 Spring 仓 (5.3.x)，org.springframework.core.io.support.SpringFactoriesLoader
// Spring 版 SPI：对比 JDK ServiceLoader，它一个文件能声明多种类型（key=接口 value=实现列表），且带缓存
public final class SpringFactoriesLoader {

	public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";

	public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
		ClassLoader classLoaderToUse = classLoader;
		if (classLoaderToUse == null) {
			classLoaderToUse = SpringFactoriesLoader.class.getClassLoader();
		}
		String factoryTypeName = factoryType.getName();
		// 全量加载后按类型名取 —— 只返回类名字符串，不实例化，留给调用方决定
		return loadSpringFactories(classLoaderToUse).getOrDefault(factoryTypeName, Collections.emptyList());
	}

	private static Map<String, List<String>> loadSpringFactories(ClassLoader classLoader) {
		Map<String, List<String>> result = cache.get(classLoader);
		if (result != null) {
			return result;      // 按 ClassLoader 缓存：一次 IO，整个启动期反复复用
		}

		result = new HashMap<>();
		try {
			// getResources 会扫所有 jar 里的同名文件 —— 每个 starter 的 spring.factories 都会被读到
			Enumeration<URL> urls = classLoader.getResources(FACTORIES_RESOURCE_LOCATION);
			while (urls.hasMoreElements()) {
				URL url = urls.nextElement();
				UrlResource resource = new UrlResource(url);
				Properties properties = PropertiesLoaderUtils.loadProperties(resource);
				for (Map.Entry<?, ?> entry : properties.entrySet()) {
					String factoryTypeName = ((String) entry.getKey()).trim();
					String[] factoryImplementationNames =
							StringUtils.commaDelimitedListToStringArray((String) entry.getValue());
					for (String factoryImplementationName : factoryImplementationNames) {
						result.computeIfAbsent(factoryTypeName, key -> new ArrayList<>())
								.add(factoryImplementationName.trim());
					}
				}
			}

			// Replace all lists with unmodifiable lists containing unique elements
			result.replaceAll((factoryType, implementations) -> implementations.stream().distinct()
					.collect(Collectors.collectingAndThen(Collectors.toList(), Collections::unmodifiableList)));
			cache.put(classLoader, result);
		}
		catch (IOException ex) {
			throw new IllegalArgumentException("Unable to load factories from location [" +
					FACTORIES_RESOURCE_LOCATION + "]", ex);
		}
		return result;
	}
}

// 基于本地 Spring Boot 仓 (2.7.x)，org.springframework.boot.autoconfigure.AutoConfigurationImportSelector
// @EnableAutoConfiguration 通过 @Import 引入它。注意它是 DeferredImportSelector：
// 延迟到用户自己的配置类全部解析完才执行，否则 @ConditionalOnMissingBean 判断不准
public class AutoConfigurationImportSelector implements DeferredImportSelector, BeanClassLoaderAware,
		ResourceLoaderAware, BeanFactoryAware, EnvironmentAware, Ordered {

	@Override
	public String[] selectImports(AnnotationMetadata annotationMetadata) {
		if (!isEnabled(annotationMetadata)) {     // spring.boot.enableautoconfiguration=false 可全局关掉
			return NO_IMPORTS;
		}
		AutoConfigurationEntry autoConfigurationEntry = getAutoConfigurationEntry(annotationMetadata);
		return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
	}

	// 自动配置五步：拿候选 -> 去重 -> 算排除 -> 剔除 -> 条件过滤
	protected AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {
		if (!isEnabled(annotationMetadata)) {
			return EMPTY_ENTRY;
		}
		AnnotationAttributes attributes = getAttributes(annotationMetadata);
		List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);   // 100+ 候选类名
		configurations = removeDuplicates(configurations);
		Set<String> exclusions = getExclusions(annotationMetadata, attributes);   // exclude 属性 + spring.autoconfigure.exclude
		checkExcludedClasses(configurations, exclusions);    // 排除了一个非自动配置类会直接报错，防手滑
		configurations.removeAll(exclusions);
		configurations = getConfigurationClassFilter().filter(configurations);    // 大头：条件过滤，砍掉大半候选
		fireAutoConfigurationImportEvents(configurations, exclusions);
		return new AutoConfigurationEntry(configurations, exclusions);
	}

	protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
		// 2.7 的过渡形态：老的 spring.factories 和新的 AutoConfiguration.imports 两个来源都读
		//（3.0 起 spring.factories 里的自动配置 key 被彻底移除，只剩 imports 文件）
		List<String> configurations = new ArrayList<>(
				SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(), getBeanClassLoader()));
		ImportCandidates.load(AutoConfiguration.class, getBeanClassLoader()).forEach(configurations::add);
		Assert.notEmpty(configurations,
				"No auto configuration classes found in META-INF/spring.factories nor in META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports. If you "
						+ "are using a custom packaging, make sure that file is correct.");
		return configurations;
	}

	private static class ConfigurationClassFilter {

		private final AutoConfigurationMetadata autoConfigurationMetadata;   // 编译期生成的条件元数据，免加载类就能判断

		private final List<AutoConfigurationImportFilter> filters;   // OnClassCondition / OnBeanCondition / OnWebApplicationCondition

		List<String> filter(List<String> configurations) {
			long startTime = System.nanoTime();
			String[] candidates = StringUtils.toStringArray(configurations);
			boolean skipped = false;
			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;    // 条件不满足（如 @ConditionalOnClass 的类不在 classpath）直接置空
						skipped = true;
					}
				}
			}
			if (!skipped) {
				return configurations;
			}
			// ... 收集非 null 的存活者返回，省略
		}
	}
}