SpringBoot源码-自动配置

自动配置：根据我们添加的jar包依赖，会自动将一些配置类的bean注册进ioc容器，我们可以需要的地
方使用@autowired或者@resource等注解来使用它。

Spring Boot应用的启动入口是@SpringBootApplication注解标注类中的main()方法，
@SpringBootApplication ： SpringBoot 应用标注在某个类上说明这个类是 SpringBoot 的主配置
类， SpringBoot 就应该运行这个类的 main() 方法启动 SpringBoot 应用。

@SpringBootApplication

看@SpringBootApplication内部源码进行分析 ，核心代码具体如下

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

从上述源码可以看出，@SpringBootApplication注解是一个组合注解，前面 4 个是注解的元数据信
息， 我们主要看后面 3 个注解：@SpringBootConfiguration、@EnableAutoConfiguration、
@ComponentScan三个核心注解，关于这三个核心注解的相关说明具体如下

@SpringBootConfiguration

@SpringBootConfiguration ： SpringBoot 的配置类，标注在某个类上，表示这是一个 SpringBoot
的配置类。
查看@SpringBootConfiguration注解源码，核心代码具体如下。

@Target({ElementType.TYPE}) 
@Retention(RetentionPolicy.RUNTIME) 
@Documented 
@Configuration // 配置类的作用等同于配置文件，配置类也是容器中的一个对象 
public @interface SpringBootConfiguration { 
}

从上述源码可以看出，@SpringBootConfiguration注解内部有一个核心注解@Configuration，该注解
是Spring框架提供的，表示当前类为一个配置类（XML配置文件的注解表现形式），并可以被组件扫描
器扫描。由此可见，@SpringBootConfiguration注解的作用与@Configuration注解相同，都是标识一
个可以被组件扫描器扫描的配置类，只不过@SpringBootConfiguration是被Spring Boot进行了重新封
装命名而已

@EnableAutoConfiguration

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

Spring 中有很多以 Enable 开头的注解，其作用就是借助 @Import 来收集并注册特定场景相关的
Bean ，并加载到 IOC 容器。
@EnableAutoConfiguration就是借助@Import来收集所有符合自动配置条件的bean定义，并加载到
IoC容器。

@AutoConfigurationPackage

package org.springframework.boot.autoconfigure; 
@Import(AutoConfigurationPackages.Registrar.class) // 导入Registrar中注册的组件 
public @interface AutoConfigurationPackage { 
}

@AutoConfigurationPackage ：自动配置包，它也是一个组合注解，其中最重要的注解是
@Import(AutoConfigurationPackages.Registrar.class) ，它是 Spring 框架的底层注解，它的作
用就是给容器中导入某个组件类，例如
@Import(AutoConfigurationPackages.Registrar.class) ，它就是将 Registrar 这个组件类导入
到容器中，可查看 Registrar 类中 registerBeanDefinitions 方法：

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

再看register方法

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

AutoConfigurationPackages.Registrar这个类就干一个事，注册一个 Bean ，这个 Bean 就是
org.springframework.boot.autoconfigure.AutoConfigurationPackages.BasePackages ，它有
一个参数，这个参数是使用了 @AutoConfigurationPackage 这个注解的类所在的包路径,保存自动配置
类以供之后的使用，比如给 JPA entity 扫描器用来扫描开发人员通过注解 @Entity 定义的 entity
类。

@Import(AutoConfigurationImportSelector.class)

@Import({AutoConfigurationImportSelector.class}) ：将
AutoConfigurationImportSelector 这个类导入到 Spring 容器中，
AutoConfigurationImportSelector 可以帮助 Springboot 应用将所有符合条件的 @Configuration
配置都加载到当前 SpringBoot 创建并使用的 IOC 容器( ApplicationContext )中。


image.png

AutoConfigurationImportSelector 重点是实现了 DeferredImportSelector 接口和各种
Aware 接口，然后 DeferredImportSelector 接口又继承了 ImportSelector 接口。
其不光实现了 ImportSelector 接口，还实现了很多其它的 Aware 接口，分别表示在某个时机会被回
调。

确定自动配置实现逻辑的入口方法：

