0
0

SpringBoot 自动配置原理

一、什么是SpringBoot自动配置

    SpringBoot自动配置是指Spring Boot能够根据项目中添加的依赖、配置文件和类路径下的类自动配置Spring应用程序，极大地简化开发者的配置工作，提高开发效率。SpringBoot的自动配置是通过

@EnableAutoConfiguration

注解实现的，它会自动根据你添加的jar依赖来配置你的Spring应用。

二、SpringBoot是如何实现自动配置的

在了解自动配置原理之前，我们需要先了解几个重要的核心注解：

1.Condition注解

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

案例：

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

  1. 导入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<?> aClass = Class.forName("redis.clients.jedis.Jedis");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
            flag = false;
        }
        return flag;
    }
}

编写UserConfig配置类，@Conditional中的ClassCondition.class的matches方法，返回true加载bean，返回false不加载


@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) {
        ConfigurableApplicationContext run = SpringApplication.run(SpringbootCondition01Application.class, args);
        Object user = run.getBean("user");
        System.out.println(user);
 
    }
 
}

如果没有添加坐标，发现为空会将配置文件jedis坐标注释或删除，有添加坐标，发现有对象会恢复jedis坐标。

小结：

自定义条件：

① 定义条件类：自定义类实现Condition接口，重写 matches 方法，在 matches 方法中进行逻辑判断，返回boolean值 。 matches 方法两个参数：

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

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

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

SpringBoot 提供的常用条件注解：

这些注解在springBoot-autoconfifigure的condition包下

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

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

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

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

**@Import****注解 **

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

而@Import提供四种用法：

① 导入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.ape.springboot_unable_04.domain.User","com.ape.springboot_unable_04.domain.User"};
    }
}

④ 导入 ImportBeanDefifinitionRegistrar 实现类。 

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);
 
    }
}
**3.@EnableAutoConfifiguration ****注解 **

主启动类

//@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容器中；

**@SpringBootConfifiguration **

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

@AutoConfifigurationPackage ：自动配置包；

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

@EnableAutoConfifiguration：开启自动配置功能；

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

@EnableAutoConfiguration开启自动配置功能
以前我们需要自己配置的东西，而现在SpringBoot可以自动帮我们配置 ；

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

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

**总结原理： **

@EnableAutoConfifiguration 注解内部使用 @Import(AutoConfifigurationImportSelector.class) 来加载配置类。

配置文件位置：META-INF/spring.factories，该配置文件中定义了大量的配置类，当 SpringBoot应用启动时，会自动加载这些配置类，初始化Bean。

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

4.自定义启动器

**需求： **

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

**参考： **

可以参考mybatis启动类的应用

**实现步骤： **

（1）创建redis-spring-boot-autoconfifigure模块

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

（3）在redis-spring-boot-autoconfifigure模块中初始化Jedis的Bean，并定义META

INF/spring.factories文件 

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

package com.apesource;
 
import org.springframework.boot.context.properties.ConfigurationProperties;
 
@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;
@Configuration
@EnableConfigurationProperties(RedisProperties.class)
public class RedisAutoConfiguration {
    //注入Jedis
    @Bean
    @ConditionalOnMissingBean(Jedis.class)
    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>

测试： 

@SpringBootApplication
public class SpringbootStarter04Application {

    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(SpringbootStarter04Application.class, args);
        System.out.println(context.getBean(Jedis.class));
 
    }
 
}
标签： spring boot java mybatis
本文转载自: https://blog.csdn.net/indiansummer_/article/details/142684318
版权归原作者 不敲代码666 所有， 如有侵权，请联系我们删除。
登录后发布评论

“SpringBoot 自动配置原理”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

java+vue计算机毕设茶叶产品质量安全可追溯系统【源码+程序+论文+开题】

Postman：Postman API测试：Postman数据驱动测试实践

解决：IntelliJ IDEA 项目中代码文件不能运行的问题(即：J 标文件的问题)

Docker：安装 MongoDB 的详细指南

Git - 两种方式撤销已提交到远端仓库的记录并删除提交记录

Kafka 原理

Flink Memory Management原理与代码实例讲解

文章导航