十四、SpringBoot-自动装配原理

SpringBoot与Spring比较起来，优化的点主要有：

• 自动配置：是一个运行时（应用程序启动时）的过程，考虑了众多因素，才决定Spring配置应该用哪个，不该用哪个，此过程是SpringBoot自动完成
• 起步依赖：是一个Maven项目对象模型，定义了对其他库的传递依赖，这些东西加在一起支持某项功能，即将具有某种功能的坐标打包到一起，提供一些默认的功能
• 辅助功能：提供一些大型项目中常见的非功能性特性，如嵌入式服务器、安全、指标、健康检测等

SpringBoot不能直接从jar包或者其他项目中获取Bean，可以通过以下方式获取

• 1、使用ComponentScan扫描
• 2、使用@Import注解加载
• 3、对Import注解进行封装

SpringBoot项目当我们想使用某个非自定义Bean时，通常只需要@Bean就能获取，不用再特殊引入依赖或者指定Bean，这就是用到了SpringBoot的自动配置，它的的实现就用到了几个重要的注解：

• Enable系列注解：动态开启某些功能，底层原理是使用@Import注解导入一些配置类，实现Bean的动态加载
• @Import：注解导入类，会加载到SpringIOC容器中
• Condition系列注解：条件判断，可以实现选择性的创建Bean操作

---

Enable系列注解：

假设现在项目A引用了依赖B，需要获取通过自定义@Enable获取到依赖B中的Bean信息

依赖B中的Bean信息

有一个为User的类

public class User {
    private String name;
}

对应的有一个UserConfig配置类

@Configuration
public class UserConfig {

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

}

这时候再自定义一个 @EnableUser 注解

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(UserConfig.class)
public @interface EnableUser {
}

这时候就可以将依赖B的坐标导入到项目A中，在项目A中获取此User的B

@SpringBootApplication
@EnableUser
public class SpringbootEnableApplication {

    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(SpringbootEnableApplication.class, args);

        Object user = context.getBean("user");
        System.out.println(user);

    }

}

---

@Import注解

使用@Import注解导入类，会加载到SpringIOC容器中，有4种导入方式：

• 1、导入Bean
• 2、导入配置类
• 3、导入ImportSelector实现类，一般用于加载配置文件中的类
• 4、导入ImportBeanDefinitionRegistrar实现类

有一个为User的类

public class User {
    private String name;
}

导入Bean

直接使用@Import（类名.class）导入

@SpringBootApplication
@Import(User.class)
public class SpringbootEnableApplication {

    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(SpringbootEnableApplication.class, args);

        Object user = context.getBean("user");
        System.out.println(user);

    }

}

导入配置类

首先创建配置类，对应的有一个UserConfig配置类

@Configuration
public class UserConfig {

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

}

使用@Import（配置类类名.class）导入

@SpringBootApplication
@Import(UserConfig.class)
public class SpringbootEnableApplication {

    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(SpringbootEnableApplication.class, args);

        Object user = context.getBean("user");
        System.out.println(user);

    }

}

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

实现ImportSelector接口，实现selectImports(AnnotationMetadata annotationMetadata)方法

public class MyImportSelector implements ImportSelector {
    @Override
    public String[] selectImports(AnnotationMetadata annotationMetadata) {
        return new String[]{"com.myinport.domain.User"};
    }
}

使用@Import（ImportSelector实现类类名.class）导入

@SpringBootApplication
@Import(MyImportSelector.class)
public class SpringbootEnableApplication {

    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(SpringbootEnableApplication.class, args);

        Object user = context.getBean("user");
        System.out.println(user);

    }

}

导入ImportBeanDefinitionRegistrar实现类

实现ImportBeanDefinitionRegistrar接口

public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata annotationMetadata, BeanDefinitionRegistry beanDefinitionRegistry) {
        AbstractBeanDefinition beanDefinition =
                BeanDefinitionBuilder.rootBeanDefinition(User.class).getBeanDefinition();
        beanDefinitionRegistry.registerBeanDefinition("user",beanDefinition);
    }
}

使用@Import（ImportBeanDefinitionRegistrar实现类类名.class）导入

@SpringBootApplication
@Import(MyImportBeanDefinitionRegistrar.class)
public class SpringbootEnableApplication {

    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(SpringbootEnableApplication.class, args);

        Object user = context.getBean("user");
        System.out.println(user);

    }

}

---

Condition，条件判断

@Conditional注解内判断Condition接口实现类的matches返回值是否为true，还有@ConditionalOnProperty判断属性是否正确、@ConditionalOnClass判断class是否存在、@ConditionalOnMissingBean判断是否存在自定义同名Bean注解，

下面以三种例子来判断要不要加载User的Bean信息

User类

public class User {
    private String name;
}

@Conditional用法示例：

实现Condition接口，返回是否加载

public class ClassCondition implements Condition {
    @Override
    public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) {
    	return true;
    }
}

对应有一个配置类

@Configuration
public class UserConfig {

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

这时候因为返回值恒为true，则能获取到Bean信息

@SpringBootApplication
public class SpringbootConditionApplication {

    public static void main(String[] args) {

        //启动SpringBoot的应用，返回Spring的IOC容器
        ConfigurableApplicationContext context = SpringApplication.run(SpringbootConditionApplication.class, args);

        Object user = context.getBean("user");
        System.out.println(user);

    }

}

@ConditionOnClass示例：

配置类信息，判断若存在redis.clients.jedis.Jedis的Bean信息，则加载User的Bean信息

@Configuration
public class UserConfig {

    @Bean
    @ConditionOnClass({"redis.clients.jedis.Jedis"})
    public User user() {
        return new User();
    }

}

当然也可以用实现Condition接口做到，返回是否加载

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

        return flag;

    }
}

ConditionalOnProperty示例：

对应的配置类

@Configuration
public class UserConfig {

    @Bean
    @ConditionalOnProperty(name = "myKey",havingValue = "myValue")
    public User user() {
        return new User();
    }
}

对应的配置文件

myKey=myValue

这样也能判断是否加载User的Bean信息

---

自动装配源码

从SpringBoot项目的启动类配置进入 @SpringBootApplication注解

@SpringBootApplication注解内部含有 @EnableAutoConfiguration注解

@EnableAutoConfiguration注解内部Import了AutoConfigurationImportSelector类

观察类中的方法执行

然后此方法就会去查找引用的起步依赖jar包中的 META-INF/spring.factories 中指定的加载信息，以spring-boot-autoconfigure包为例

它就会通过Conditional系列的注解去判断，此Bean信息是否应该加载。

整体流程就是：@SpringBootApplication -> @EnableAutoConfiguration -> AutoConfigurationImportSelector -> selectImports() -> SpringFactoriesLoader.loadFactoryNames() -> META-INF/spring.factories，再根据Condition进行判断是否加载进SpringIOC中