浅谈springboot自动配置原理

从main函数说起

一切的开始要从SpringbootApplication注解说起。

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


@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan
public @interface SpringBootApplication {
  
}

其中最重要的就是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 {};
}

通过import注解导入AutoConfigurationimportSelector。在这个类中加载/meta-INF/spring.factories文件的信息，然后筛选出以EnableAutoConfiguration为key的数据，加载到IOC容器中，实现自动配置功能。

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@documented
@Inherited
@import(AutoConfigurationPackages.Registrar.class)
public @interface AutoConfigurationPackage {

}

从表面看就是自动配置包，主要使用了import注解，导入了Registrar类。这里Registrar类的registerBeanDefinitions方法导包，也就是导入当前main函数所在路径的包地址，我这里是com.zhangfei。

怎么自动装配其他N个类

import({AutoConfigurationimportSelector.class})该注解给当前配置类导入另外N个自动配置类。

这里既然导入N个自动配置类，那么都导入哪些类呢？

//AutoConfigurationimportSelector实现DeferredimportSelector接口，而DeferredimportSelector接口又继承了importSelector
public interface importSelector {
  String[] selectimports(Annotationmetadata var1);
}

AutoConfigurationimportSelector通过实现接口importSelector的selectimports方法返回需要导入的组件，selectimports方法返回一个全类名字符串数组。

主角上场

//AutoConfigurationimportSelector.java
@Override
public String[] selectimports(Annotationmetadata annotationmetadata) {
  if (!isEnabled(annotationmetadata)) {
    return NO_importS;
  }
  AutoConfigurationmetadata autoConfigurationmetadata = AutoConfigurationmetadataLoader.loadmetadata(this.beanClassLoader);
  AutoConfigurationEntry autoConfigurationEntry = getAutoConfigurationEntry(autoConfigurationmetadata,annotationmetadata);
  return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
}

protected AutoConfigurationEntry getAutoConfigurationEntry(AutoConfigurationmetadata autoConfigurationmetadata,Annotationmetadata annotationmetadata) {
  if (!isEnabled(annotationmetadata)) {
    return EMPTY_ENTRY;
  }
  AnnotationAttributes attributes = getAttributes(annotationmetadata);
  List configurations = getCandidateConfigurations(annotationmetadata, attributes);
  configurations = removeDuplicates(configurations);
  Set exclusions = getExclusions(annotationmetadata, attributes);
  checkExcludedClasses(configurations, exclusions);
  configurations.removeAll(exclusions);
  configurations = filter(configurations, autoConfigurationmetadata);
  fireAutoConfigurationimportEvents(configurations, exclusions);
  return new AutoConfigurationEntry(configurations, exclusions);
}

protected List getCandidateConfigurations(Annotationmetadata metadata, AnnotationAttributes attributes) {
  List configurations = SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(),getBeanClassLoader());
  return configurations;
}

这里又开始调用SpringFactoriesLoader.loadFactoryNames。
SpringFactoriesLoader.loadFactoryNames方法中关键的三步：
(1)从当前项目的类路径中获取所有 meta-INF/spring.factories 这个文件下的信息.
(2)将上面获取到的信息封装成一个 Map 返回，EnableAutoConfiguration为key。
(3)从返回的Map中通过刚才传入的 EnableAutoConfiguration.class参数，获取该 key 下的所有值。

public static List loadFactoryNames(Class factoryClass, @Nullable ClassLoader classLoader) {
  String factoryClassName = factoryClass.getName();
  return (List)loadSpringFactories(classLoader).getOrDefault(factoryClassName, Collections.emptyList());
}

private static Map> loadSpringFactories(@Nullable ClassLoader classLoader) {
  MultiValueMap result = (MultiValueMap)cache.get(classLoader);
  if (result != null) {
    return result;
  } else {
    try {
      Enumeration urls = classLoader != null ? classLoader.getResources("meta-INF/spring.factories") : ClassLoader.getSystemResources("meta-INF/spring.factories");
      linkedMultiValueMap result = new linkedMultiValueMap();

      while(urls.hasMoreElements()) {
 URL url = (URL)urls.nextElement();
 UrlResource resource = new UrlResource(url);
 Properties properties = PropertiesLoaderUtils.loadProperties(resource);
 Iterator var6 = properties.entrySet().iterator();

 while(var6.hasNext()) {
   Entry entry = (Entry)var6.next();
   String factoryClassName = ((String)entry.getKey()).trim();
   String[] var9 = StringUtils.commaDelimitedListToStringArray((String)entry.getValue());
   int var10 = var9.length;

   for(int var11 = 0; var11 < var10; ++var11) {
     String factoryName = var9[var11];
     result.add(factoryClassName, factoryName.trim());
   }
 }
      }

      cache.put(classLoader, result);
      return result;
    } catch (IOException var13) {
      throw new IllegalArgumentException("Unable to load factories from location [meta-INF/spring.factories]", var13);
    }
  }
}

自动配置都有哪些内容呢？

# Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=
org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,
org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration,
org.springframework.boot.autoconfigure.batch.BatchAutoConfiguration,
org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration,
...其他省略

XXXAutoConfiguration和XXProperties

在spring.factories文件中看到的都是自动配置类，那么自动配置用到的属性值在那里呢？我们拿出redis为例

@Configuration
@ConditionalOnClass(RedisOperations.class) //判断当前项目有没有这个类RedisOperations.class
@EnableConfigurationProperties(RedisProperties.class) //启用配置属性，这里看到了熟悉的XXXProperties
@import({ LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class }) //导入这两个类
public class RedisAutoConfiguration {

  @Bean
  @ConditionalOnMissingBean(name = "redisTemplate")
  public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory)
      throws UnknownHostException {
    RedisTemplate template = new RedisTemplate<>();
    template.setConnectionFactory(redisConnectionFactory);
    return template;
  }

  @Bean
  @ConditionalOnMissingBean
  public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory)
      throws UnknownHostException {
    StringRedisTemplate template = new StringRedisTemplate();
    template.setConnectionFactory(redisConnectionFactory);
    return template;
  }
}

 
//这里则保存redis初始化时的属性
@ConfigurationProperties(prefix = "spring.redis")
public class RedisProperties {

  private int database = 0;

  private String url;

  private String host = "localhost";

  private String password;

  private int port = 6379;

  private boolean ssl;

}

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持考高分网。