springboot自动装配原理

springboot自动配置原理

自动配置：

pom.xml

spring-boot-dependencies:核心依赖在父工程中！
我们再写入一些springboot依赖的时候，不需要指定版本，就因为有这些版本仓库

启动器

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

就是springboot的启动场景

比如说spring-boot-starter-web 它就会帮我们导入web环境所有的依赖

springboot将所有的功能场景都变成一个个的启动器

如果我们要使用什么功能 就只需要找到相对应的启动器就可以了 starter

主程序

//来标注一个主程序类 说明这个类是一个springboot应用
@SpringBootApplication
public class Springboot01Application
{
    public static void main(String[] args) 
    {
        SpringApplication.run(Springboot01Application.class, args);
    }
}

@SpringBootApplication

来标注一个主程序类 说明这个类是一个springboot的主配置类，springboot就应该运行这个类的main方法来启动springboot应用

@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
      @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {}

@SpringBootConfiguration：springboot的配置类，标注在某个类上，表示这是一个springboot的配置类

@Configuration
public @interface SpringBootConfiguration {}

@Configuration：告诉spring这是一个配置类 配置类就相当于配置文件

@Component
public @interface Configuration {}

所以，配置类也是容器中的一个组件

接下来来看第二个注解**@EnableAutoConfiguration**：开启自动配置

以前我们需要手动配置的东西，springboot帮我们自动配置**@EnableAutoConfiguration**告诉springboot开启自动配置功能

@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {}

@AutoConfigurationPackage：自动配置包

@Import(AutoConfigurationPackages.Registrar.class)
public @interface AutoConfigurationPackage {}

@Import：引入其他的配置类AutoConfigurationPackages.Registrar

static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports
{
   public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry)
   {
      register(registry, new PackageImports(metadata).getPackageNames().toArray(new String[0]));
   }

   public Set<Object> determineImports(AnnotationMetadata metadata)
   {
      return Collections.singleton(new PackageImports(metadata));
   }
}

它的作用就是将主配置类（@SpringBootApplication标注的类）的所在包及下面所有子包里面的组件扫描到spring容器中

​ 以Debug的方式就会发现它所获得的注解元数据以及getPackageNames获得的包名为主配置类所在包

回过头来再看@EnableAutoConfiguration上面标注的第二个注解**@Import(AutoConfigurationImportSelector.class)**

它又是要给spring容器导入什么组件呢？就是由AutoConfigurationImportSelector来说明要导入什么组件

AutoConfigurationImportSelector：导入哪些组件的选择器，里面有一个方法

​ 这个selectImports方法的作用呢就是用来告诉spring容器到底要导哪些组件，这些组件都是以String数组的方式返回组件的

全类名 ，这些组件就会被添加到容器中去

它调用了getAutoConfigurationEntry方法，里面有一个getCandidateConfigurations方法返回了一个List集合

​ 它会给我们容器中导入非常多的自动配置类（xxxAutoCondiguration），就是给容器中导入这个场景需要的所有组件，并配置好这些组件我们要做什么功能，什么功能的自动配置类就会把相应的组件以及对象都配置好，自动配置都是通过自动配置类完成的，有了自动配置类，就免去了手动编写配置和注入功能组件的工作

那这些自动配置类到底是从哪里得到的呢？让我们再看看getCandidateConfigurations方法，它就是来获取候选的配置文件

里面调用了SpringFactoriesLoader.loadFactoryNames(EnableAutoConfiguration.class,classLoader)方法

public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader)
{
   String factoryTypeName = factoryType.getName();
   return loadSpringFactories(classLoader).getOrDefault(factoryTypeName, Collections.emptyList());
}

