spring boot自动配置

zheeez2024-08-22 15:26

Spring自动配置是Spring框架的一个核心特性，它允许开发者通过在类路径下的配置类发现bean，而无需在应用程序中显式地进行bean的声明。Spring Boot利用这一特性，通过starter依赖的机制和@EnableAutoConfiguration注解，帮助开发者快速地配置和启动Spring应用。

一，@Conditional

条件判断

使用方法
  • 自定义条件类

需要实现org.springframework.context.annotation.Condition接口或继承org.springframework.context.annotation.Condition的某个实现类（如OnPropertyCondition、OnBeanCondition等）。 实现Condition接口需要覆盖matches(ConditionContext, AnnotatedTypeMetadata)方法，这个方法会返回一个布尔值，表示是否满足条件。

  • 在@Bean方法或@Configuration类上使用@Conditional

可以将自定义的条件类作为@Conditional的值，或者直接使用Spring提供的条件注解（如@ConditionalOnProperty、@ConditionalOnBean等）。

源码

案例

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

  1. 导入Jedis坐标后，加载该Bean，没导入，则不加载。
创建User配置类
java 复制代码 
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Conditional {
    Class<? extends Condition>[] value();
}
java 复制代码 
@Configuration
public class UserConfig {

    //@Conditional中的ClassCondition.class的matches方法，返回true执行以下代码，否则反之
    @Bean
    @Conditional(value= ClassCondition.class)
    public User user(){
        return new User();
    }
}
Condition 条件判断类
java 复制代码 
    @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;

    }
测试
java 复制代码 
 public static void main(String[] args) {

        //启动SpringBoot的应用，返回Spring的IOC容器
        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);


    }
需求2

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

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

实现步骤：

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

@Conditional(ClassCondition.class)注解不支持动态改变所以要自定义注解

创建ConditionOnClass注解
java 复制代码 
@Target({ElementType.TYPE, ElementType.METHOD})//可以修饰在类与方法上
@Retention(RetentionPolicy.RUNTIME)//注解生效节点runtime
@Documented//生成文档
@Conditional(value=ClassCondition.class)
public @interface ConditionOnClass {
    String[] value();//设置此注解的属性redis.clients.jedis.Jedis
}
ClassCondition类
java 复制代码 
//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;
user配置类
java 复制代码 
@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 -- 小结

自定义条件：

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

导入demo4，以坐标形式
java 复制代码 
 <!--导入坐标-->
        <dependency>
            <groupId>com.apesource</groupId>
            <artifactId>springboot-enable_other-04</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>
demo3导入
java 复制代码 
@SpringBootApplication
//@Import(User.class)
//@Import(UserConfig.class)
//@Import(MyImportSelector.class)
@Import({MyImportBeanDefinitionRegistrar.class})
//@EnableCaching
//@EnableAsync
public class SpringbootEnable03Application {

    public static void main(String[] args) {

        ConfigurableApplicationContext context =  SpringApplication.run(SpringbootEnable03Application.class, args);
        /**
         * Import4中用法：
         *  1. 导入Bean
         *  2. 导入配置类
         *  3. 导入ImportSelector的实现类
         *      查看ImportSelector接口源码
         *          String[] selectImports(AnnotationMetadata importingClassMetadata);
         *          代表将"字符串数组"中的的类，全部导入spring容器
         *  4. 导入ImportBeanDefinitionRegistrar实现类
         *
         */
//        User user = context.getBean(User.class);
//        System.out.println(user);
//
//        Student student = context.getBean(Student.class);
//        System.out.println(student);

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

    }

}
UserConfig类
java 复制代码 
@Configuration
public class UserConfig {

    @Bean
    public User user() {
        return new User();
    }
}
EnableUser注解
java 复制代码 
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(UserConfig.class)
public @interface EnableUser {
}
MyImportSelector
java 复制代码 
public class MyImportSelector implements ImportSelector {
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        //目前字符串数组的内容是写死的，未来可以设置在配置文件中动态加载
        return new String[]{"com.apesource.domain.User", "com.apesource.domain.Student"};
    }
}
MyImportBeanDefinitionRegistrar
java 复制代码 
public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        //AnnotationMetadata注解
        //BeanDefinitionRegistry向spring容器中注入

        //1.获取user的definition对象
        AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.rootBeanDefinition(User.class).getBeanDefinition();

        //2.通过beanDefinition属性信息,向spring容器中注册id为user的对象
        registry.registerBeanDefinition("user", beanDefinition);

    }
}

