SpringBoot自动配置--原理探究

大汉堡~

于 2024-08-18 16:42:24 发布

阅读量486

点赞数 19

本文链接：https://blog.csdn.net/2301_76207358/article/details/141256295

版权

什么是自动配置？

SpringBoot自动配置是指在SpringBoot应用启动时，可以把一些配置类自动注入到Spring的IOC容器中，项目运行时可以直接使用这些配置类的属性。简单来说就是用注解来对一些常规的配置做默认配置，简化xml配置内容，使项目快速运行。

一.Condition

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

案例：需求1

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

实现步骤：

① 定义条件类：自定义类实现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

代码实现如下：

public class ClassCondition implements Condition {
    
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        //1.需求： 导入Jedis坐标后创建Bean
        //思路：判断redis.clients.jedis.Jedis.class文件是否存在

        boolean flag = true;
        try {
            Class<?> cls = Class.forName("redis.clients.jedis.Jedis");
        } catch (ClassNotFoundException e) {
            flag = false;
        }
        return flag;

    }
}

配置类：

@Configuration
public class UserConfig {
    //@Conditional中的ClassCondition.class的matches方法，返回true执行以下代码，否则反之
    @Bean
    @Conditional(value= ClassCondition.class)
    public User user(){
        return new User();
    }
}

测试：

@SpringBootApplication
public class SpringbootCondition01Application {
    public static void main(String[] args) {

        //启动SpringBoot的应用，返回Spring的IOC容器
        ConfigurableApplicationContext context =  SpringApplication.run(SpringbootCondition01Application.class, args);
      
        Object user = context.getBean("user");
        System.out.println(user);
    }
}

案例：需求2

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

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

自定义注解@ConditionOnClass：

@Target({ElementType.TYPE, ElementType.METHOD})//可以修饰在类与方法上
@Retention(RetentionPolicy.RUNTIME)//注解生效节点runtime
@Documented//生成文档
@Conditional(value=ClassCondition.class)
public @interface ConditionOnClass {
    String[] value();//设置此注解的属性redis.clients.jedis.Jedis
}

ClassCondition类：

public class ClassCondition implements Condition {
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        //2.需求： 导入通过注解属性值value指定坐标后创建Bean
        //获取注解属性值  value
        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 {
    //情况1
    @Bean
//    @Conditional(ClassCondition.class)
//    @ConditionOnClass(value="redis.clients.jedis.Jedis")
    @ConditionOnClass(value={"com.alibaba.fastjson.JSON","redis.clients.jedis.Jedis"})
    public User user(){
        return new User();
    }

    //情况2
    @Bean
    //当容器中有一个key=k1且value=v1的时候user2才会注入
    //在application.properties文件中添加k1=v1
    @ConditionalOnProperty(name = "k1",havingValue = "v1")
    public User user2(){
        return new User();
    }

}

测试：

@SpringBootApplication
public class SpringbootCondition02Application {
    public static void main(String[] args) {
        //启动SpringBoot的应用，返回Spring的IOC容器
        ConfigurableApplicationContext context =  SpringApplication.run(SpringbootCondition02Application.class, args);
        Object user2 = context.getBean("user2");
        System.out.println(user2);
    }
}

二.@Enable注解

这里引入多模块的概念：

比起传统复杂的单体工程，使用Maven的多模块配置，可以帮助项目划分模块，鼓励重用，防止pom变得过于庞大，方便某个模块的构建，而不用每次都构建整个项目。

1.首先使用 Spring Initializr 来快速创建好一个Maven项目。这是子项目，在子项目里写相关功能类。

2.然后在父项目的 pom.xml 里面声明该父项目包含的子模块。（其它信息就不逐一讲述了，诸如继承SpringBoot官方父项目以及统一依赖管理）

实例如下：

1.子项目构建好实现类

2.父项目导入子项目的模块坐标，然后进行使用

    <!--导入坐标-->
    <dependency>
        <groupId>com.wei</groupId>
        <artifactId>enable02</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </dependency>
</dependencies>

回归正题——————————————————————————————————————————

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

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

而@Import提供4种用法：

接下来的实例使用了上述所说的多模块，子项目写相关功能类及自定义注解，父项目导入子项目坐标，完成重用

① 导入Bean

直接写好实体类，使用@Import注解导入即可

@SpringBootApplication
@Import(User.class)
public class Enable01Application {
    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(Enable01Application.class, args);

        //获取Bean
        User user = context.getBean(User.class);
        System.out.println(user);
    }
}

② 导入配置类

配置类：

@Configuration
public class UserConfig {

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

导入配置类并测试：

@SpringBootApplication
@Import(UserConfig.class)
public class Enable01Application {
    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(Enable01Application.class, args);

        //获取Bean
        User user = context.getBean(User.class);
        System.out.println(user);
   }
}

③ 导入 ImportSelector 实现类

一般用于加载配置文件中的类：

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

导入ImportSelector的实现类并测试：

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

