SpringBoot系列之自动装配原理详解

墨蓝 2023-10-09 15:17 49阅读 0赞

#### 文章目录 ####

*  前言
 *  一、SpringBoot自动配置-Condition-1
 *   *  1、观察spring自动创建bean过程
     *  2、创建自定义bean对象
     *  3、根据条件创建自定义bean
 *  二、 SpringBoot自动配置-Condition-2
 *  三、SpringBoot自动配置-切换内置web服务器
 *   *  1、查看继承关系图
     *  2、shift+delete 排除Tomcat
 *  四、SpringBoot自动配置-Enable注解原理
 *  五、SpringBoot自动配置-@Import详解
 *   *  ①导入Bean
     *  ②导入配置类
     *  ③导入 ImportSelector 实现类
     *  ④导入 ImportBeanDefinitionRegistrar 实现类
 *  六、SpringBoot自动配置-@EnableAutoConfiguration详解
 *  总结

--------------------

## 前言 ##

Springboot目前是Java开发中最主流的框，因此在我们的工作和面试中都会经常用到，SpringBoot主要解决了传统spring的重量级xml配置Bean，实现了自动装配。接下来将从注解已经源码来学习SpringBoot自动装配原理。

--------------------

## 一、SpringBoot自动配置-Condition-1 ##

**Condition**是Spring4.0后引入的条件化配置接口，通过实现Condition接口可以完成有条件的加载相应的Bean。  
`@Conditional`要配和`Condition`的实现类（ClassCondition）进行使用

**接下来我们以下面例子来学习：**  
• 创建模块 springboot-condition

### 1、观察spring自动创建bean过程 ###

> 改造启动类如下:

@SpringBootApplication
    public class SpringbootConditionApplication {
        
    
        public static void main(String[] args) {
        
            ConfigurableApplicationContext run = SpringApplication.run(SpringbootConditionApplication.class, args);
            System.out.println(run);
            //只要引入Redis起步依赖，就有了RedisTemplate对象
            Object redisTemplate = run.getBean("redisTemplate");
            System.out.println(redisTemplate);
        }

启动：**获取不到对象**  
![在这里插入图片描述][1051fbe28d1d4cdabab3faeb99c5d583.png]导入 `redis`起步依赖

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

再启动则可以获取到bean对象。  
![在这里插入图片描述][465b727a5efa4e678528c8658ae29a2b.png]

### 2、创建自定义bean对象 ###

①新建user实体类`com.lp.springbootcondition.pojo.User`

package com.lp.springbootcondition.pojo;
    public class User {
        
        int id;
        String name;
        int age;
        public User() {
        
        }
        public User(int id, String name, int age) {
        
            this.id = id;
            this.name = name;
            this.age = age;
        }
        public int getId() {
        
            return id;
        }
        public void setId(int id) {
        
            this.id = id;
        }
        public String getName() {
        
            return name;
        }
        public void setName(String name) {
        
            this.name = name;
        }
        public int getAge() {
        
            return age;
        }
        public void setAge(int age) {
        
            this.age = age;
        }
        @Override
        public String toString() {
        
            return "User{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }

②新建配置类`com.lp.springbootcondition.config.ConditionConfig`

@Configuration
    public class ConditionConfig {
        
        @Bean
        public User user() {
        
            return new User();
        }
    }

③启动类获取。测试可以获取到

@SpringBootApplication
    public class SpringbootConditionApplication {
        
        public static void main(String[] args) {
        
            ConfigurableApplicationContext run = SpringApplication.run(SpringbootConditionApplication.class, args);
            System.out.println(run);
            //只要引入Redis起步依赖，就有了RedisTemplate对象
    //        Object redisTemplate = run.getBean("redisTemplate");
    //        System.out.println(redisTemplate);
            User user = (User) run.getBean("user");
            System.out.println(user);
        }
    }

![在这里插入图片描述][e37035c910f440daadd8e6f0586b06cf.png]

### 3、根据条件创建自定义bean ###

创建ClassCondition 类com.lp.springbootcondition.condition.ClassCondition

public class ClassCondition implements Condition {
        
        @Override
        public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        
            return false;
    }
    }

改造userConfig

@Configuration
    public class ConditionConfig {
        
        @Bean
        @Conditional(ClassCondition.class)
        public User user(){
        
            return new User();
        }
    }

启动起启动类，测试不能自动创建user这个bean  
![在这里插入图片描述][df51104b5a634c2295eae1b8209b5dd8.png]

**1、改造ClassCondition。根据是否导入redis来决定是否创建userBean**

public class ClassCondition implements Condition {
        
        @Override
        public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        
            try {
        
              
                Class.forName("redis.clients.jedis.Jedis");
                return true;
            } catch (ClassNotFoundException e) {
        
                e.printStackTrace();
                return false;
            }
        }
    }

测试。获取不到userBean

@SpringBootApplication
    public class SpringbootConditionApplication {
        
    
        public static void main(String[] args) {
        
            ConfigurableApplicationContext run = SpringApplication.run(SpringbootConditionApplication.class, args);
            System.out.println(run);
            //只要引入Redis起步依赖，就有了RedisTemplate对象
    //        Object redisTemplate = run.getBean("redisTemplate");
    //        System.out.println(redisTemplate);
            User user = (User) run.getBean("user");
            System.out.println(user);
        }
    }

![在这里插入图片描述][48772d492638444a9f81d75362bdd405.png]导入Redis依赖,再测试

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

可以获取到userBean  
![在这里插入图片描述][93b123cc4d32438f934c5f3ad719105d.png]

## 二、 SpringBoot自动配置-Condition-2 ##

需求：将类的判断定义为动态的。判断哪个字节码文件存在可以动态指定。  
1、创建自定义条件注解类ConditionClass

@Target(ElementType.TYPE) //可以用在哪些地方
    @Documented//生成javadoc
    @Retention(RetentionPolicy.RUNTIME) //运行时起作用
    @Conditional(ClassCondition.class)
    public @interface ConditionClass {
        
        String[] value();
    }

2、改造ClassCondition类

public class ClassCondition implements Condition {
        
        @Override
        public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        
            try {
        
                //必须引入动态传来的包名，才生成对象
                Map<String, Object> annotationAttributes = metadata.getAnnotationAttributes("com.lp.springbootcondition.condition.ConditionClass");
                System.out.println(annotationAttributes);
                if (annotationAttributes != null) {
        
                    String[] values = (String[]) annotationAttributes.get("value");
                    for (String value : values) {
        
                        Class.forName(value);
                    }
                }
                return true;
            } catch (ClassNotFoundException e) {
        
                e.printStackTrace();
                return false;
            }
        }
    }

