@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
		@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
@ConfigurationPropertiesScan
public @interface SpringBootApplication {
	/**
	 * 需要排除的自動化配置， 根據(jù)類名進行排除，  比如MongoAutoConfiguration， JpaRepositoriesAutoConfiguration等
	 */
	@AliasFor(annotation = EnableAutoConfiguration.class)
	Class<?>[] exclude() default {};
	/**
	 * 需要排除的自動化配置， 根據(jù)名稱進行排除
	 */
	@AliasFor(annotation = EnableAutoConfiguration.class)
	String[] excludeName() default {};
	/**
	 * 指定需要掃描的包路徑，參數(shù)填寫包名
	 */
	@AliasFor(annotation = ComponentScan.class, attribute = "basePackages")
	String[] scanBasePackages() default {};
	/**
	 * 指定需要掃描的包路徑
	 */
	@AliasFor(annotation = ComponentScan.class, attribute = "basePackageClasses")
	Class<?>[] scanBasePackageClasses() default {};
	/**
	 * Bean方法的動態(tài)代理配置， 如果沒有采用工廠方法， 可以標記為false， 采用cglib代理。	
	 */
	@AliasFor(annotation = Configuration.class)
	boolean proxyBeanMethods() default true;
}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration(proxyBeanMethods = false)
public @interface SpringBootConfiguration {
	/**
	 * Bean方法的動態(tài)代理配置
	 */
	@AliasFor(annotation = Configuration.class)
	boolean proxyBeanMethods() default true;
}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {
    // 設置注解支持重載的標識
	String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";
	/**
	 * 排除自動化配置的組件， 如MongoAutoConfiguration， JpaRepositoriesAutoConfiguration等
	 */
	Class<?>[] exclude() default {};
	/**
	 * 排除自動化配置的組件， 根據(jù)名稱設置
	 */
	String[] excludeName() default {};
}

/**
 * {@link DeferredImportSelector} to handle {@link EnableAutoConfiguration
 * auto-configuration}. This class can also be subclassed if a custom variant of
 * {@link EnableAutoConfiguration @EnableAutoConfiguration} is needed.
 *
 * @author Phillip Webb
 * @author Andy Wilkinson
 * @author Stephane Nicoll
 * @author Madhura Bhave
 * @since 1.3.0
 * @see EnableAutoConfiguration
 */
public class AutoConfigurationImportSelector implements DeferredImportSelector, BeanClassLoaderAware,
		ResourceLoaderAware, BeanFactoryAware, EnvironmentAware, Ordered {
            ...
        }
}

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;
	}

private static class AutoConfigurationGroup
			implements DeferredImportSelector.Group, BeanClassLoaderAware, BeanFactoryAware, ResourceLoaderAware {
    	// 記錄注解的元數(shù)據(jù)
		private final Map<String, AnnotationMetadata> entries = new LinkedHashMap<>();
		// 記錄自動化配置條目，放入集合
		private final List<AutoConfigurationEntry> autoConfigurationEntries = new ArrayList<>();
        // 設置bean的類加載器
		private ClassLoader beanClassLoader;
        // 設置bean工廠信息
		private BeanFactory beanFactory;
        // 設置資源加載器信息
		private ResourceLoader resourceLoader;
        // 設置自動化配置的元數(shù)據(jù)記錄
		private AutoConfigurationMetadata autoConfigurationMetadata;
		...
	}

@Override
public Iterable<Entry> selectImports() {
    if (this.autoConfigurationEntries.isEmpty()) {
        return Collections.emptyList();
    }
    // 將所有自動化條目根據(jù)配置的Exclusion條件作過濾， 并轉(zhuǎn)換為SET集合
    Set<String> allExclusions = this.autoConfigurationEntries.stream()
        .map(AutoConfigurationEntry::getExclusions).flatMap(Collection::stream).collect(Collectors.toSet());
    // SET集合， 記錄所有需要處理的自動化配置
    Set<String> processedConfigurations = this.autoConfigurationEntries.stream()
        .map(AutoConfigurationEntry::getConfigurations).flatMap(Collection::stream)
        .collect(Collectors.toCollection(LinkedHashSet::new));
    // 兩個SET， 做交集過濾， 排除不需要的配置
    processedConfigurations.removeAll(allExclusions);
    // 最后進行排序處理
    return sortAutoConfigurations(processedConfigurations, getAutoConfigurationMetadata()).stream()
        .map((importClassName) -> new Entry(this.entries.get(importClassName), importClassName))
        .collect(Collectors.toList());
}

