Spring Boot自动化装配机制

@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 {
	/**
	 * 需要排除的自动化配置， 根据类名进行排除，  比如MongoAutoConfiguration， JpaRepositoriesAutoConfiguration等
	 */
	@AliasFor(annotation = EnableAutoConfiguration.class)
	Class<?>[] exclude() default {};
	/**
	 * 需要排除的自动化配置， 根据名称进行排除
	 */
	@AliasFor(annotation = EnableAutoConfiguration.class)
	String[] excludeName() default {};
	/**
	 * 指定需要扫描的包路径，参数填写包名
	 */
	@AliasFor(annotation = ComponentScan.class, attribute = "basePackages")
	String[] scanBasePackages() default {};
	/**
	 * 指定需要扫描的包路径
	 */
	@AliasFor(annotation = ComponentScan.class, attribute = "basePackageClasses")
	Class<?>[] scanBasePackageClasses() default {};
	/**
	 * Bean方法的动态代理配置， 如果没有采用工厂方法， 可以标记为false， 采用cglib代理。	
	 */
	@AliasFor(annotation = Configuration.class)
	boolean proxyBeanMethods() default true;
}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration(proxyBeanMethods = false)
public @interface SpringBootConfiguration {
	/**
	 * Bean方法的动态代理配置
	 */
	@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 {};
	/**
	 * 排除自动化配置的组件， 根据名称设置
	 */
	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 {
    	// 记录注解的元数据
		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;
        // 设置自动化配置的元数据记录
		private AutoConfigurationMetadata autoConfigurationMetadata;
		...
	}

@Override
public Iterable<Entry> selectImports() {
    if (this.autoConfigurationEntries.isEmpty()) {
        return Collections.emptyList();
    }
    // 将所有自动化条目根据配置的Exclusion条件作过滤， 并转换为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、获取符合规则的Spring Boot 内置的自动化配置类， 并做去重处理
		List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
		configurations = removeDuplicates(configurations);
        // 4、做排除规则匹配， 过滤处理
		Set<String> exclusions = getExclusions(annotationMetadata, attributes);
		checkExcludedClasses(configurations, exclusions);
		configurations.removeAll(exclusions);
		configurations = filter(configurations, autoConfigurationMetadata);
        // 5、触发自动导入处理完成事件
		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());
    	}
        // 决定是否导入注解中的配置内容
    	@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;
		// 构造方法， 记录注解内容	
		PackageImport(AnnotationMetadata metadata) {
			this.packageName = ClassUtils.getPackageName(metadata.getClassName());
		}
		// 获取指定包名称
		public String getPackageName() {
			return this.packageName;
		}
	    // 重载父类比较逻辑， 根据包名判断
		@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， 打印内容
		@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定义， 重新构造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) {
        // 获取已经存在的Bean定义信息
		String[] existing = (String[]) constructorArguments.getIndexedArgumentValue(0, String[].class).getValue();
        // 创建合并集合， 过滤重复的Bean定义
		Set<String> merged = new LinkedHashSet<>();
        // 根据Set特性， 自动合并去重
		merged.addAll(Arrays.asList(existing));
		merged.addAll(Arrays.asList(packageNames));        
		return StringUtils.toStringArray(merged);
	}