关于SpringBoot AutoConfiguration

（1）如何导入的自动配置类

首先我们得从@SpringBootApplication注解入手。

@SpringBootApplication

public class SpringBootDemoApplication {  

    public static void main(String[] args) {

        SpringApplication.run(SpringBootDemoApplication.class, args);

    }  

}

@SpringBootApplication = @EnableAutoConfiguration + @ComponentScan + @SpringBootConfiguration

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

)}

)

public @interface SpringBootApplication {

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

    @AliasFor(

        annotation = ComponentScan.class,

        attribute = "nameGenerator"

    )

    Class<? extends BeanNameGenerator> nameGenerator() default BeanNameGenerator.class;

    @AliasFor(

        annotation = Configuration.class

    )

    boolean proxyBeanMethods() default true;

}

其中@EnableAutoConfiguration注解是一个组合注解，@AutoConfigurationPackage 表示自动配置包与@Import({AutoConfigurationImportSelector.class})

1、@AutoConfigurationPackage

作用：给Spring容器中导入一个Registrar注册组件

@Target({ElementType.TYPE})

@Retention(RetentionPolicy.RUNTIME)

@Documented

@Inherited

@Import({AutoConfigurationPackages.Registrar.class})

public @interface AutoConfigurationPackage {

    String[] basePackages() default {};

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

}

@AutoConfigurationPackage和@ComponentScan一样，也是将主配置类所在的包以及子包里面的组件扫描到IOC容器中，但是区别是 @AutoConfigurationPackage扫描@Enitity、@MapperScan等第三方依赖的注解。 @ComponentScan只扫描@Controller、@Service、@Component、@Repository这些常见注解。所以说这俩注解的对象是不一样的。

2、@Import({AutoConfigurationImportSelector.class})

而@Import({AutoConfigurationImportSelector.class})

@Target({ElementType.TYPE})

@Retention(RetentionPolicy.RUNTIME)

@Documented

@Inherited

@AutoConfigurationPackage

@Import({AutoConfigurationImportSelector.class})

public @interface EnableAutoConfiguration {

    String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";

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

    String[] excludeName() default {};

}

在AutoConfigurationImportSelector下可以看到 getCandidateConfigurations方法

    protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {

        List<String> configurations = SpringFactoriesLoader.loadFactoryNames(this.getSpringFactoriesLoaderFactoryClass(), this.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;

    }

通过SpringFactoriesLoader.loadFactoryNames（）

将spring-boot-autoconfigure-2.3.12.RELEASE.jar/META-INF/spring.factories 下配置导入configurations并返回。

总结自动装配的过程

1、通过各种注解的方式实现类与类之间的依赖关系，容器在启动的时候SpringApplication.run()，调用了EnableAutoConfigurationImportSelector.class的selectImports方法。

2、selectImporys方法调用了SpringFactoriesLoader.loadFactoryNames方法扫描jar包类路径下的META-INF/spring.factories文件下获取BEANConfiguration列表。

3、loadFactoryNames方法会读取spring.factoris文件中EnableAutoConfiguration.class类对应的值。

4、根据类上的注解判断，若符合条件则改配置类生效，将配置文件中的属性值配置到对应的配置类中，最后注入到IOC容器中实现自动配置。

（2）@Conditional 的魔力

为了让有条件性注册 Spring bean 变得更加灵活，Spring 4 引入了 @Conditional 概念。通过使用 @Conditional 方式，你可以根据任意条件注册一个 bean。

例如，你可能想在如下情况注册一个 bean：

• classpath 中某个类
• 某种类型的 Spring bean，尚未在 ApplicationContext 中注册
• 存放在某个位置的某个文件
• 一个存在于配置文件中的某个属性值
• 一个存在/不存在的某个系统属性

这里只是列举了几个例子，你可以根据自己的需要定义任何条件。

让我们来看看 Spring 的 @Conditional 是如何工作的。

假设我们有一个 UserDAO 接口，其包含从数据存储中获取数据的方法。我们有两个 UserDAO 接口的实现，即 JdbcUserDAO（与 MySQL 数据库通信）和 MongoUserDAO（与 MongoDB 通信）。

我们可能想通过基于系统属性 dbType 来只启用 JdbcUserDAO 或 MongoUserDAO 其中一个。

如果应用程序使用了 java -jar myapp.jar -DdbType = MySQL 启动，则启用 JdbcUserDAO，如果启动时使用了 java -jar myapp.jar -DdbType = MONGO，则启用 MongoUserDAO。

假设我们有 UserDAO 接口，以下是 JdbcUserDAO 和 MongoUserDAO 实现类：

public interface UserDAO

{

    List<String> getAllUserNames();

}

 

public class JdbcUserDAO implements UserDAO

{

    @Override

    public List<String> getAllUserNames()

    {

        System.out.println("**** Getting usernames from RDBMS *****");

        return Arrays.asList("Siva","Prasad","Reddy");

    }

}

 

public class MongoUserDAO implements UserDAO

{

    @Override

    public List<String> getAllUserNames()

    {

        System.out.println("**** Getting usernames from MongoDB *****");

        return Arrays.asList("Bond","James","Bond");

    }

}

我们可以实现一个 MySQLDatabaseTypeCondition Condition 来检查系统属性是否是 MYSQL：

public class MySQLDatabaseTypeCondition implements Condition

{

    @Override

    public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata metadata)

    {

        String enabledDBType = System.getProperty("dbType");

        return (enabledDBType != null && enabledDBType.equalsIgnoreCase("MYSQL"));

    }

}