④ 导入 ImportBeanDefinitionRegistrar 实现类

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

    }
}

导入ImportBeanDefinitionRegistrar的实现类并测试：

@SpringBootApplication
@Import(MyImportBeanDefinitionRegistrar.class)
public class Enable01Application {
    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(Enable01Application.class, args);

        //获取Bean
        User user = context.getBean(User.class);
        System.out.println(user);
    }
}

三、@EnableAutoConfiguration 注解

主启动类：springboot启动类上有一个@SpringBootApplication注解，这是springboot项目一个必不可少的注解。

@SpringBootApplication 来标注一个主程序类，说明这是一个Spring Boot应用

@SpringBootApplication
 public class SpringbootApplication {
 public static void main(String[] args) {
 //以为是启动了一个方法，没想到启动了一个服务
    SpringApplication.run(SpringbootApplication.class, args);
 }
 }

@SpringBootApplication注解内部：

@SpringBootApplication是一个复合注解，其中包含了@SpringBootConfiguration、@EnableAutoConfiguration、@ComponentScan注解

下面我们分别展开看看：

1.@ComponentScan

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

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

2.@SpringBootConfiguration

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

3.@EnableAutoConfiguration开启自动配置功能

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

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

接下来@EnableAutoConfiguration注解如何开启自动配置，@EnableAutoConfiguration也是一个复合注解，关键部分在它导入的AutoConfigurationImportSelector类中。

@Import({AutoConfigurationImportSelector.class}) ：给容器导入组件； AutoConfigurationImportSelector ：自动配置导入选择器，给容器中导入一些组件；

在AutoConfigurationImportSelector类中有一个selectImports()方法，通过SpringFactoriesLoader.loadFactoryNames()扫描所有具有META-INF/spring.factories的jar包，获取获取spring.factories中key为org.springframework.boot.autoconfigure.EnableAutoConfiguration的值（配置类名），然后把这些类导入到spring的ioc容器中。

总结原理：

@EnableAutoConfiguration 注解内部使用 @Import(AutoConfigurationImportSelector.class) 来加载配置类。
配置文件位置：META-INF/spring.factories，该配置文件中定义了大量的配置类，当 SpringBoot 应用启动时，会自动加载这些配置类，初始化Bean
并不是所有的Bean都会被初始化，在配置类中使用Condition来加载满足条件的Bean

四、自定义启动器

需求：自定义redis-starter，要求当导入redis坐标时，SpringBoot自动创建Jedis的Bean

实现步骤：

创建redis-spring-boot-autoconfigure模块
创建redis-spring-boot-starter模块,依赖redis-spring-boot-autoconfigure的模块
在redis-spring-boot-autoconfigure模块中初始化Jedis的Bean，并定义META INF/spring.factories文件
在测试模块中引入自定义的redis-starter依赖，测试获取Jedis的Bean，操作redis

创建redis-spring-boot-autoconfigure模块

1、编写一个配置类，这个配置类使用@ConfigurationProperties注解与全局配置文件中的以spring.redis开头的一组配置文件绑定。

@ConfigurationProperties(prefix = "spring.redis")
public class RedisProperties {
    private String host="localhost";
    private int port = 6379;

    public String getHost() {
        return host;
    }

    public void setHost(String host) {
        this.host = host;
    }

    public int getPort() {
        return port;
    }

    public void setPort(int port) {
        this.port = port;
    }
}

2、编写一个自动配置加载类，这个类将使用@EnableConfigurationProperties注解将配置类加载到spring的ioc容器中。

@Configuration
@EnableConfigurationProperties(RedisProperties.class)
public class RedisAutoconfiguration {
    //注入jedis
    @Bean
    public Jedis jedis(RedisProperties redisProperties){
        return new Jedis(redisProperties.getHost(),redisProperties.getPort());
    }
}

3、将编写的自动配置类添加到resources/META-INF/spring.factories（新建一个即可）中EnableAutoConfiguration的值中。

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
  com.wei.redisspringbootautoconfigure.RedisAutoconfiguration

创建redis-spring-boot-starter模块,依赖redis-spring-boot-autoconfigure的模块

<!--引入自定义的redis-spring-boot-autoconfigure-->
<dependency>
    <groupId>com.wei</groupId>
    <artifactId>redis-spring-boot-autoconfigure</artifactId>
    <version>0.0.1-SNAPSHOT</version>
</dependency>

在测试模块中引入自定义的redis-starter依赖，测试获取Jedis的Bean，操作redis

1.导入redis-spring-boot-starter坐标

<!--导入坐标-->
<dependency>
    <groupId>com.wei</groupId>
    <artifactId>redis-spring-boot-starter</artifactId>
    <version>0.0.1-SNAPSHOT</version>
</dependency>

2.测试获取Jedis的Bean，操作redis

@SpringBootApplication
public class SpringbootStarterTestApplication {

    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(SpringbootStarterTestApplication.class, args);
        Jedis bean = context.getBean(Jedis.class);
        System.out.println(bean);
    }

}