SpringBoot自动配置

        SpringBoot的自动配置是一种让你的Spring应用更加便捷的方式，它可以帮你避免手动编写许多的配置代码。SpringBoot的自动配置是通过@EnableAutoConfiguration注解实现的，它会自动根据你添加的jar依赖来配置你的Spring应用。

一.Condition

Condition 是在 Spring 4.0 增加的条件判断功能，通过这个可以功能可以实现选择性的创建 Bean 操作。

案例1：

在 Spring 的 IOC 容器中有一个 User 的 Bean ，现要求：导入 Jedis 坐标后，加载该 Bean ，没导入，则不加载。

编写ClassCondition类，用来判断redis.clients.jedis.Jedis.class文件是否存在，代码实现如下：

public class ClassCondition implements Condition {
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        boolean flag = true;
        try {
            Class<?> cls = Class.forName("redis.clients.jedis.Jedis");
        } catch (ClassNotFoundException e) {
            flag = false;
        }
        return flag;
    }
}

编写UserConfig配置类，@Conditional中的ClassCondition.class的matches方法，返回true加载bean，否则反之

@Configuration
public class UserConfig {
    @Bean
    @Conditional(value= ClassCondition.class)
    public User user(){
        return new User();
    }
}

案例2：

在 Spring 的 IOC 容器中有一个 User 的 Bean ，现要求：将类的判断定义为动态的。判断哪个字节码文件存在可以动态指定。

实现步骤：

• 不使用@Conditional(ClassCondition.class)注解
• 自定义注解@ConditionOnClass,因为他和之前@Conditional注解功能一直，所以直接复制
• 编写ClassCondition中的matches方法

自定义ConditionOnClass注解：

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Conditional(value=ClassCondition.class)
public @interface ConditionOnClass {
    String[] value();
}

 编写ClassCondition中的matches方法：

public class ClassCondition implements Condition {
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        Map<String, Object> map =     metadata.getAnnotationAttributes(ConditionOnClass.class.getName());
        System.out.println(map);
        String[] value = (String[]) map.get("value");
        boolean flag = true;
        try {
            for (String className : value) {
                Class<?> cls = Class.forName(className);
            }
        } catch (ClassNotFoundException e) {
            flag = false;
        }
        return flag;
 
    }
}

配置类：

@Configuration
public class UserConfig {
    @Bean
    @Conditional(value = ClassCondition.class)
    @ConditionalOnClass(value = "redis.clients.jedis.Jedis")
    public User user(){
        return new User();
    }
}

condition小结： 

自定义条件：

① 定义条件类：自定义类实现 Condition 接口，重写 matches 方法，在 matches 方法中进行逻辑判

断，返回

boolean 值 。 matches 方法两个参数：

• context ：上下文对象，可以获取属性值，获取类加载器，获取 BeanFactory 等。

• metadata ：元数据对象，用于获取注解属性。

② 判断条件： 在初始化 Bean 时，使用 @Conditional( 条件类 . class ) 注解

SpringBoot 提供的常用条件注解：

一下注解在 springBoot-autoconfigure 的 condition 包下

ConditionalOnProperty ：判断配置文件中是否有对应属性和值才初始化 Bean

ConditionalOnClass ：判断环境中是否有对应字节码文件才初始化 Bean

ConditionalOnMissingBean ：判断环境中没有对应 Bean 才初始化 Bean

ConditionalOnBean ：判断环境中有对应 Bean 才初始化 Bean

可以查看 RedisAutoConfiguration 类说明以上注解使用

二.@Enable注解

SpringBoot 中提供了很多 Enable 开头的注解，这些注解都是用于动态启用某些功能的。而其底层原理是使用@Import 注 解导入一些配置类，实现 Bean 的动态加载。

@Import 注解

@Enable 底层依赖于 @Import 注解导入一些类，使用 @Import 导入的类会被 Spring 加载到 IOC 容器中。

而 @Import 提供 4 中用法：

① 导入 Bean

@SpringBootApplication
@Import(User.class)
public class Enable01Application {
    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(EnableApplication.class, args);
        User user = context.getBean(User.class);
        System.out.println(user);
    }
}

② 导入配置类

@Configuration
public class UserConfig {
    @Bean
    public User user(){
        return new User();
    }
}

③ 导入 ImportSelector 实现类。一般用于加载配置文件中的类

public class MyImportSelector implements ImportSelector {
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        //目前字符串数组的内容是写死的，未来可以设置在配置文件中动态加载
        return new String[]{"com.sxh.domain.User", "com.sxh.domain.Student"};
    }
}

④ 导入 ImportBeanDefinitionRegistrar 实现类。

public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
   
        //1.获取user的definition对象
        AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.rootBeanDefinition(User.class).getBeanDefinition();

        //2.通过beanDefinition属性信息,向spring容器中注册id为user的对象
        registry.registerBeanDefinition("user", beanDefinition);

    }
}

三.@EnableAutoConfiguration 注解 

•  主启动类

//@SpringBootApplication 来标注一个主程序类
//说明这是一个Spring Boot应用
@SpringBootApplication
public class SpringbootApplication {
public static void main(String[] args) {
//以为是启动了一个方法，没想到启动了一个服务
SpringApplication.run(SpringbootApplication.class, args);
}
}

•  @SpringBootApplication注解内部

@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(
excludeFilters = {@Filter(
type = FilterType.CUSTOM,
classes = {TypeExcludeFilter.class}
), @Filter(
type = FilterType.CUSTOM,
classes = {AutoConfigurationExcludeFilter.class}
)}
)
public @interface SpringBootApplication {
// ......
}

• @ComponentScan  

这个注解在 Spring 中很重要 , 它对应 XML 配置中的元素。

作用：自动扫描并加载符合条件的组件或者 bean ， 将这个 bean 定义加载到 IOC 容器中  

 

• @SpringBootConfiguration

作用： SpringBoot 的配置类 ，标注在某个类上 ， 表示这是一个 SpringBoot 的配置类；

//@SpringBootConfiguration注解内部
//这里的 @Configuration，说明这是一个配置类 ，配置类就是对应Spring的xml 配置文件；
@Configuration
public @interface SpringBootConfiguration {}
//里面的 @Component 这就说明，启动类本身也是Spring中的一个组件而已，负责启动应用
@Component
public @interface Configuration {}

• @AutoConfigurationPackage ：自动配置包

//AutoConfigurationPackage的子注解
//Registrar.class 作用：将主启动类的所在包及包下面所有子包里面的所有组件扫描到Spring容器
@Import({Registrar.class})
public @interface AutoConfigurationPackage {
}

•  @EnableAutoConfiguration开启自动配置功能

以前我们需要自己配置的东西，而现在SpringBoot可以自动帮我们配置 ；

• @EnableAutoConfiguration

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

• @Import({AutoConfigurationImportSelector.class}) ：给容器导入组件 ；

AutoConfigurationImportSelector ：自动配置导入选择器，给容器中导入一些组件

总结原理：

@EnableAutoConfiguration 注解内部使用 @Import(AutoConfigurationImportSelector. class )

来加载配置类。

配置文件位置： META-INF/spring.factories ，该配置文件中定义了大量的配置类，当 SpringBoot

应用启动时，会自动加载这些配置类，初始化 Bean

并不是所有的 Bean 都会被初始化，在配置类中使用 Condition 来加载满足条件的 Bean