SpringBoot自动配置原理

猿究院崔世博

已于 2024-10-02 14:43:00 修改

阅读量614

点赞数 22

于 2024-10-02 14:27:42 首次发布

本文链接：https://blog.csdn.net/weixin_58693169/article/details/142680410

版权

SpringBoot 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

一、@SpringBootApplication

我们的启动类上有@SpringBootApplication注解

进入注解内部

其中三个注解：

@SpringBootConofiguration：子注解@SpringBootConfiguration，间接被@Configuration修饰，即启动类是一个源配置类

@EnableAutoConfiguration：

进入注解内部：

可以看到@EnableAutoConfiguration内部导入了一个

AutoConfigurationImportSelector的类

进入类的内部：

发现该类实现了ImportSelector接口，然后类中重写了selectImports()方法：

进入方法内部：

细分下来就是五步：

1.获取annotationMetadata 的注解 @EnableAutoConfiguration 的属性：

AnnotationAttributes attributes = this.getAttributes(annotationMetadata);

2.从资源文件 spring.factorys 中获取EnableAutoConfiguration 对应的所有的类
List<String> configurations = this.getCandidateConfigurations(annotationMetadata, attributes);
configurations = this.removeDuplicates(configurations);

3.通过注解 @EnableAutoConfiguration 设置 exclude 的相关属性，可以排除指定的自动配置类
Set<String> exclusions = this.getExclusions(annotationMetadata, attributes);
this.checkExcludedClasses(configurations, exclusions);
configurations.removeAll(exclusions);

4.根据注解@Conditional来判断是否需要排除某些自动配置类
configurations = this.getConfigurationClassFilter().filter(configurations);

5.触发AutoConfiguration导入的相关事件
this.fireAutoConfigurationImportEvents(configurations, exclusions);
return new AutoConfigurationImportSelector.AutoConfigurationEntry(configurations, exclusions);

其中第2步的方法getCandidateConfigurations(annotationMetadata, attributes);指的是通过SpringFactories机制，从配置文件META/INF/spring.factories 中找出所有的自动配置类

总结原理：

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

@ComponentScan：对指定路径的包扫描，这里指的是对对源配置类所在的Package进行组件扫描,也就是为什么代码要写在启动类的同级目录中的原因。

二、@Conditional

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

案例一：

在 Spring 的 IOC 容器中有一个 User 的 Bean，现要求：

1. 导入Jedis坐标后，加载该Bean，没导入，则不加载。

（1）创建User

package com.apesource.springboot_condition01.bean;

/**
 * @author 崔世博
 * @version 1.0
 * @since 2024/9/26
 */
public class User {
    
}

（2）创建ClassCondition重写mataches方法

package com.apesource.springboot_condition01.condition;

import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.type.AnnotatedTypeMetadata;

/**
 * @author 崔世博
 * @version 1.0
 * @since 2024/9/26
 */
public class ClassCondition implements Condition {
    /**
     * @param context  上下文对象。用于获取环境，IOC容器，ClassLoader对象
     * @param metadata 注解元对象。 可以用于获取注解定义的属性值
     * @return
     */
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        boolean flag = true;
        try {
            //1.需求： 导入Jedis坐标后创建Bean
            //思路：判断redis.clients.jedis.Jedis.class文件是否存在
            //通过反射方式创建对象，如果创建成功说明已经加入坐标可以返回true
            Class<?> aClass = Class.forName("redis.clients.jedis.Jedis");
        } catch (ClassNotFoundException e) {
            flag = false;
        }
        return flag;
    }
}

（3）创建配置类UserConfig

package com.apesource.springboot_condition01.config;

import com.apesource.springboot_condition01.bean.User;
import com.apesource.springboot_condition01.condition.ClassCondition;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Conditional;
import org.springframework.context.annotation.Configuration;

/**
 * @author 崔世博
 * @version 1.0
 * @since 2024/9/26
 */
@Configuration
public class UserConfig {

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

（4）启动类中进行测试

package com.apesource.springboot_condition01;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;

@SpringBootApplication
public class SpringbootCondition01Application {

    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(SpringbootCondition01Application.class, args);
        //获取Bean，redisTemplate
        //情况1 没有添加坐标前，发现为空
        //情况2 有添加坐标前，发现有对象
//        Object redisTemplate = context.getBean("redisTemplate");
//        System.out.println(redisTemplate);

