【SpringBoot】排除不需要的自动配置类DataSourceAutoConfiguration

一、排除自动配置类的三种方式

 

以下三种方式可以用来排除任意的自动配置类

 

1.1使用@SpringBootApplication注解排除

使用exclude属性（value是Class对象数组）

1. @SpringBootApplication(exclude = DataSourceAutoConfiguration.class)
2. public class DemoApplication {
3.  
4. public static void main(String[] args) {
5. SpringApplication.run(DemoApplication.class, args);
6. }
7.  
8. }

或者excludeName属性（value是类的全限定名字符串数组）

1. @SpringBootApplication(excludeName = {"org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration"})
2. public class DemoApplication {
3.  
4. public static void main(String[] args) {
5. SpringApplication.run(DemoApplication.class, args);
6. }
7.  
8. }

 

1.2使用@EnableAutoConfiguration注解排除

 

1.在项目中创建一个配置类对象MyConfig.class,在配置类上使用@EnableAutoConfiguration注解。

使用exclude属性（value是Class对象数组）

1. @Configuration
2. @EnableAutoConfiguration(exclude = DataSourceAutoConfiguration.class)
3. public class MyConfig {
4. }

或者excludeName属性（value是类的全限定名字符串数组）

1. @Configuration
2. @EnableAutoConfiguration(excludeName = {"org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration"})
3. public class MyConfig {
4. }

 

思考1：为什么不能直接在启动类上使用@EnableAutoConfiguration注解，而要重新创建一个配置类？

因为@SpringBootApplication已经继承了@EnableAutoConfiguration，并且@EnableAutoConfiguration注解，是不可在类上重复使用的注解（换句话说就是使用@SpringBootApplication注解，就相当于使用了@EnableAutoConfiguration注解）

所以 我们会发现方法一与方法二本质上是一样的只是形式上的差别，底层都是依赖于@EnableAutoConfiguration注解实现的排除功能。

 

思考2：@SpringBootApplication注解与@EnableAutoConfiguration的关系？为什么在@SpringBootApplication注解中配置属性底层还是使用@EnableAutoConfiguration实现的呢？

@SpringBootApplication注解源码：

1. @Target(ElementType.TYPE)
2. @Retention(RetentionPolicy.RUNTIME)
3. @Documented
4. @Inherited
5. @SpringBootConfiguration
6. @EnableAutoConfiguration
7. @ComponentScan(excludeFilters = {
8. @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
9. @Filter(type = FilterType.CUSTOM,
10. classes = AutoConfigurationExcludeFilter.class) })
11. public @interface SpringBootApplication {
12.  
13. /**
14. * Exclude specific auto-configuration classes such that they will never be applied.
15. * @return the classes to exclude
16. */
17. @AliasFor(annotation = EnableAutoConfiguration.class)
18. Class<?>[] exclude() default {};
19.  
20. /**
21. * Exclude specific auto-configuration class names such that they will never be
22. * applied.
23. * @return the class names to exclude
24. * @since 1.3.0
25. */
26. @AliasFor(annotation = EnableAutoConfiguration.class)
27. String[] excludeName() default {};

 

我们可以看出源码中使用了注解：

@AliasFor(annotation = EnableAutoConfiguration.class)

将@SpringBootApplication的exclude和excludeName属性与@EnableAutoConfiguration的属性做了一个桥接的作用。

 

 

1.3.在yml配置文件中添加排除配置

1. spring:
2. autoconfigure:
3. exclude: org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration

注：如果要排除多个类，使用逗号隔开

 

 

二、为什么可以这样排除，内在逻辑原理研究

 

springBoot将自动配置类添入到spring容器中的部分源码：

1. protected AutoConfigurationEntry getAutoConfigurationEntry(
2. AutoConfigurationMetadata autoConfigurationMetadata,
3. AnnotationMetadata annotationMetadata) {
4. if (!isEnabled(annotationMetadata)) {
5. return EMPTY_ENTRY;
6. }
7. //获取注解中配置的需要排除的自动配置类信息
8. AnnotationAttributes attributes = getAttributes(annotationMetadata);
9. //获取项目中所有的自动配置类
10. List<String> configurations = getCandidateConfigurations(annotationMetadata,
11. attributes);
12. configurations = removeDuplicates(configurations);
13. //获取配置文件中配置的需要排除的类信息，并与之前的注解中配置的数据整合在一起
14. Set<String> exclusions = getExclusions(annotationMetadata, attributes);
15. checkExcludedClasses(configurations, exclusions);
16. //将需要排除的类信息删除
17. configurations.removeAll(exclusions);
18. configurations = filter(configurations, autoConfigurationMetadata);
19. fireAutoConfigurationImportEvents(configurations, exclusions);
20. //返回最终需要的自动配置类
21. return new AutoConfigurationEntry(configurations, exclusions);
22. }

1.这段代码中的主要逻辑就是，将项目中所有需要的自动配置类的全限定名以字符串数组返回出去，后续spring容器会将所有的配置类创建成Bean

2.所以我们三种配置排除自动配置类的行为，最终都会在这段代码逻辑中体现出来，在spring容器初始化他们之前，我们就已经提前把他们从初始化的名单中排除了

3.我们配置的时候为什么都是使用的类的全限定名在这里也得到了解释，因为只有使用全限定名spring容器才能将其创建成对象。

4.还可以得出结论就是几种方式可以同时使用，最终排除的是他们的并集