三，spring boot自动装配

@EnableAutoConfiguration 注解
主启动类
java 复制代码 
//@SpringBootApplication 来标注一个主程序类
//说明这是一个Spring Boot应用
@SpringBootApplication
public class SpringbootApplication {
   public static void main(String[] args) {
     //以为是启动了一个方法，没想到启动了一个服务
      SpringApplication.run(SpringbootApplication.class, args);
   }
}
@SpringBootApplication注解内部
java 复制代码 
@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的配置类；

java 复制代码 
//@SpringBootConfiguration注解内部
//这里的 @Configuration，说明这是一个配置类 ，配置类就是对应Spring的xml 配置文件；
@Configuration
public @interface SpringBootConfiguration {}
//里面的 @Component 这就说明，启动类本身也是Spring中的一个组件而已，负责启动应用
@Component
public @interface Configuration {}
@AutoConfigurationPackage ：自动配置包
java 复制代码 
//AutoConfigurationPackage的子注解
//Registrar.class 作用：将主启动类的所在包及包下面所有子包里面的所有组件扫描到Spring容器 
@Import({Registrar.class})
public @interface AutoConfigurationPackage {
}
@EnableAutoConfiguration开启自动配置功能

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

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

java 复制代码 
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
自定义启动器

需求： 自定义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。
实现：模拟自定义配置

redis-spring-boot-autoconfigure

java 复制代码 
<!--引入jedis依赖-->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
        </dependency>
复制代码 
RedisAutoconfiguration
java 复制代码 
@Configuration
@EnableConfigurationProperties(RedisProperties.class)
public class RedisAutoconfiguration {
    //注入jedis
    @Bean
    public Jedis jedis(RedisProperties redisProperties){
        return new Jedis(redisProperties.getHost(),redisProperties.getPort());
    }
}
java 复制代码 
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
  com.apesource.RedisAutoconfiguration
redis-spring-boot-starter
java 复制代码 
<dependency>
            <groupId>com.apesource</groupId>
            <artifactId>redis-spring-boot-autoconfigure</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>
springboot-enable_other-04
java 复制代码 
<!--导入坐标-->
        <dependency>
            <groupId>com.apesource</groupId>
            <artifactId>redis-spring-boot-starter</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>

启动

java 复制代码 
@SpringBootApplication
public class SpringbootEnable03Application {

    public static void main(String[] args) {

        ConfigurableApplicationContext context =  SpringApplication.run(SpringbootEnable03Application.class, args);
        Jedis bean1 = context.getBean(Jedis.class);
        System.out.println(bean1);
    }
}
相关推荐
李慕婉学姐5 小时前
【开题答辩过程】以《基于JAVA的校园即时配送系统的设计与实现》为例，不知道这个选题怎么做的，不知道这个选题怎么开题答辩的可以进来看看
java·开发语言·数据库
Chasing Aurora6 小时前
数据库连接+查询优化
数据库·sql·mysql·prompt·约束
奋进的芋圆7 小时前
Java 延时任务实现方案详解（适用于 Spring Boot 3）
java·spring boot·redis·rabbitmq
sxlishaobin7 小时前
设计模式之桥接模式
java·设计模式·桥接模式
model20057 小时前
alibaba linux3 系统盘网站迁移数据盘
java·服务器·前端
荒诞硬汉7 小时前
JavaBean相关补充
java·开发语言
提笔忘字的帝国7 小时前
【教程】macOS 如何完全卸载 Java 开发环境
java·开发语言·macos
萧曵 丶8 小时前
Next-Key Lock、记录锁、间隙锁浅谈
数据库·sql·mysql·mvcc·可重复读·幻读
2501_941882488 小时前
从灰度发布到流量切分的互联网工程语法控制与多语言实现实践思路随笔分享
java·开发语言
華勳全栈8 小时前
两天开发完成智能体平台
java·spring·go
热门推荐
01GitHub 镜像站点02安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）03Linux下V2Ray安装配置指南04Labelme从安装到标注：零基础完整指南05jdk21下载、安装（Windows、Linux、macOS）06手把手教你通过Gemini3 pro 学生认证，白用一年，手慢无！07【踩坑笔记】50系显卡适配的 PyTorch 安装08GitLab 零基础入门指南：从安装到项目管理全流程09Opencode CLI 安装成功,但是启动失败10UV安装并设置国内源