3、改造`ConditionConfig`  
**注意：** 此处@ConditionOnClass为自定义注解

@Configuration
    public class ConditionConfig {
        
    //    @Bean
    //    public User user() {
        
    //        return new User();
    //    }
        @Bean
    //    @Conditional(ClassCondition.class)
        @ConditionOnClass({
        "redis.clients.jedis.Jedis"})
        public User user(){
        
            return new User();
        }

4、测试User对象的创建

@SpringBootApplication
    public class SpringbootConditionApplication {
        
    
        public static void main(String[] args) {
        
            ConfigurableApplicationContext run = SpringApplication.run(SpringbootConditionApplication.class, args);
            System.out.println(run);
            //只要引入Redis起步依赖，就有了RedisTemplate对象
    //        Object redisTemplate = run.getBean("redisTemplate");
    //        System.out.println(redisTemplate);
            User user = (User) run.getBean("user");
            System.out.println(user);
        }
    }

![在这里插入图片描述][61659e35874f4cb095198a29de89d998.png]查看Springboot条件注解源码  
![在这里插入图片描述][1620afa37d914b3eabad700a0be2cd6f.png]我们会发现Springboot都已经帮我们写好了  
**SpringBoot 提供的常用条件注解：**

ConditionalOnProperty：判断配置文件中是否有对应属性和值才初始化Bean
    ConditionalOnClass：判断环境中是否有对应字节码文件才初始化Bean
    ConditionalOnMissingBean：判断环境中没有对应Bean才初始化Bean

## 三、SpringBoot自动配置-切换内置web服务器 ##

如果我们需要切换内置web服务器可以按一下操作进行切换

### 1、查看继承关系图 ###

![在这里插入图片描述][03f6e438a9c04dad8be3dfa76d33396c.png]

### 2、shift+delete 排除Tomcat ###

![在这里插入图片描述][a6454afc64ae45109ee80fa321c1aefe.png]  
pom文件中的排除依赖效果

<dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-web</artifactId>
       
       <exclusions>
       <exclusion>
       <artifactId>spring-boot-starter-tomcat</artifactId>
       <groupId>org.springframework.boot</groupId>
       </exclusion>
       </exclusions>
       </dependency>
    
    
    <dependency>
        <artifactId>spring-boot-starter-jetty</artifactId>
        <groupId>org.springframework.boot</groupId>
    </dependency>

根据上面的例子，我们能够知道 为什么引入了starter-data-redis起步依赖，我们就能在项目中，直接拿`redistemplate`?  
因为在`springboot`中的`autoconfigure`工程里把常用的对象的配置类都有了，只要工程中，引入了相关起步依赖，这些对象在我们本项目的容器中就有了。  
![在这里插入图片描述][35a75c568a4a4cd9911d0ecefcebd6b0.png]

## 四、SpringBoot自动配置-Enable注解原理 ##

**重要：SpringBootApplication 由三个注解组成**  
![在这里插入图片描述][7d5fe93e7c1b420eb8ce76f86198f68c.png]

@SpringBootConfiguration 自动配置相关
    @EnableAutoConfiguration
    @ComponentScan 扫本包及子包

SpringBoot不能直接获取在其他工程中定义的Bean。  
springboot-enable工程，编写主启动类

> 代码如下（示例）：

/**
     * @ComponentScan 扫描范围：当前引导类所在包及其子包
     *
     * //1.使用@ComponentScan扫描com.lp.springbootenableother.config包
     * //2.可以使用@Import注解，加载类。这些类都会被Spring创建，并放入IOC容器
     * //3.可以对Import注解进行封装。
     **/
    package com.lp.springbootenable;
    
    import com.lp.pojo.User;
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.context.ConfigurableApplicationContext;
    
    @SpringBootApplication
    public class SpringbootEnableApplication {
        
    
        public static void main(String[] args) {
        
            ConfigurableApplicationContext run = SpringApplication.run(SpringbootEnableApplication.class, args);
            User user = (User) run.getBean("user");
            System.out.println(user);
    
        }
    }

pom中引入springboot-enable-other

<dependency>
                <groupId>com.lp</groupId>
                <artifactId>springboot-enable-other</artifactId>
                <version>0.0.1-SNAPSHOT</version>
    </dependency>

新建`springboot-enable-other`工程  
![在这里插入图片描述][68d57a2baf8a4d58bb93cb7f5070054b.png]编写User

public class User {
        }

编写UserConfig

@Configuration
    public class UserConfig {
        
    
        @Bean
        public User user() {
        
            return new User();
        }
    }

启动主启动类，确实，本工程中没有这个第三方jar包中的bean对象  
![在这里插入图片描述][9dabccf8fda94594b00977afdb6a0f6b.png]原因：`@ComponentScan` 扫描范围：当前引导类所在包及其子包  
**三种解决方案：**  
1.使用@ComponentScan扫描lp.config包  
2.可以使用@Import注解，加载类。这些类都会被Spring创建，并放入IOC容器  
3.可以对Import注解进行封装。

@SpringBootApplication
    //@ComponentScan("com.lp.springbootenableother.config")
    //@Import(UserConfig.class)
    @EnableUser
    public class SpringbootEnableApplication {
        
    
        public static void main(String[] args) {
        
            ConfigurableApplicationContext run = SpringApplication.run(SpringbootEnableApplication.class, args);
            User user = (User) run.getBean("user");
            System.out.println(user);
    
        }
    }

编写`EnableUser`注解

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

启动，能够获取  
!\[在这里插入图片描述\](https://img-blog.csdnimg.cn/249b1a85258747c597aa1e8ebe81dad4.png

**重点：Enable注解底层原理是使用@Import注解实现Bean的动态加载**

## 五、SpringBoot自动配置-@Import详解 ##

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

而@Import提供4中用法：

### ①导入Bean ###

。注意bean名字是全限定名（`@Import(UserConfig.class)`）。

> 示例代码

@Import(User.class)
    public class SpringbootEnableApplication {
        
        public static void main(String[] args) {
        
            ConfigurableApplicationContext run = SpringApplication.run(SpringbootEnableApplication.class, args);
            User user = (User) run.getBean("user");
            System.out.println(user);
    
        }
    }

### ②导入配置类 ###

> 示例代码

@Import(UserConfig.class)
    public class SpringbootEnableApplication {
        
        public static void main(String[] args) {
        
            ConfigurableApplicationContext run = SpringApplication.run(SpringbootEnableApplication.class, args);
            User user = (User) run.getBean("user");
            System.out.println(user);
    
        }
    }

### ③导入 ImportSelector 实现类 ###

一般用于加载配置文件中的类

> 示例代码

public class MyImportSelector implements ImportSelector {
        
        @Override
        public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        
            return new String[]{
        "com.lp.domain.User", "com.lp.domain.Role"};
        }
    }

![在这里插入图片描述][fdc65fe24f3e415eb666187654c53725.png]

### ④导入 ImportBeanDefinitionRegistrar 实现类 ###

@Import(\{MyImportBeanDefinitionRegistrar.class\})

> 示例代码

public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
        
        @Override
        public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        
            AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.rootBeanDefinition(User.class).getBeanDefinition();
            registry.registerBeanDefinition("user", beanDefinition);
        }
    }