        /********************案例1********************/
        Object user = context.getBean("user");
        System.out.println(user);


    }

}

测试结果：

在没有添加jedis依赖时会报错表示容器中没有命名为user的bean对象：

添加jedis依赖后成功在控制台输出对象地址：

        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
        </dependency>

案例：需求2

在 Spring 的 IOC 容器中有一个 User 的 Bean，现要求：

将类的判断定义为动态的。判断哪个字节码文件存在可以动态指定

实现步骤：

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

（1）创建User类

package com.apesource.springboot_condition02.bean;

/**
 * @author 崔世博
 * @version 1.0
 * @since 2024/9/26
 */
public class User {
}

（2）创建ClassCondition类

package com.apesource.springboot_condition02.condition;

import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.type.AnnotatedTypeMetadata;
import org.springframework.util.MultiValueMap;

import java.util.List;
import java.util.Map;

/**
 * @author 崔世博
 * @version 1.0
 * @since 2024/9/26
 */
public class ClassCondition implements Condition {
    /**
     * @param context  上下文对象。用于获取环境，IOC容器，ClassLoader对象
     * @param metadata 注解元对象。 可以用于获取注解定义的属性值
     * @return
     */
    @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;
    }
}

（3）自定义注解ConditionOnClass

package com.apesource.springboot_condition02.condition;

import org.springframework.context.annotation.Conditional;

import java.lang.annotation.*;

/**
 * @author 崔世博
 * @version 1.0
 * @since 2024/9/26
 */
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Conditional(ClassCondition.class)
public @interface ConditionOnClass {
    String[] value();
}

（4）创建UserConfig配置类

package com.apesource.springboot_condition02.config;

import com.apesource.springboot_condition02.bean.User;
import com.apesource.springboot_condition02.condition.ConditionOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Conditional;
import org.springframework.context.annotation.Configuration;

/**
 * @author 崔世博
 * @version 1.0
 * @since 2024/9/26
 */
@Configuration
public class UserConfig {
    @Bean
    @ConditionOnClass("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();
    }
}

（5）在启动类中测试

package com.apesource.springboot_condition02;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;

@SpringBootApplication
public class SpringbootCondition02Application {

    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(SpringbootCondition02Application.class, args);
        System.out.println(context.getBean("user"));
        System.out.println(context.getBean("user2"));

    }

}

（6）测试结果：

如果导入jedis依赖,user成功注入容器，否则失败

如果在application.properties中存在键值对k1=v1则user2成功注入容器，否则失败

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

② 导入配置类

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

④ 导入 ImportBeanDefinitionRegistrar 实现类。

四.自定义启动器

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

参考：可以参考mybatis启动类的应用

实现步骤：

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

（1）创建redis-spring-boot-autoconfigure模块：

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

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

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

创建类RedisProperties用来读取配置文件。

package com.apesource;

import org.springframework.boot.context.properties.ConfigurationProperties;

/**
 * @author 崔世博
 * @version 1.0
 * @since 2024/9/27
 */
//扫描资源文件中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;
    }
}

创建配置类RedisAutoConfiguration

package com.apesource;

import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import redis.clients.jedis.Jedis;

/**
 * @author 崔世博
 * @version 1.0
 * @since 2024/9/27
 */
@Configuration
@EnableConfigurationProperties(RedisProperties.class)
public class RedisAutoConfiguration {
    //注入Jedis
    @Bean
    @ConditionalOnMissingBean(Jedis.class)//判断 如果容器中没有jedis注入
    public Jedis jedis(RedisProperties redisProperties) {
        return new Jedis(redisProperties.getHost(), redisProperties.getPort());
    }
}

在Resource目录下创建文件METAINF/spring.factories文件

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
  com.apesource.RedisAutoconfiguration

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

添加依赖：

        <dependency>
            <groupId>com.apesource</groupId>
            <artifactId>redis-springboot-starter</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>

在启动类中进行测试

package com.apesource.springboot_starter_04;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
import redis.clients.jedis.Jedis;

@SpringBootApplication
public class SpringbootStarter04Application {

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

    }

}

运行结果：

因为没有引入Redis坐标所以自动注入了Jedis