SpringBoot的自动配置原理

最新推荐文章于 2023-06-19 09:25:05 发布

-abandon-

最新推荐文章于 2023-06-19 09:25:05 发布

阅读量163

点赞数 3

本文链接：https://blog.csdn.net/wasdf231/article/details/124922490

版权

SpringBoot自动配置原理

SpringBoot自动配置的核心是main()方法上面的@SpringBootApplication注解，它是SpringBoot的启动类注解，它是一个复合注解。

@SpringBootApplication
public class SpringbootQidongApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpringbootQidongApplication.class, args);
    }

}

查看源码，可以看到三个重要的注解，@SpringBootConfiguration，@EnableAutoConfiguration，@ComponentScan，其中@EnableAutoConfiguration是最重要，表示开启自动配置

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

在理解@EnableAutoConfiguration注解源码之前，我们需要知道Condition和@Enable开头的一系列注解的低层。

一、Condition

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

@Conditional()，该注解可以修饰方法也可以修饰类。

	@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Conditional {
    Class<? extends Condition>[] value();
}

当我们点击Condition查看源码，可以看到，需要传入一个Class数组，并且需要继承Condition接口：

@FunctionalInterface
public interface Condition {
    boolean matches(ConditionContext var1, AnnotatedTypeMetadata var2);
}

Condition是个接口，需要实现matches方法，返回true则注入bean，false则不注入。
**思考：**SpringBoot是如何知道要创建哪个Bean的？比如SpringBoot是如何知道要创建RedisTemplate的？

演示1:
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    1. 没有添加坐标前，发现为空，报错
        ConfigurableApplicationContext context =  SpringApplication.run(SpringbootCondition01Application.class, args);
        Object redisTemplate = context.getBean("redisTemplate");
        System.out.println(redisTemplate);
    2. 有添加坐标前，发现有对象
        ConfigurableApplicationContext context =  SpringApplication.run(SpringbootCondition01Application.class, args);
        Object redisTemplate = context.getBean("redisTemplate");
        System.out.println(redisTemplate);
    疑问，他怎么知道的配置哪个类

案例：需求1

在 Spring 的 IOC 容器中有一个 User 的 Bean，现要求：导入Jedis坐标后，加载该Bean，没导入，则不加载。
实现步骤及代码：
创建一个User实体类

	public class User {
		private String userName;
		private String sex;
}

编写UserConfig 配置类

	@Configuration
public class UserConfig {

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


}

编写ClassCondition 实现Condition 接口，覆盖重写matches()方法。

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

    }
}

最后再启动类中进行测试，如果pom.xml文件中导入Jedis坐标，打印出user的内存地址值，如果没有导入会抛出NoSuchBeanDefinitionException异常。

@SpringBootApplication
public class SpringbootCondition01Application {

    public static void main(String[] args) {
        /********************案例1********************/
        Object user = context.getBean("user");
        System.out.println(user);

    }

}

案例：需求2

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

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

实现步骤：

不使用@Conditional(ClassCondition.class)注解
自定义注解@ConditionOnClass,表示如果类不存在的话，加载就会抛出异常NoClassDefFoundError
编写ClassCondition中的matches方法

编写UserConfig 配置类，可以一次性配置多个

@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();
    }
}

在condition包下面创建两个类

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


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

    }
}

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

同样在启动类上面测试

@SpringBootApplication
public class SpringbootCondition01Application {

    public static void main(String[] args) {

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


        /********************获取容器中user********************/
//        Object user = context.getBean("user");
//        System.out.println(user);

        Object user = context.getBean("user2");
        System.out.println(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开头的注解。比如：
@EnableAsync：开启异步方法支持。
@EnableScheduling：开启计划任务
@EnableSwagger2：开启Swagger
@EnableWebMvc：开启Web Mvc配置功能；
这些注解都是用于动态启用某些功能的。而其底层原理是使用@Import注解导入一些配置类，实现Bean的动态加载

@Import注解
@Import注解可以用来导入一个或多个class，这些类会注入到spring容器中，或者配置类，配置类里面定义的bean都会被spring容器托管。
@Enable底层依赖于@Import注解导入一些类，使用@Import导入的类会被Spring加载到IOC容器中。而@Import提供4中用法：

① 导入Bean

② 导入配置类

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

④ 导入 ImportBeanDefinitionRegistrar 实现类。

三.@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 ：自动配置导入选择器，给容器中导入一些组件

AutoConfigurationImportSelector.class
    selectImports方法
this.getAutoConfigurationEntry(annotationMetadata)方法
this.getCandidateConfigurations(annotationMetadata, 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;
			↓
在所有包名叫做autoConfiguration的包下面都有META-INF/spring.factories文件

总结原理：

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

-abandon-

关注

3
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
SpringBoot的自动配置原理

SpringBoot自动配置原理SpringBoot自动配置的核心是main()方法上面的@SpringBootApplication注解，它是SpringBoot的启动类注解，它是一个复合注解。@SpringBootApplicationpublic class SpringbootQidongApplication { public static void main(String[] args) { SpringApplication.run(SpringbootQido
复制链接

扫一扫