跟自动配置逻辑相关的入口方法在 DeferredImportSelectorGrouping 类的 getImports 方法处，
因此我们就从 DeferredImportSelectorGrouping 类的 getImports 方法来开始分析SpringBoot的自
动配置源码好了。

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

标 【1】 处的的代码是我们分析的重中之重，自动配置的相关的绝大部分逻辑全在这里了。那么
this.group.process(deferredImport.getConfigurationClass().getMetadata(), deferredImport.getImportSelector()) ；主要做的事情就是在 this.group 即 AutoConfigurationGroup 对象的 process 方法中，传入的 AutoConfigurationImportSelector
对象来选择一些符合条件的自动配置类，过滤掉一些不符合条件的自动配置类

注：
AutoConfigurationGroup：是AutoConfigurationImportSelector的内部类，主要用来处理自动配 
置相关的逻辑，拥有process和selectImports方法，然后拥有entries和 
autoConfigurationEntries集合属性，这两个集合分别存储被处理后的符合条件的自动配置类，我们知道 
这些就足够了； 
AutoConfigurationImportSelector：承担自动配置的绝大部分逻辑，负责选择一些符合条件的自动配 
置类； 
metadata:标注在SpringBoot启动类上的@SpringBootApplication注解元数据 
标【2】的this.group.selectImports的方法主要是针对前面的process方法处理后的自动配置类再进一 
步有选择的选择导入
image.png

图中我们可以看到，跟自动配置逻辑相关的入口方法在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); 
} 
}

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

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

此流程遍历整个ClassLoader中所有jar包下的spring.factories文件，并进行过滤。
spring.factories里面保存着springboot的默认提供的自动配置类。

META-INF/spring.factories

image.png

主要逻辑

AutoConfigurationEntry 方法主要做的事情就是获取符合条件的自动配置类，避免加载不必要的自
动配置类从而造成内存浪费。我们下面总结下 AutoConfigurationEntry 方法主要做的事情：
【1】从 spring.factories 配置文件中加载 EnableAutoConfiguration 自动配置类）,获取的自动配
置类如图所示。
【2】若 @EnableAutoConfiguration 等注解标有要 exclude 的自动配置类，那么再将这个自动配置类
排除掉；
【3】排除掉要 exclude 的自动配置类后，然后再调用 filter 方法进行进一步的过滤，再次排除一些
不符合条件的自动配置类；
【4】经过重重过滤后，此时再触发 AutoConfigurationImportEvent 事件，告诉
ConditionEvaluationReport 条件评估报告器对象来记录符合条件的自动配置类；
【5】 最后再将符合条件的自动配置类返回。

过滤方法

// 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 的 filter 方法主要做的事情就是调用
AutoConfigurationImportFilter 接口的 match 方法来判断每一个自动配置类上的条件注解（若有
的话） @ConditionalOnClass , @ConditionalOnBean 或 @ConditionalOnWebApplication 是否满足
条件，若满足，则返回true，说明匹配，若不满足，则返回false说明不匹配。
我们现在知道 AutoConfigurationImportSelector 的 filter 方法主要做了什么事情就行了

关于条件注解的讲解

@Conditional是Spring4新提供的注解，它的作用是按照一定的条件进行判断，满足条件给容器注册
bean。
@ConditionalOnBean：仅仅在当前上下文中存在某个对象时，才会实例化一个Bean。
@ConditionalOnClass：某个class位于类路径上，才会实例化一个Bean。
@ConditionalOnExpression：当表达式为true的时候，才会实例化一个Bean。基于SpEL表达式
的条件判断。
@ConditionalOnMissingBean：仅仅在当前上下文中不存在某个对象时，才会实例化一个Bean。
@ConditionalOnMissingClass：某个class类路径上不存在的时候，才会实例化一个Bean。
@ConditionalOnNotWebApplication：不是web应用，才会实例化一个Bean。
@ConditionalOnWebApplication：当项目是一个Web项目时进行实例化。
@ConditionalOnNotWebApplication：当项目不是一个Web项目时进行实例化。
@ConditionalOnProperty：当指定的属性有指定的值时进行实例化。
@ConditionalOnJava：当JVM版本为指定的版本范围时触发实例化。
@ConditionalOnResource：当类路径下有指定的资源时触发实例化。
@ConditionalOnJndi：在JNDI存在的条件下触发实例化。
@ConditionalOnSingleCandidate：当指定的Bean在容器中只有一个，或者有多个但是指定了首
选的Bean时触发实例化。