![在这里插入图片描述][981c78874de0404b8179006c391483b9.png]SpringbootEnableApplication测试代码

Import4中用法：
    
    *  1. 导入Bean
    *  2. 导入配置类
    *  3. 导入ImportSelector的实现类。
    *  4. 导入ImportBeanDefinitionRegistrar实现类
          */
    @SpringBootApplication
    //@ComponentScan("com.lp.springbootenableother.config")
    //@Import(User.class)
    //@EnableUser
    //@Import(MyImportSelector.class)
    //@Import({MyImportBeanDefinitionRegistrar.class})
    public class SpringbootEnableApplication {
        
    
        public static void main(String[] args) {
        
            ConfigurableApplicationContext run = SpringApplication.run(SpringbootEnableApplication.class, args);
    //        User user = (User) run.getBean("user");
    //        System.out.println(user);
            Map<String, User> beansOfType = run.getBeansOfType(User.class);
            System.out.println(beansOfType);
    
    //        Jedis jedis = (Jedis) run.getBean("jedis");
    //        System.out.println(jedis);
    //        jedis.set("hello", "world");
    //        String hello = jedis.get("hello");
    //        System.out.println(hello);
        }
    }

**@EnableAutoConfiguration中使用的是第三种方式：@Import(AutoConfigurationImportSelector.class)**

