SpringBoot 自动配置

@Target({ElementType.TYPE}) //注解的适用范围,Type表示注解可以描述在类、接口、注解或枚举中 

@Retention(RetentionPolicy.RUNTIME) //表示注解的生命周期，Runtime运行时 

@Documented //表示注解可以记录在javadoc中 

@Inherited //表示可以被子类继承该注解 

@SpringBootConfiguration // 标明该类为配置类 

@EnableAutoConfiguration // 启动自动配置功能 

@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = 

TypeExcludeFilter.class), 

@Filter(type = FilterType.CUSTOM, classes = 

AutoConfigurationExcludeFilter.class) }) 

public @interface SpringBootApplication { 

// 根据class来排除特定的类，使其不能加入spring容器，传入参数value类型是class类型。 

@AliasFor(annotation = EnableAutoConfiguration.class) 

Class<?>[] exclude() default {}; 

// 根据classname 来排除特定的类，使其不能加入spring容器，传入参数value类型是class的全 

类名字符串数组。 

@AliasFor(annotation = EnableAutoConfiguration.class) 

String[] excludeName() default {}; 

// 指定扫描包，参数是包名的字符串数组。 

@AliasFor(annotation = ComponentScan.class, attribute = "basePackages") 

String[] scanBasePackages() default {}; 

// 扫描特定的包，参数类似是Class类型数组。 

@AliasFor(annotation = ComponentScan.class, attribute = 

"basePackageClasses") 

Class<?>[] scanBasePackageClasses() default {}; 

}

@Target({ElementType.TYPE}) 

@Retention(RetentionPolicy.RUNTIME) 

@Documented 

@Configuration // 配置类的作用等同于配置文件，配置类也是容器中的一个对象 

public @interface SpringBootConfiguration { 

}

package org.springframework.boot.autoconfigure; 

// 自动配置包 

@AutoConfigurationPackage 

// Spring的底层注解@Import，给容器中导入一个组件； 

// 导入的组件是AutoConfigurationPackages.Registrar.class 

@Import(AutoConfigurationImportSelector.class) 

// 告诉SpringBoot开启自动配置功能，这样自动配置才能生效。 

public @interface EnableAutoConfiguration { 

String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration"; 

// 返回不会被导入到 Spring 容器中的类 

Class<?>[] exclude() default {}; 

// 返回不会被导入到 Spring 容器中的类名 

String[] excludeName() default {}; 

}

package org.springframework.boot.autoconfigure; 

@Import(AutoConfigurationPackages.Registrar.class) // 导入Registrar中注册的组件 

public @interface AutoConfigurationPackage { 

}

static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {

    Registrar() {

    }

    public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {

        AutoConfigurationPackages.register(registry, (String[])(new AutoConfigurationPackages.PackageImports(metadata)).getPackageNames().toArray(new String[0]));

    }

    public Set<Object> determineImports(AnnotationMetadata metadata) {

        return Collections.singleton(new AutoConfigurationPackages.PackageImports(metadata));

    }

}

public static void register(BeanDefinitionRegistry registry, String... 

packageNames) { 

// 这里参数 packageNames 缺省情况下就是一个字符串，是使用了注解 

// @SpringBootApplication 的 Spring Boot 应用程序入口类所在的包 

if (registry.containsBeanDefinition(BEAN)) { 

// 如果该bean已经注册，则将要注册包名称添加进去 

BeanDefinition beanDefinition = registry.getBeanDefinition(BEAN); 

ConstructorArgumentValues constructorArguments = beanDefinition 

.getConstructorArgumentValues(); 

constructorArguments.addIndexedArgumentValue(0, 

addBasePackages(constructorArguments, packageNames)); 

}

else {

//如果该bean尚未注册，则注册该bean，参数中提供的包名称会被设置到bean定义中去 

GenericBeanDefinition beanDefinition = new GenericBeanDefinition(); 

beanDefinition.setBeanClass(BasePackages.class); 

beanDefinition.getConstructorArgumentValues().addIndexedArgumentValue(0,

packageNames); 

beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE); 

registry.registerBeanDefinition(BEAN, beanDefinition); 

} 

} 

// ConfigurationClassParser.java 

public Iterable<Group.Entry> getImports() { 

// 遍历DeferredImportSelectorHolder对象集合deferredImports，deferredImports集合 

装了各种ImportSelector，当然这里装的是AutoConfigurationImportSelector 

for (DeferredImportSelectorHolder deferredImport : this.deferredImports) { 

// 【1】，利用AutoConfigurationGroup的process方法来处理自动配置的相关逻辑，决定 

导入哪些配置类（这个是我们分析的重点，自动配置的逻辑全在这了） 

this.group.process(deferredImport.getConfigurationClass().getMetadata(), 

deferredImport.getImportSelector()); 

}

// 【2】，经过上面的处理后，然后再进行选择导入哪些配置类 

return this.group.selectImports(); 

}