有选择的导入自动配置类

this.group.selectImports 方法是如何进一步有选择的导入自动配置类的。

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

可以看到， selectImports 方法主要是针对经过排除掉 exclude 的和被
AutoConfigurationImportFilter 接口过滤后的满足条件的自动配置类再进一步排除 exclude 的自
动配置类，然后再排序
最后，我们再总结下SpringBoot自动配置的原理，主要做了以下事情：

  1. 从spring.factories配置文件中加载自动配置类；
  2. 加载的自动配置类中排除掉 @EnableAutoConfiguration 注解的 exclude 属性指定的自动配置
    类；
  3. 然后再用 AutoConfigurationImportFilter 接口去过滤自动配置类是否符合其标注注解（若有
    标注的话） @ConditionalOnClass , @ConditionalOnBean 和 @ConditionalOnWebApplication 的条件，若都符合的话则返回匹配结果；
  4. 然后触发 AutoConfigurationImportEvent 事件，告诉 ConditionEvaluationReport 条件评
    估报告器对象来分别记录符合条件和 exclude 的自动配置类。
  5. 最后spring再将最后筛选后的自动配置类导入IOC容器中
image.png

总解

  1. SpringBoot 启动会加载大量的自动配置类
  2. 我们看我们需要实现的功能有没有 SpringBoot 默认写好的自动配置类
  3. 我们再来看这个自动配置类中到底配置了哪些组件；（只要我们有我们要用的组件，我们就不需要
    再来配置了）
  4. 给容器中自动配置类添加组件的时候，会从 properties 类中获取某些属性，我们就可以在配置文
    件中指定这些属性的值。
    xxxAutoConfiguration ：自动配置类，用于给容器中添加组件从而代替之前我们手动完成大量繁
    琐的配置。
    xxxProperties : 封装了对应自动配置类的默认属性值，如果我们需要自定义属性值，只需要根据
    xxxProperties 寻找相关属性在配置文件设值即可。

例子HttpEncodingAutoConfiguration （ Http 编码自动配置）

// 表示这是一个配置类，和以前编写的配置文件一样，也可以给容器中添加组件 
@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注解

@ComponentScan使用
主要是从定义的扫描路径中，找出标识了需要装配的类自动装配到spring 的bean容器中。
常用属性如下：
basePackages、value：指定扫描路径，如果为空则以@ComponentScan注解的类所在的包为基
本的扫描路径
basePackageClasses：指定具体扫描的类
includeFilters：指定满足Filter条件的类
excludeFilters：指定排除Filter条件的类
includeFilters和excludeFilters 的FilterType可选：ANNOTATION=注解类型 默认、
ASSIGNABLE_TYPE(指定固定类)、ASPECTJ(ASPECTJ类型)、REGEX(正则表达式)、CUSTOM(自定义类
型)，自定义的Filter需要实现TypeFilter接口
@ComponentScan的配置如下：

@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = 
TypeExcludeFilter.class), 
@Filter(type = FilterType.CUSTOM, classes = 
AutoConfigurationExcludeFilter.class) })

借助excludeFilters将TypeExcludeFillter及FilterType这两个类进行排除
当前@ComponentScan注解没有标注basePackages及value，所以扫描路径默认为@ComponentScan
注解的类所在的包为基本的扫描路径（也就是标注了@SpringBootApplication注解的项目启动类所在
的路径）

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 203,547评论 6赞 477
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 85,399评论 2赞 381
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 150,428评论 0赞 337
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 54,599评论 1赞 274
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 63,612评论 5赞 365
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 48,577评论 1赞 281
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 37,941评论 3赞 395
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 36,603评论 0赞 258
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 40,852评论 1赞 297
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,605评论 2赞 321
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 37,693评论 1赞 329
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 33,375评论 4赞 318
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 38,955评论 3赞 307
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 29,936评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,172评论 1赞 259
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 43,970评论 2赞 349
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 42,414评论 2赞 342

推荐阅读更多精彩内容