private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) 
{
   MultiValueMap<String, String> result = cache.get(classLoader);
   if (result != null) {  return result; }

   try {
      Enumeration<URL> urls = (classLoader != null ?
            classLoader.getResources(FACTORIES_RESOURCE_LOCATION) :
            ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));
      result = new LinkedMultiValueMap<>();
      while (urls.hasMoreElements()) {
         URL url = urls.nextElement();
         UrlResource resource = new UrlResource(url);
         Properties properties = PropertiesLoaderUtils.loadProperties(resource);
         for (Map.Entry<?, ?> entry : properties.entrySet()) {
            String factoryTypeName = ((String) entry.getKey()).trim();
            for (String factoryImplementationName : StringUtils.commaDelimitedListToStringArray((String) entry.getValue())) {
               result.add(factoryTypeName, factoryImplementationName.trim());
            }
         }
      }
      cache.put(classLoader, result);
      return result;
   }
   catch (IOException ex) {
      throw new IllegalArgumentException("Unable to load factories from location [" +
            FACTORIES_RESOURCE_LOCATION + "]", ex);
   }
}

它用类加载器获取了一个资源：FACTORIES_RESOURCE_LOCATION

然后把这个资源当成一个properties配置文件，从properties配置文件拿出factoryTypeName

public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";

​ 所以就是springboot在启动的时候从类路径下的"META-INF/spring.factories"获取EnableAutoConfiguration指定的值（会扫描所有jar包类路径），将这些值作为自动配置类导入到容器中，自动配置类就生效了，帮我们进行自动配置工作，以前我们需要自己配制的东西，自动配置类都帮我们

​ 每一个xxxAutoConfiguration都是容器中的一个组件，都加入到容器中，用他们来做自动配置

下面以一个HttpEncodingAutoConfiguration（Http编码自动配置）类来了解一下自动配置原理

@Configuration(proxyBeanMethods = false)
@EnableConfigurationProperties(ServerProperties.class)
@ConditionalOnWebApplication(type = ConditionalOnWebApplication.Type.SERVLET)
@ConditionalOnClass(CharacterEncodingFilter.class)
@ConditionalOnProperty(prefix = "server.servlet.encoding", value = "enabled", matchIfMissing = true)
public class HttpEncodingAutoConfiguration {}

@Configuration：表示这是一个配置类 就像以前编写的配置文件一样，可以给容器中添加组件

@EnableConfigurationProperties：启动指定类的ConfigurationProperties功能，将配置文件中对应的值和ServerProperties绑定起来

​ 并把ServerProperties加入到IOC容器中，我们能配置的属性都是来源于这个功能的properties类

• //从配置文件中获取指定的值和Bean的属性进行绑定
  @ConfigurationProperties(prefix = "server", ignoreUnknownFields = true)
  public class ServerProperties {}
  

• 所有配置文件能配置的属性都是在xxxProperties里面封jiu装着，配置文件能配置什么就可以参照某个功能对应的属性类

@ConditionalOnWebApplication：判断当前应用是否是web应用，若是，当前配置类生效

​ spring底层有一个@Condition注解，根据不同的条件，如果满足指定的条件，整个配置类里面的配置才会生效

@ConditionalOnClass：判断当前项目有没有指定类CharacterEncodingFilter（springmvc中文乱码过滤器）

@ConditionalOnProperty：判断我们的配置文件是否存在某个配置server.servlet.encoding.enabled，matchIfMissing = true表示如果哦 不存在，判断也是成立的，即使我们不配置server.servlet.encoding.enabled，默认也生效

​ 自动配置类就是根据当前不同的条件判断，决定这个配置类是否生效，一旦配置类生效，就会给容器中添加各种组件，这些组件的属性是从对应的properties类中获取的，这些类里面的每一个属性又是和配置文件绑定的

总结：

• springboot启动时会加载大量的自动配置类
• 我们看我们需要的功能有没有springboot默认写好的自动配置类
• 我们再来看这个自动配置类中到底配置了哪些组件，只要我们要用的组件有，我们就不需要再来配置了
• 给容器中自动添加组件的时候，会从properties类中获取某些属性，我们就可以在配置文件中指定这些属性的值
• xxxAutoConfiguration：自动配置类，给容器中添加组件
• xxxProperties：封装配置文件中相关属性