注：

AutoConfigurationGroup：是AutoConfigurationImportSelector的内部类，主要用来处理自动配 

置相关的逻辑，拥有process和selectImports方法，然后拥有entries和 

autoConfigurationEntries集合属性，这两个集合分别存储被处理后的符合条件的自动配置类，我们知道 

这些就足够了； 

AutoConfigurationImportSelector：承担自动配置的绝大部分逻辑，负责选择一些符合条件的自动配 

置类； 

metadata:标注在SpringBoot启动类上的@SpringBootApplication注解元数据 

标【2】的this.group.selectImports的方法主要是针对前面的process方法处理后的自动配置类再进一 

步有选择的选择导入

// AutoConfigurationImportSelector$AutoConfigurationGroup.java 

// 这里用来处理自动配置类，比如过滤掉不符合匹配条件的自动配置类 

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())); 

// 【1】,调用getAutoConfigurationEntry方法得到自动配置类放入 autoConfigurationEntry对象中 

AutoConfigurationEntry autoConfigurationEntry = 

((AutoConfigurationImportSelector) deferredImportSelector) 

.getAutoConfigurationEntry(getAutoConfigurationMetadata(), 

annotationMetadata);

//上面代码中我们再来看标 【1】 的方法 getAutoConfigurationEntry ，这个方法主要是用来获取自动 配置类有关，承担了自动配置的主要逻辑。直接上代码： 

//深入 getCandidateConfigurations 方法 

// 【2】，又将封装了自动配置类的autoConfigurationEntry对象装进 

//autoConfigurationEntries集合 

this.autoConfigurationEntries.add(autoConfigurationEntry); 

// 【3】，遍历刚获取的自动配置类 

for (String importClassName : autoConfigurationEntry.getConfigurations()) { 

// 这里符合条件的自动配置类作为key，annotationMetadata作为值放进entries集合 

this.entries.putIfAbsent(importClassName, annotationMetadata); 

} 

}

// AutoConfigurationImportSelector.java 

// 获取符合条件的自动配置类，避免加载不必要的自动配置类从而造成内存浪费 

protected AutoConfigurationEntry getAutoConfigurationEntry( 

AutoConfigurationMetadata autoConfigurationMetadata, 

AnnotationMetadata annotationMetadata) { 

// 获取是否有配置spring.boot.enableautoconfiguration属性，默认返回true 

if (!isEnabled(annotationMetadata)) { 

return EMPTY_ENTRY; 

}

// 获得@Congiguration标注的Configuration类即被审视introspectedClass的注解数据， 

// 比如：@SpringBootApplication(exclude = FreeMarkerAutoConfiguration.class) 

// 将会获取到exclude = FreeMarkerAutoConfiguration.class和excludeName=""的注解 数据 

AnnotationAttributes attributes = getAttributes(annotationMetadata); 

// 【1】得到spring.factories文件配置的所有自动配置类 

List<String> configurations = getCandidateConfigurations(annotationMetadata, 

attributes); 

// 利用LinkedHashSet移除重复的配置类 

configurations = removeDuplicates(configurations); 

// 得到要排除的自动配置类，比如注解属性exclude的配置类 

// 比如：@SpringBootApplication(exclude = FreeMarkerAutoConfiguration.class) 

// 将会获取到exclude = FreeMarkerAutoConfiguration.class的注解数据 

Set<String> exclusions = getExclusions(annotationMetadata, attributes); 

// 检查要被排除的配置类，因为有些不是自动配置类，故要抛出异常 

checkExcludedClasses(configurations, exclusions); 

// 【2】将要排除的配置类移除 

configurations.removeAll(exclusions); 

// 【3】因为从spring.factories文件获取的自动配置类太多，如果有些不必要的自动配置类都加载 

//进内存，会造成内存浪费，因此这里需要进行过滤 

// 注意这里会调用AutoConfigurationImportFilter的match方法来判断是否符合 

//@ConditionalOnBean,@ConditionalOnClass或@ConditionalOnWebApplication，后面会重点分 

//析一下

configurations = filter(configurations, autoConfigurationMetadata); 

// 【4】获取了符合条件的自动配置类后，此时触发AutoConfigurationImportEvent事件， 

// 目的是告诉ConditionEvaluationReport条件评估报告器对象来记录符合条件的自动配置类 

// 该事件什么时候会被触发？--> 在刷新容器时调用invokeBeanFactoryPostProcessors后置处 

//理器时触发 

fireAutoConfigurationImportEvents(configurations, exclusions); 

// 【5】将符合条件和要排除的自动配置类封装进AutoConfigurationEntry对象，并返回 

return new AutoConfigurationEntry(configurations, exclusions); 

}

