SpringBoot 自动配置

一.Condition

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

案例：需求1

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

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

 <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-data-redis</artifactId>
           </dependency>
          <dependency>
           <groupId>redis.clients</groupId>
           <artifactId>jedis</artifactId>
 </dependency>

案例：需求2

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

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

@SpringBootApplication
public class SpringbootCondition01Application {

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

}

@Configuration
public class UserConfig {

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


}

@Configuration
public class UserConfig {

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


}

实现步骤：

不使用@Conditional(ClassCondition.class)注解

自定义注解@ConditionOnClass,因为他和之前@Conditional注解功能一直，所以直接复制

编写ClassCondition中的matches方法    

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

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

@SpringBootApplication
public class SpringbootCondition02Application {

    public static void main(String[] args) {

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

}

@Configuration
public class UserConfig {


    //情况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);


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

        Object user2 = context.getBean("user2");
        System.out.println(user2);

}

}

二.@Enable注解

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

@Import注解

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

1.导入Bean

在Spring中，Bean是被Spring容器管理的对象。可以通过使用@Bean注解、XML配置、或使用@Component和相关的注解（如@Service, @Repository, @Controller等）来定义和导入Bean。

2.导入配置类

配置类使用@Configuration注解标记，允许定义Bean的创建和依赖关系。使用@Import注解可以将其他配置类导入当前的配置类中，从而实现模块化和复用。

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

ImportSelector 是一个接口，允许您通过编程方式来选择和导入其他配置类。在Spring的配置中，可以返回一个类名数组，指示Spring容器要导入哪些配置类。这通常用于条件化加载某些配置。

4. 导入 ImportBeanDefinitionRegistrar 实现类。

ImportBeanDefinitionRegistrar 是一个接口，允许开发者直接向Spring的BeanFactory注册Bean定义。可以在registerBeanDefinitions方法中编写自定义逻辑，动态地添加Bean。这在需要根据条件或环境来动态创建Bean时特别有用

创建一个包，包含以下实体类以及配置类

实体类

创建一个userconfig类

package com.xn.config;


import com.xn.domain.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class UserConfig {
    @Bean
    public User user() {
        return new User();
    }


}

定义一个MyImportSelector的类，它实现了ImportSelector接口

package com.xn.config;

import org.springframework.context.annotation.ImportSelector;
import org.springframework.core.type.AnnotationMetadata;

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

定义一个名为MyImportBeanDefinitionRegistrar的类，它实现了ImportBeanDefinitionRegistrar接口

package com.xn.config;

import com.xn.domain.User;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
import org.springframework.core.type.AnnotationMetadata;

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

    }
}

定义一个自定义注解@EnableUser 

package com.xn.config;

import org.springframework.context.annotation.Import;

import java.lang.annotation.*;

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(UserConfig.class)
public @interface EnableUser {
}

再创建一个包，并导入上一个包的坐标

<groupId>com.apesource</groupId>
    <artifactId>springboot-enable-03</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot-enable-03</name>
    <description>Demo project for Spring Boot</description>

 @SpringBootApplication中有@ComponentScan注解， 扫描范围：当前引导类所在包及其子包
当前引导类所在包com.xn.springbootenable03
注入user类所在包com.xn.springbootenable_other04.config因此扫描不到，所以容器中没有user
解决方案：      
        1.使用@ComponentScan扫描com.xn.springbootenable_other04.config包

@SpringBootApplication
@ComponentScan("com.xn.config")
public class SpringbootEnable03Application {

    public static void main(String[] args) {


        ConfigurableApplicationContext context =  SpringApplication.run(SpringbootEnable03Application.class, args);

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

    }

}

        2.可以使用@Import注解，加载类。这些类都会被Spring创建，并放入IOC容器

@SpringBootApplication
@Import(User.class)//导入javaBean
public class SpringbootEnable03Application {

    public static void main(String[] args) {

        ConfigurableApplicationContext context =  SpringApplication.run(SpringbootEnable03Application.class, args);

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

    }

}

        3.可以对Import注解进行封装。     

@SpringBootApplication
@Import(UserConfig.class)
public class SpringbootEnable03Application {

    public static void main(String[] args) {

        ConfigurableApplicationContext context =  SpringApplication.run(SpringbootEnable03Application.class, args);

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

    }

}

 3.导入ImportSelector的实现类 查看ImportSelector接口源码

String[] selectImports(AnnotationMetadata importingClassMetadata); 代表将“字符串数组”中的的类，全部导入spring容器

@SpringBootApplication
@Import(MyImportSelector.class)
public class SpringbootEnable03Application {

    public static void main(String[] args) {

        ConfigurableApplicationContext context =  SpringApplication.run(SpringbootEnable03Application.class, args);

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

    }

}

4. 导入ImportBeanDefinitionRegistrar实现类

@SpringBootApplication

//@Import(MyImportSelector.class)//**
@Import({MyImportBeanDefinitionRegistrar.class})
public class SpringbootEnable03Application {

    public static void main(String[] args) {


        ConfigurableApplicationContext context =  SpringApplication.run(SpringbootEnable03Application.class, args);

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

    }

}

 @EnableUser

@SpringBootApplication
@EnableUser
public class SpringbootEnable03Application {

    public static void main(String[] args) {


        ConfigurableApplicationContext context =  SpringApplication.run(SpringbootEnable03Application.class, args);

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

    }

}

三.@EnableAutoConfiguration 注解

主启动类

@SpringBootApplication注解内部

@ComponentScan

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

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

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

@AutoConfigurationPackage ：自动配置包

@EnableAutoConfiguration开启自动配置功能

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

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

 总结原理：

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

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

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

 四.自定义启动器

自定义启动器（Custom Starter）是Spring Boot的一种常见功能，主要用于打包一些自动配置功能和相关的依赖，以便其他Spring Boot项目能够方便地使用。

实现自定义启动器的一般步骤

1. 创建一个独立的 Maven 或 Gradle 项目：

   • 创建一个新的项目，用于实现自定义启动器。

     2.添加必要的依赖：

     3.创建自动配置类：并添加@Configuration注解

package com.xn;

import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
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开启对特定配置属性类的支持。它允许将一个或多个配置属性类注册到 Spring 的上下文中
@EnableConfigurationProperties(RedisProperties.class)
public class RedisAutoconfiguration {
    //Jedis 是一个用于 Java 的 Redis 客户端。它提供了一个简单的 API 来与 Redis 数据库进行交互，
    // 使得 Java 开发者能够方便地连接、操作和管理 Redis 数据
    //注入jedis
    @Bean
    public Jedis jedis(RedisProperties redisProperties){
        return new Jedis(redisProperties.getHost(),redisProperties.getPort());
    }
}

        4. 创建一个Spring Boot项目中用来绑定配置属性的类

package com.xn;

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

        5.服务类

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package com.apesource.pojo;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;

public class User implements BeanNameAware, ApplicationContextAware, BeanFactoryAware {
    public User() {
    }

    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println(beanFactory);
    }

    public void setBeanName(String s) {
        System.out.println(s);
    }

    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        System.out.println(applicationContext);
    }
}

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package com.apesource.test;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test01 {
    public Test01() {
    }

    public static void main(String[] args) {
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        Object user = applicationContext.getBean("users");
        System.out.println(user);
    }
}

        6.创建一个spring.factories文件 ，xml文件

 

         7.应用

package com.xn.springbootstarter04;

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);
        Jedis bean1 = context.getBean(Jedis.class);
        System.out.println(bean1);

    }


}