SpringBoot自动配置注解原理解析

时间 2019-11-11

原文原文链接

1. SpringBoot启动主程序类：

1 @SpringBootApplication
2 public class DemoApplication {
3     public static void main(String[] args) {
4 
5         SpringApplication.run(DemoApplication.class, args);
6     }
7 }

每次咱们直接直接启动这个启动类，SpringBoot就启动成功了，而且帮咱们配置了好多自动配置类。redis

其中最重要是 @SpringBootApplication 这个注解，咱们点进去看一下。spring

2. SpringBootApplication注解：

 1 @Target(ElementType.TYPE)
 2 @Retention(RetentionPolicy.RUNTIME)
 3 @Documented
 4 @Inherited
 5 @SpringBootConfiguration
 6 @EnableAutoConfiguration
 7 @ComponentScan(excludeFilters = {
 8         @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
 9         @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
10 public @interface SpringBootApplication {

　　三个比较重要的注解：

@SpringBootConfiguration : Spring Boot的配置类，标注在某个类上，表示这是一个Spring Boot的配置类app
@EnableAutoConfiguration: 开启自动配置类，SpringBoot的精华所在。框架
@ComponentScan包扫描ide

　　之前咱们须要配置的东西，Spring Boot帮咱们自动配置；@EnableAutoConfiguration告诉SpringBoot开启自动配置功能；这样自动配置才能生效；工具

3. EnableAutoConfiguration注解：

1 @Target(ElementType.TYPE)
2 @Retention(RetentionPolicy.RUNTIME)
3 @Documented
4 @Inherited
5 @AutoConfigurationPackage
6 @Import(AutoConfigurationImportSelector.class)
7 public @interface EnableAutoConfiguration {

两个比较重要的注解：

@AutoConfigurationPackage：自动配置包学习
@Import: 导入自动配置的组件this

4. AutoConfigurationPackage注解：

1     static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {
2 
3         @Override
4         public void registerBeanDefinitions(AnnotationMetadata metadata,
5                 BeanDefinitionRegistry registry) {
6             register(registry, new PackageImport(metadata).getPackageName());
7         }

它实际上是注册了一个Bean的定义。spa

new PackageImport(metadata).getPackageName()，它其实返回了当前主程序类的 同级以及子级 的包组件。3d

以上图为例，DemoApplication是和demo包同级，可是demo2这个类是DemoApplication的父级，和example包同级

也就是说，DemoApplication启动加载的Bean中，并不会加载demo2，这也就是为何，咱们要把DemoApplication放在项目的最高级中。

5. Import(AutoConfigurationImportSelector.class)注解：

能够从图中看出 AutoConfigurationImportSelector 继承了 DeferredImportSelector 继承了 ImportSelector

ImportSelector有一个方法为：selectImports。

 1 @Override
 2     public String[] selectImports(AnnotationMetadata annotationMetadata) {
 3         if (!isEnabled(annotationMetadata)) {
 4             return NO_IMPORTS;
 5         }
 6         AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader
 7                 .loadMetadata(this.beanClassLoader);
 8         AnnotationAttributes attributes = getAttributes(annotationMetadata);
 9         List<String> configurations = getCandidateConfigurations(annotationMetadata,
10                 attributes);
11         configurations = removeDuplicates(configurations);
12         Set<String> exclusions = getExclusions(annotationMetadata, attributes);
13         checkExcludedClasses(configurations, exclusions);
14         configurations.removeAll(exclusions);
15         configurations = filter(configurations, autoConfigurationMetadata);
16         fireAutoConfigurationImportEvents(configurations, exclusions);
17         return StringUtils.toStringArray(configurations);
18     }

能够看到第九行，它实际上是去加载 public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";外部文件。这个外部文件，有不少自动配置的类。以下：

6. 如何自定义本身的Bean：

咱们以RedisTemplate为例：

 1 @Configuration
 2 @ConditionalOnClass(RedisOperations.class)
 3 @EnableConfigurationProperties(RedisProperties.class)
 4 @Import({ LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class })
 5 public class RedisAutoConfiguration {
 6 
 7     @Bean
 8     @ConditionalOnMissingBean(name = "redisTemplate")
 9     public RedisTemplate<Object, Object> redisTemplate(
10             RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
11         RedisTemplate<Object, Object> template = new RedisTemplate<>();
12         template.setConnectionFactory(redisConnectionFactory);
13         return template;
14     }
15 
16     @Bean
17     @ConditionalOnMissingBean
18     public StringRedisTemplate stringRedisTemplate(
19             RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
20         StringRedisTemplate template = new StringRedisTemplate();
21         template.setConnectionFactory(redisConnectionFactory);
22         return template;
23     }
24 
25 }

咱们每次在Spring中使用Redis，都会使用到RedisTemplate这个工具类，可是他默认给咱们返回的这个工具类，可能不是很符合咱们的要求。好比：咱们想要开启事务，或者想要改变它默认的序列化。

这时候该如何去作呢？

根据前面的分析，只要咱们在容器中放入一个RedisTemplate Bean便可。

 1 @Bean("redisTemplate")
 2     public RedisTemplate<Object, Object> myRedisTemplate(
 3             RedisConnectionFactory redisConnectionFactory) {
 4         RedisTemplate<Object, Object> template = new RedisTemplate<>();
 5         template.setConnectionFactory(redisConnectionFactory);
 6         // 修改序列化为Jackson
 7         template.setDefaultSerializer(new GenericJackson2JsonRedisSerializer());
 8         // 开启事务
 9         template.setEnableTransactionSupport(true);
10         return template;
11     }

咱们本身定义咱们的RedisTemplate模板，修改序列化，开启事务等操做。

咱们将咱们本身的Bean加入到IoC容器中之后，他就会默认的覆盖掉原来的RedisTemplate，达到定制的效果。

咱们在以Kafka为例：

假设咱们想要消费的对象不是字符串，而是一个对象呢？好比Person对象，或者其余Object类呢？

1：咱们首先去查找KafkaAutoConfiguration（xxxAutoConfiguration），看看是否有关于Serializer属性的配置

2：假设没有咱们就去KafkaProperties文件查找是否有Serializer的配置

而后直接在application.properties修改默认序列化就好，连Bean都不须要本身重写。

相似这种，可使用Spring提供的Json序列化，也能够自动使用第三方框架提供的序列化，好比Avro, Protobuff等

1 spring.kafka.producer.key-serializer=org.springframework.kafka.support.serializer.JsonSerializer
2 spring.kafka.producer.value-serializer=org.springframework.kafka.support.serializer.JsonSerializer
3 spring.kafka.consumer.key-deserializer=com.example.common.MyJson
4 spring.kafka.consumer.value-deserializer=com.example.common.MyJson

后记：

不少时候咱们刚开始看一个知识点，不懂迷茫的时候，真的不要慌，可能说明你暂时的知识储备还不够理解。
等你通过不断的学习，不断的深刻之后
忽然有一天，你会忽然的醒悟
哇！原来他讲的是这个意思
可能咱们不理解，咱们能够去尝试去看两遍，三遍，甚至更多遍，忽然会有一个时刻，你会醒悟过来的
且行且珍惜，共勉