@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(getAutoConfigurationMetadata(), annotationMetadata);
    // 記錄獲取的條目
    this.autoConfigurationEntries.add(autoConfigurationEntry);
    for (String importClassName : autoConfigurationEntry.getConfigurations()) {
        // 放入成員變量entries中
        this.entries.putIfAbsent(importClassName, annotationMetadata);
    }
}

protected AutoConfigurationEntry getAutoConfigurationEntry(AutoConfigurationMetadata autoConfigurationMetadata,
			AnnotationMetadata annotationMetadata) {
        // 1、判斷是否開對應注解
		if (!isEnabled(annotationMetadata)) {
			return EMPTY_ENTRY;
		}
        // 2、獲取注解定義的屬性
		AnnotationAttributes attributes = getAttributes(annotationMetadata);
        // 3、獲取符合規(guī)則的Spring Boot 內(nèi)置的自動化配置類， 并做去重處理
		List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
		configurations = removeDuplicates(configurations);
        // 4、做排除規(guī)則匹配， 過濾處理
		Set<String> exclusions = getExclusions(annotationMetadata, attributes);
		checkExcludedClasses(configurations, exclusions);
		configurations.removeAll(exclusions);
		configurations = filter(configurations, autoConfigurationMetadata);
        // 5、觸發(fā)自動導入處理完成事件
		fireAutoConfigurationImportEvents(configurations, exclusions);
		return new AutoConfigurationEntry(configurations, exclusions);
	}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@Import(AutoConfigurationPackages.Registrar.class)
public @interface AutoConfigurationPackage {
...
}

static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {
        // 注冊BEAN的定義信息
    	@Override
    	public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
    		register(registry, new PackageImport(metadata).getPackageName());
    	}
        // 決定是否導入注解中的配置內(nèi)容
    	@Override
    	public Set<Object> determineImports(AnnotationMetadata metadata) {
    		return Collections.singleton(new PackageImport(metadata));
    	}
    }

    /**
	 * Wrapper for a package import.
	 */
	private static final class PackageImport {
		private final String packageName;
		// 構(gòu)造方法， 記錄注解內(nèi)容	
		PackageImport(AnnotationMetadata metadata) {
			this.packageName = ClassUtils.getPackageName(metadata.getClassName());
		}
		// 獲取指定包名稱
		public String getPackageName() {
			return this.packageName;
		}
	    // 重載父類比較邏輯， 根據(jù)包名判斷
		@Override
		public boolean equals(Object obj) {
			if (obj == null || getClass() != obj.getClass()) {
				return false;
			}
			return this.packageName.equals(((PackageImport) obj).packageName);
		}
		// 重載hash標識， 以包名的HASH值為準
		@Override
		public int hashCode() {
			return this.packageName.hashCode();
		}
	    // 重載toString， 打印內(nèi)容
		@Override
		public String toString() {
			return "Package Import " + this.packageName;
		}
	}

public static void register(BeanDefinitionRegistry registry, String... packageNames) {
        // 判斷是否包含BEAN定義信息， 如果包含， 更新packageNames信息
		if (registry.containsBeanDefinition(BEAN)) {
			BeanDefinition beanDefinition = registry.getBeanDefinition(BEAN);
			ConstructorArgumentValues constructorArguments = beanDefinition.getConstructorArgumentValues();
			constructorArguments.addIndexedArgumentValue(0, addBasePackages(constructorArguments, packageNames));
		}
        // 如果registry中不包含BEAN定義， 重新構(gòu)造GenericBeanDefinition對象， 記錄相關信息
		else {            
			GenericBeanDefinition beanDefinition = new GenericBeanDefinition();
			beanDefinition.setBeanClass(BasePackages.class);
			beanDefinition.getConstructorArgumentValues().addIndexedArgumentValue(0, packageNames);
			beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
			registry.registerBeanDefinition(BEAN, beanDefinition);
		}
	}

private static String[] addBasePackages(ConstructorArgumentValues constructorArguments, String[] packageNames) {
        // 獲取已經(jīng)存在的Bean定義信息
		String[] existing = (String[]) constructorArguments.getIndexedArgumentValue(0, String[].class).getValue();
        // 創(chuàng)建合并集合， 過濾重復的Bean定義
		Set<String> merged = new LinkedHashSet<>();
        // 根據(jù)Set特性， 自動合并去重
		merged.addAll(Arrays.asList(existing));
		merged.addAll(Arrays.asList(packageNames));        
		return StringUtils.toStringArray(merged);
	}