springboot自动装配解析

喜欢ヅ旅行 2022-10-18 12:50 230阅读 0赞

# 我们从一个redis操作的例子入手 #

新建一个springboot工程，仅仅需要引入2个jar包就可以操作使用redis

## 1. 导入包 ##

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

## 2. 然后就可以在application.properies文件中配置redis属性 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2E3MTg1MTUwMjg_size_16_color_FFFFFF_t_70]

## 3.写一个测试redis ##

@RestController
    public class SpringRedisTestController { 
    
        @Autowired
        RedisTemplate redisTemplate;
    
        @RequestMapping("/getRedisValue")
        public String getRedisValue() { 
            //赋值
            String key = "spring:redis:test";
            redisTemplate.opsForValue().set(key,"testvalue",10,TimeUnit.SECONDS);
            // 取值
            String val = (String)redisTemplate.opsForValue().get(key);
            System.out.println("从redis中取值===》 " + val);
            return val;
        }
    }

## 4.启动 ##

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

## 5.测试controller ##

访问http://localhost:8080/getRedisValue，执行结果如下

![在这里插入图片描述][20210709155200958.png]  
就这么简单的就可以使用redis，不需要写任何xml配置文件，也不需要写任何config配置类，只需要引入redis的jar包就可以使用redis,

# 思考 #

为什么springboot将redis的使用变的这么简单？基本上啥都没干，就写了地址，就可以使用redis了？  
首先我们要思考的是，既然我们没有写配置类，那么redis的配置文件是如何加载的呢？RedisTemplate又是如何加载的呢？  
这就要依赖于springboot的核心特性，自动装配机制。下面进行解析

# 自动装配 #

从上面代码看下来，整个启动过程我们只用了一个注解，那就是@SpringBootApplication，点进去可以发现新大陆。

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

## @ComponentScan ##

@ComponentScan是扫描包路径的，默认扫描的是启动类所在的包路径，以及子包下面的Bean

## @SpringBootConfiguration ##

@SpringBootConfiguration这个点进去看，也很简答，仅仅是对spring本身的configuration的封装

@Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Configuration
    public @interface SpringBootConfiguration {

## @EnableAutoConfiguration （自动装配核心） ##

@EnableAutoConfiguration 这个注解就是自动装配的核心

@Target({ ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Inherited
    @AutoConfigurationPackage
    @Import({ AutoConfigurationImportSelector.class})
    public @interface EnableAutoConfiguration { 
        String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";
    
        Class<?>[] exclude() default { };
    
        String[] excludeName() default { };
    }

### ImportSelector ###

从这个注解上，可以看到引用了一个重要的ImportSelector即 AutoConfigurationImportSelector.class

> **如果不是很明白importSelector，建议先了解下，因为这个的作用就是动态注册Bean,注入各种Configuration的核心，在springboot中很重要。建议一定要了解**

在AutoConfigurationImportSelector中，通过selectImports 方法进行动态注册Bean,

public String[] selectImports(AnnotationMetadata annotationMetadata) { 
            if (!this.isEnabled(annotationMetadata)) { 
                return NO_IMPORTS;
            } else { 
                AutoConfigurationImportSelector.AutoConfigurationEntry autoConfigurationEntry = this.getAutoConfigurationEntry(annotationMetadata);
                return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
            }
        }

主要看getAutoConfigurationEntry 这个方法，大致看下这个方法主要做了几件事  
\#1 获取启动类上的注解属性信息  
\#2 获得指定路径下所需要加载的configuration  
\#3 条件加载，因为不是所有configuration都需要加载，所以需要过滤

protected AutoConfigurationImportSelector.AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) { 
            if (!this.isEnabled(annotationMetadata)) { 
                return EMPTY_ENTRY;
            } else { 
            	// #1 获取启动类上的注解属性信息
                AnnotationAttributes attributes = this.getAttributes(annotationMetadata);
                // #2 获得指定路径下所需要加载的configuration
                List<String> configurations = this.getCandidateConfigurations(annotationMetadata, attributes);
                // 去重
                configurations = this.removeDuplicates(configurations);
                // 查看哪些类不需要加载，这个和#1有关，一般是用@SpringBootApplication(exclude = XXX.class)配置
                Set<String> exclusions = this.getExclusions(annotationMetadata, attributes);
                this.checkExcludedClasses(configurations, exclusions);
                configurations.removeAll(exclusions);
                // #3 条件加载，因为不是所有configuration都需要加载，所以需要过滤
                configurations = this.getConfigurationClassFilter().filter(configurations);
                this.fireAutoConfigurationImportEvents(configurations, exclusions);
                return new AutoConfigurationImportSelector.AutoConfigurationEntry(configurations, exclusions);
            }
        }

### 利用SPI机制加载核心配置文件 ###

最核心的是\#2和\#3这两步

*  \#2 根据spring的SPI机制，加载指定路径下的文件，META-INF/spring.factories，这里面定义的所有可能需要默认加载的Configuration，其中就有RedisAutoConfiguration
 *  \#3 从配置文件中获得自动装配过滤的配置。文件是META-INF/spring-autoconfigure-metadata.properties

### META-INF/spring.factories如何加载？ ###

根据上面代码进入\#2这一步getCandidateConfigurations，最后可以看到加载的位置  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2E3MTg1MTUwMjg_size_16_color_FFFFFF_t_70 1]

### META-INF/spring-autoconfigure-metadata.properties如何加载？ ###

进入\#3代码最后可以看到。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2E3MTg1MTUwMjg_size_16_color_FFFFFF_t_70 2]  
![在这里插入图片描述][20210709163955347.png]

加载了这些文件后，就会加载默认配置的那些Configuration，比如会自动加载RedisAutoConfiguration

继续用redis举例子，进入RedisAutoConfiguration

# RedisAutoConfiguration #

可以看到类上有这些注解

1.  @ConditionalOnClass(\{RedisOperations.class\})  
    ConditionalOnClass 意思是当给定的类名在类路径上存在，则实例化当前Bean。也即RedisOperations.class在类路径上存在，才会加载这个RedisAutoConfiguration 。而RedisOperations 在jar包spring-data-redis.jar中，所以如果不引入redis的jar包就不会加载RedisAutoConfiguration。
2.  @EnableConfigurationProperties(\{RedisProperties.class\})  
    这个很关键，这里是加载redis的配置信息，会将application.properties中配置的信息自动加载到RedisProperties这个Bean中
3.  @Import(\{LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class\})  
    这里会加载一个reidis工厂类LettuceConnectionFactory

@Configuration(
        proxyBeanMethods = false
    )
    @ConditionalOnClass({ RedisOperations.class}) // 这个是条件加载，当RedisOperations存在才会加载
    @EnableConfigurationProperties({ RedisProperties.class}) // 这个很关键，这里是加载redis的配置信息
    @Import({ LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class})// 这里会加载一个reidis工厂类LettuceConnectionFactory
    public class RedisAutoConfiguration { 
        public RedisAutoConfiguration() { 
        }
    
        @Bean
        @ConditionalOnMissingBean(
            name = { "redisTemplate"}
        )
        public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException { 
            RedisTemplate<Object, Object> template = new RedisTemplate();
            template.setConnectionFactory(redisConnectionFactory);
            return template;
        }
    }

到这里一个RedisAutoConfiguration 就加载完成了，RedisTemplate也相继加载完成。

# 总结 #

所以在我们的springboot工程中，即使没有写任何额外的xml配置或者redis配置类，只需要简单的属性配置（application.properties中），就可以使用redis，这个得益于springboot的自动装配机制，启动的时候，就会加载所有默认configuration，只要引用的相关的jar包就行，这里引入了redis的jar包，spring-boot-starter-data-redis，所以就会加载RedisAutoConfiguration ，如果不引用就不会加载。

# 扩展 #

我们也可以利用SPI机制自定义spring-boot第三方jar包，只需要再META-INF中定义好需要自动加载的configuration就行。比如自定义的jar中添加META-INF/spring.factories，内容如下

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
      com.test.redission.MyRedissonAutoConfiguratio

这样就会自动加载MyRedissonAutoConfiguratio

再比如最近两年dubbo对spring-boot的集成也是同样道理，引入jar包dubbo-spring-boot-starter，就可以使用spring-boot方式配置dubbo。在dubbo-spring-boot-autoconfigure可以看到这个文件spring.factories

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

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2E3MTg1MTUwMjg_size_16_color_FFFFFF_t_70]: /images/20221005/3731a43146664aaf9be3cf8c1818709f.png
[20210709155200958.png]: /images/20221005/2e06780e825d43ec8d2d6876ad5755d4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2E3MTg1MTUwMjg_size_16_color_FFFFFF_t_70 1]: /images/20221005/0ef9ca7b092044a294909891b9bc6741.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2E3MTg1MTUwMjg_size_16_color_FFFFFF_t_70 2]: /images/20221005/1d8abfe19d024358a401b9ba337c0b73.png
[20210709163955347.png]: /images/20221005/1417e07018ee48ed9c6a3c76558194d4.png
[2021070917215350.png]: /images/20221005/b117f59246cd41e099379b9ed41a7b0a.png