SpringBoot自动装配底层原理分析

我们从一个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属性

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，执行结果如下

就这么简单的就可以使用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，最后可以看到加载的位置

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

进入#3代码最后可以看到。

加载了这些文件后，就会加载默认配置的那些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