现在我们可以使用 @Conditional 条件性地配置 JdbcUserDAO 和 MongoUserDAO bean，如下所示：

@Configuration

public class AppConfig

{

    @Bean

    @Conditional(MySQLDatabaseTypeCondition.class)

    public UserDAO jdbcUserDAO(){

        return new JdbcUserDAO();

    }

    @Bean

    @Conditional(MongoDBDatabaseTypeCondition.class)

    public UserDAO mongoUserDAO(){

        return new MongoUserDAO();

    }

}

如果我们使用 java -jar myapp.jar -DdbType = MYSQL 来运行应用程序，则只有 JdbcUserDAO bean 被注册。

但如果将系统属性设置为 -DdbType = MONGODB，则只会注册 MongoUserDAO bean。

使用注解实现 Condition 的方式更为优雅，我们可以创建一个 DatabaseType 注解，如下所示：

@Target({ ElementType.TYPE, ElementType.METHOD })

@Retention(RetentionPolicy.RUNTIME)

@Conditional(DatabaseTypeCondition.class)

public @interface DatabaseType

{

    String value();

}

然后可以通过编写 DatabaseTypeCondition 使用 DatabaseType 的值来确定是否启用或禁用 bean 注册，如下所示：

public class DatabaseTypeCondition implements Condition

{

    @Override

    public boolean matches(ConditionContext conditionContext,

    AnnotatedTypeMetadata metadata)

    {

        Map<String, Object> attributes = metadata.getAnnotationAttributes(DatabaseType.class.getName());

        String type = (String) attributes.get("value");

        String enabledDBType = System.getProperty("dbType","MYSQL");

        return (enabledDBType != null && type != null && enabledDBType.equalsIgnoreCase(type));

    }

}

现在我们可以将 @DatabaseType 注解放置在 bean 定义上：

@Configuration

@ComponentScan

public class AppConfig

{

    @DatabaseType("MYSQL")

    public UserDAO jdbcUserDAO(){

        return new JdbcUserDAO();

    }

 

    @Bean

    @DatabaseType("MONGO")

    public UserDAO mongoUserDAO(){

        return new MongoUserDAO();

    }

}

此处，我们从 DatabaseType 注解获取元数据，并检查系统属性 dbType 的值以确定是否启用或禁用 bean 注册。

我们已经看了许多示例，了解了如何使用 @Conditional 注解条件性地注册 bean。

SpringBoot 大量地使用了 @Conditional 特性，根据各种标准条件性地注册 bean。

你可以在 Spring-boot-autoconfigure- {version} .jar 的 org.springframework.boot.autoconfigure 包中找到 SpringBoot 使用的各种 Condition 实现。

（3）如何关闭自动配置

全体无效化

a）使用@Configuration @ComponentScan 代替 @SpringBootApplication。

b）参数设置

src/main/resources/application.properties

设置spring.boot.enableautoconfiguration=false

部分无效化

@SpringBootApplication(exclude=HibernateJpaAutoConfiguration.class)

或

src/main/resources/application.properties

spring.autoconfigure.exclude=org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration

@SpringBootApplication(exclude={DataSourceAutoConfiguration.**class**, DataSourceTransactionManagerAutoConfiguration.**class**, HibernateJpaAutoConfiguration.**class**})

或

src/main/resources/application.properties

spring.autoconfigure.exclude[0]=org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration

spring.autoconfigure.exclude[1]=org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration

spring.autoconfigure.exclude[2]=org.springframework.boot.autoconfigure.jdbc.DataSourceTransactionManagerAutoConfiguration

spring.autoconfigure.exclude[3]=org.springframework.boot.autoconfigure.data.web.SpringDataWebAutoConfiguration

以上内容均来自下面三篇文章，本人只是自己做了个总结，方便以后学习，如有侵权，请告知我，马上删除！

引用：

SpringBoot自动装配以及原理 - Be_Your_Sun - 博客园 (cnblogs.com)

Spring Boot 入门 - 进阶篇（7）- 自动配置(AutoConfigure) - Fish Where The Fish Are - ITeye博客

了解 Spring Boot AutoConfiguration - oopsguy - 博客园 (cnblogs.com)

了解 Spring Boot AutoConfiguration - oopsguy - 博客园 (cnblogs.com)