// AutoConfigurationImportSelector.java 

private List<String> filter(List<String> configurations, 

AutoConfigurationMetadata autoConfigurationMetadata) { 

long startTime = System.nanoTime(); 

// 将从spring.factories中获取的自动配置类转出字符串数组 

String[] candidates = StringUtils.toStringArray(configurations); 

// 定义skip数组，是否需要跳过。注意skip数组与candidates数组顺序一一对应 

boolean[] skip = new boolean[candidates.length]; 

boolean skipped = false; 

// getAutoConfigurationImportFilters方法：拿到OnBeanCondition， 

OnClassCondition和OnWebApplicationCondition 

// 然后遍历这三个条件类去过滤从spring.factories加载的大量配置类 

for (AutoConfigurationImportFilter filter : 

getAutoConfigurationImportFilters()) { 

// 调用各种aware方法，将beanClassLoader,beanFactory等注入到filter对象中， 

// 这里的filter对象即OnBeanCondition，OnClassCondition或 

OnWebApplicationCondition 

invokeAwareMethods(filter); 

// 判断各种filter来判断每个candidate（这里实质要通过candidate(自动配置类)拿到其标 

注的 

// @ConditionalOnClass,@ConditionalOnBean和@ConditionalOnWebApplication里 

面的注解值）是否匹配， 

// 注意candidates数组与match数组一一对应 

/**********************【主线，重点关注】********************************/ 

boolean[] match = filter.match(candidates, autoConfigurationMetadata); 

// 遍历match数组，注意match顺序跟candidates的自动配置类一一对应 

for (int i = 0; i < match.length; i++) { 

// 若有不匹配的话 

if (!match[i]) { 

// 不匹配的将记录在skip数组，标志skip[i]为true，也与candidates数组一一 

对应 

skip[i] = true; 

// 因为不匹配，将相应的自动配置类置空 

candidates[i] = null; 

// 标注skipped为true 

skipped = true; 

} 

} 

}

// 这里表示若所有自动配置类经过OnBeanCondition，OnClassCondition和 

OnWebApplicationCondition过滤后，全部都匹配的话，则全部原样返回 

if (!skipped) { 

return configurations; 

}

// 建立result集合来装匹配的自动配置类 

List<String> result = new ArrayList<>(candidates.length); 

for (int i = 0; i < candidates.length; i++) { 

// 若skip[i]为false，则说明是符合条件的自动配置类，此时添加到result集合中 

if (!skip[i]) { 

result.add(candidates[i]); 

} 

}

// 打印日志

if (logger.isTraceEnabled()) { 

int numberFiltered = configurations.size() - result.size(); 

logger.trace("Filtered " + numberFiltered + " auto configuration class 

in " 

+ TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - startTime) 

+ " ms"); 

}

// 最后返回符合条件的自动配置类 

return new ArrayList<>(result); 

}

// AutoConfigurationImportSelector$AutoConfigurationGroup.java 

public Iterable<Entry> selectImports() { 

if (this.autoConfigurationEntries.isEmpty()) { 

return Collections.emptyList(); 

}

// 这里得到所有要排除的自动配置类的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)); 

// 移除掉要排除的自动配置类 

processedConfigurations.removeAll(allExclusions); 

// 对标注有@Order注解的自动配置类进行排序， 

return sortAutoConfigurations(processedConfigurations, 

getAutoConfigurationMetadata()) 

.stream() 

.map((importClassName) -> new Entry( 

this.entries.get(importClassName), importClassName)) 

.collect(Collectors.toList()); 

}

// 表示这是一个配置类，和以前编写的配置文件一样，也可以给容器中添加组件 

@Configuration 

// 启动指定类的ConfigurationProperties功能；将配置文件中对应的值和 

//HttpEncodingProperties绑定起来； 

@EnableConfigurationProperties({HttpEncodingProperties.class}) 

// Spring底层@Conditional注解，根据不同的条件，如果满足指定的条件，整个配置类里面的配置就会生效。 

// 判断当前应用是否是web应用，如果是，当前配置类生效。并把HttpEncodingProperties加入到 ioc 容器中 

@ConditionalOnWebApplication 

// 判断当前项目有没有这个CharacterEncodingFilter ： SpringMVC中进行乱码解决的过滤器 

@ConditionalOnClass({CharacterEncodingFilter.class}) 

// 判断配置文件中是否存在某个配置 spring.http.encoding.enabled 如果不存在，判断也是成立的 

// matchIfMissing = true 表示即使我们配置文件中不配置 

spring.http.encoding.enabled=true，也是默认生效的 

@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = 

TypeExcludeFilter.class), 

@Filter(type = FilterType.CUSTOM, classes = 

AutoConfigurationExcludeFilter.class) })