上一节已经看了@Import注解，而@EnableAutoConfiguration注解中就引用了此注解

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

所以接下来可以看一下AutoConfigurationImportSelector类：

public class AutoConfigurationImportSelector implements DeferredImportSelector, BeanClassLoaderAware,
		ResourceLoaderAware, BeanFactoryAware, EnvironmentAware, Ordered {

可以看到这里使用了DeferredImportSelector接口，那么就应该想到，他会使勇Group处理，不会直接走selectImports方法；可以看到：

    @Override
	public Class<? extends Group> getImportGroup() {
		return AutoConfigurationGroup.class;
	}

此方法实现了接口方法，并返回了值；所以此时程序是不会走selectImports方法的，而是走了

AutoConfigurationGroup#process的方法，

		@Override
		public void process(AnnotationMetadata annotationMetadata, DeferredImportSelector deferredImportSelector) {
			Assert.state(deferredImportSelector instanceof AutoConfigurationImportSelector,
					() -> String.format("Only %s implementations are supported, got %s",
							AutoConfigurationImportSelector.class.getSimpleName(),
							deferredImportSelector.getClass().getName()));
			AutoConfigurationEntry autoConfigurationEntry = ((AutoConfigurationImportSelector) deferredImportSelector)
					.getAutoConfigurationEntry(annotationMetadata);
			this.autoConfigurationEntries.add(autoConfigurationEntry);
			for (String importClassName : autoConfigurationEntry.getConfigurations()) {
				this.entries.putIfAbsent(importClassName, annotationMetadata);
			}
		}

通过此方法，可以找到最终调用的是AutoConfigurationImportSelector#getAutoConfigurationEntry方法，此方法是这篇文章主要的分析内容：

	protected AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {
		if (!isEnabled(annotationMetadata)) {
			return EMPTY_ENTRY;
		}
		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);
		configurations = getConfigurationClassFilter().filter(configurations);
		fireAutoConfigurationImportEvents(configurations, exclusions);
		return new AutoConfigurationEntry(configurations, exclusions);
	}

1）获取配置类信息

List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);

此方法其实就是一个spi的扩展机制；

	protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
		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;
	}

public final class SpringFactoriesLoader {

	/**
	 * The location to look for factories.
	 * <p>Can be present in multiple JAR files.
	 */
	public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";

SpringFactoriesLoader类读取了META-INF/spring.factories文件中的配置，然后将value加载出来，

	protected Class<?> getSpringFactoriesLoaderFactoryClass() {
		return EnableAutoConfiguration.class;
	}

可以看到最终加载的信息的key是org.springframework.boot.autoconfigure.EnableAutoConfiguration的配置信息，看名字就知道是自动装配相关的东西；

 可以看到总共加载了127个（这里面有自定义的参数）。

知道了这一步，这么多配置信息，是不是不是所有的配置都需要加载，那是不是就要进行一次过滤，只加载必须的类信息；

configurations = getConfigurationClassFilter().filter(configurations);

此方法是移除类不需要的类的方法：

	private ConfigurationClassFilter getConfigurationClassFilter() {
		if (this.configurationClassFilter == null) {
			List<AutoConfigurationImportFilter> filters = getAutoConfigurationImportFilters();
			for (AutoConfigurationImportFilter filter : filters) {
				invokeAwareMethods(filter);
			}
			this.configurationClassFilter = new ConfigurationClassFilter(this.beanClassLoader, filters);
		}
		return this.configurationClassFilter;
	}

这里创建了一个ConfigurationClassFilter类对象；其构造函数如下：

		ConfigurationClassFilter(ClassLoader classLoader, List<AutoConfigurationImportFilter> filters) {
			this.autoConfigurationMetadata = AutoConfigurationMetadataLoader.loadMetadata(classLoader);
			this.filters = filters;
		}

final class AutoConfigurationMetadataLoader {

	protected static final String PATH = "META-INF/spring-autoconfigure-metadata.properties";

可以看到，最终其也是通过spi的形式，读取了spring-autoconfigure-metadata.properties文件，此文件中包含了排除的类信息，可以通过文件看一下：

 可以看到在两个文件中都存在此路径，其意思就是当org.influxdb.InfluxDB类的class文件存在的时候，spring.factories中的InfluxDbAutoConfiguration才会加载；

所以通过此处过滤之后：

 只还有24个需要加载的，其他的都被过滤掉了；

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

 最终存储到entries变量中：

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