## 六、SpringBoot自动配置-@EnableAutoConfiguration详解 ##

![在这里插入图片描述][6f5c82487fce4f94a562d1d9ae63a6d4.png]

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

## 总结 ##

SpringBoot中的主启动类`@SpringBootApplication`由三个注解组成，分别是`@SpringBootConfiguration`、`@EnableAutoConfiguration`、`@ComponentScan`其中

`@SpringBootConfiguration`表示启动类为配置类；

`@ComponentScan`实现启动时扫描启动类所在的包以及子包下所有标记为bean的类由IOC容器注册为bean。

`@EnableAutoConfiguration`通过`@Import(AutoConfigurationImportSelector.class)`注解来加载`AutoConfigurationImportSelector`类，然后通过`AutoConfigurationImportSelector`中的`selectImports`方法去读取spring-boot-autoconfigure 下的`META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports`文件中的全类名，并根据一定规则过滤掉不符合的全类名，然后将剩余读取到的类全名集合返回给IOC容器并将这些组件注册为bean。

[1051fbe28d1d4cdabab3faeb99c5d583.png]: https://img-blog.csdnimg.cn/1051fbe28d1d4cdabab3faeb99c5d583.png
[465b727a5efa4e678528c8658ae29a2b.png]: https://img-blog.csdnimg.cn/465b727a5efa4e678528c8658ae29a2b.png
[e37035c910f440daadd8e6f0586b06cf.png]: https://img-blog.csdnimg.cn/e37035c910f440daadd8e6f0586b06cf.png
[df51104b5a634c2295eae1b8209b5dd8.png]: https://img-blog.csdnimg.cn/df51104b5a634c2295eae1b8209b5dd8.png
[48772d492638444a9f81d75362bdd405.png]: https://img-blog.csdnimg.cn/48772d492638444a9f81d75362bdd405.png
[93b123cc4d32438f934c5f3ad719105d.png]: https://img-blog.csdnimg.cn/93b123cc4d32438f934c5f3ad719105d.png
[61659e35874f4cb095198a29de89d998.png]: https://img-blog.csdnimg.cn/61659e35874f4cb095198a29de89d998.png
[1620afa37d914b3eabad700a0be2cd6f.png]: https://img-blog.csdnimg.cn/1620afa37d914b3eabad700a0be2cd6f.png
[03f6e438a9c04dad8be3dfa76d33396c.png]: https://img-blog.csdnimg.cn/03f6e438a9c04dad8be3dfa76d33396c.png
[a6454afc64ae45109ee80fa321c1aefe.png]: https://img-blog.csdnimg.cn/a6454afc64ae45109ee80fa321c1aefe.png
[35a75c568a4a4cd9911d0ecefcebd6b0.png]: https://img-blog.csdnimg.cn/35a75c568a4a4cd9911d0ecefcebd6b0.png
[7d5fe93e7c1b420eb8ce76f86198f68c.png]: https://img-blog.csdnimg.cn/7d5fe93e7c1b420eb8ce76f86198f68c.png
[68d57a2baf8a4d58bb93cb7f5070054b.png]: https://img-blog.csdnimg.cn/68d57a2baf8a4d58bb93cb7f5070054b.png
[9dabccf8fda94594b00977afdb6a0f6b.png]: https://img-blog.csdnimg.cn/9dabccf8fda94594b00977afdb6a0f6b.png
[fdc65fe24f3e415eb666187654c53725.png]: https://img-blog.csdnimg.cn/fdc65fe24f3e415eb666187654c53725.png
[981c78874de0404b8179006c391483b9.png]: https://img-blog.csdnimg.cn/981c78874de0404b8179006c391483b9.png
[6f5c82487fce4f94a562d1d9ae63a6d4.png]: https://img-blog.csdnimg.cn/6f5c82487fce4f94a562d1d9ae63a6d4.png