SpringBoot的AutoConfigure自动配置原理

最新推荐文章于 2024-09-07 00:25:19 发布

HD243608836

最新推荐文章于 2024-09-07 00:25:19 发布

阅读量4.7k

点赞数 2

分类专栏： springBoot 文章标签： SpringBoot AutoConfigure 自动配置原理

原文链接：https://www.jianshu.com/p/1ed18eebb299

版权

springBoot 专栏收录该内容

192 篇文章 13 订阅

订阅专栏

外化配置和自动配置

将配置从代码中分离到XML或者properties中，这种spring配置外部化的方式成为外部配置。
spring 自动配置，spring-boot-autoconfigure依赖默认配置项，根据添加的依赖自动加载相关的配置属性并启动依赖。应用者只需要引入对应的start jar包，spring boot 就可以自动扫描和加载依赖信息。

自动配置原理

自动配置的前提

@Configuration ：他是JavaConfig形式的Spring IOC容器配置，其本身是一个IOC容器配置类。与原XML形式配置原理一致。
例如：
1、 XML方式定义类

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd"
       default-lazy-init="true">
    <!--bean定义-->
    <bean id="mockService" class="..MockServiceImpl">
</bean>
</beans>

2、 JavaConfig形式定义类

@Configuration
public class MockConfiguration{
    @Bean
    public MockService mockService(){
        return new MockServiceImpl();
    }
}

@Conditional：他是在Spring4中引入的有条件注册bean的注解，需要配合@Configuration使用。
提供以下方式：

@ConditionalOnBean：当SpringIoc容器内存在指定Bean的条件
@ConditionalOnClass：当SpringIoc容器内存在指定Class的条件
@ConditionalOnExpression：基于SpEL表达式作为判断条件
@ConditionalOnJava：基于JVM版本作为判断条件
@ConditionalOnJndi：在JNDI存在时查找指定的位置
@ConditionalOnMissingBean：当SpringIoc容器内不存在指定Bean的条件
@ConditionalOnMissingClass：当SpringIoc容器内不存在指定Class的条件
@ConditionalOnNotWebApplication：当前项目不是Web项目的条件
@ConditionalOnProperty：指定的属性是否有指定的值
@ConditionalOnResource：类路径是否有指定的值
@ConditionalOnSingleCandidate：当指定Bean在SpringIoc容器内只有一个，或者虽然有多个但是指定首选的Bean
@ConditionalOnWebApplication：当前项目是Web项目的条件
@ComponentScan：自动扫描并加载符合条件的组件，例如通过@Bean、@Component等注解的bean，将这些类加载到Spring IOC容器中。可以通过basePackages等属性来细粒度的定制@ComponentScan自动扫描的范围。

SpringBoot 的 AutoConfiguration

SpringBoot通过@EnableAutoConfiguration开启自动配置，借助SpringFactoriesLoader将所有符合自动配置条件的bean定义加载到IOC容器。

@EnableAutoConfiguration：是一个复合Annotation,通过@Import({EnableAutoConfigurationImportSelector.class})将符合条件的Configuration配置加载到IOC容器。

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

@EnableAutoConfigurationImportSelector：继承自AutoConfigurationImportSelector类，该类实现了自动配置项默认配置的加载

```
public class AutoConfigurationImportSelector
        implements DeferredImportSelector, BeanClassLoaderAware, ResourceLoaderAware,
        BeanFactoryAware, EnvironmentAware, Ordered {
    //通过select加载自动配置信息
    @Override
    public String[] selectImports(AnnotationMetadata annotationMetadata) {
        if (!isEnabled(annotationMetadata)) {
            return NO_IMPORTS;
        }
        try {
          // Step1: 得到注解信息
            AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader
                    .loadMetadata(this.beanClassLoader);
            // Step2: 得到注解中的所有属性信息
            AnnotationAttributes attributes = getAttributes(annotationMetadata);
            // Step3: 得到候选配置列表
            List<String> configurations = getCandidateConfigurations(annotationMetadata,
                    attributes);
            // Step4: 去重
            configurations = removeDuplicates(configurations);
            // Step5: 排序
            configurations = sort(configurations, autoConfigurationMetadata);
            // Step6: 根据注解中的exclude信息去除不需要的
            Set<String> exclusions = getExclusions(annotationMetadata, attributes);
            checkExcludedClasses(configurations, exclusions);
            configurations.removeAll(exclusions);
            configurations = filter(configurations, autoConfigurationMetadata);
            // Step7: 派发事件
            fireAutoConfigurationImportEvents(configurations, exclusions);
            return configurations.toArray(new String[configurations.size()]);
        }
        catch (IOException ex) {
            throw new IllegalStateException(ex);
        }
    }
}
```

在步骤三中加载依赖的Configurations

```
protected List<String> getCandidateConfigurations(AnnotationMetadata metadata,
        AnnotationAttributes attributes) {
    List<String> configurations = SpringFactoriesLoader.loadFactoryNames(
            getSpringFactoriesLoaderFactoryClass(), getBeanClassLoader());
    Assert.notEmpty(configurations,
            "No auto configuration classes found in META-INF/spring.factories. If you "
                    + "are using a custom packaging, make sure that file is correct.");
    return configurations;
}
```

委托SpringFactoriesLoader加载loadFactoryNames，META-INF/spring.factories中的配置候选项。

   public static List<String> loadFactoryNames(Class<?> factoryClass, ClassLoader classLoader) {
       String factoryClassName = factoryClass.getName();
       try {
           Enumeration<URL> urls = (classLoader != null ? classLoader.getResources(FACTORIES_RESOURCE_LOCATION) :
                   ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));
           List<String> result = new ArrayList<String>();
           while (urls.hasMoreElements()) {
               URL url = urls.nextElement();
               Properties properties = PropertiesLoaderUtils.loadProperties(new UrlResource(url));
               String factoryClassNames = properties.getProperty(factoryClassName);
               result.addAll(Arrays.asList(StringUtils.commaDelimitedListToStringArray(factoryClassNames)));
           }
           return result;
       }
       catch (IOException ex) {
           throw new IllegalArgumentException("Unable to load [" + factoryClass.getName() +
                   "] factories from location [" + FACTORIES_RESOURCE_LOCATION + "]", ex);
       }
   }

spring-boot-autoconfigure包含的Autoconfigure

   # 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,\
   org.springframework.boot.autoconfigure.cassandra.CassandraAutoConfiguration,\
   org.springframework.boot.autoconfigure.cloud.CloudAutoConfiguration,\
   ....

AutoConfiguration自定义Starter

通过spring-boot-autoconfigure完成自动化配置自定义starter。starter让我们摆脱了各种依赖库的处理，需要配置各种信息的困扰。Spring Boot会自动通过classpath路径下的类发现需要的Bean，并织入bean。

添加META-INF/spring.factories

在src/main/resources资源目录下创建META-INF/spring.factories 配置文件，在该文件中配置key和value。
其中key固定为：org.springframework.boot.autoconfigure.EnableAutoConfiguration

配置自定义Autoconfigure

自定义Autoconfigure文件负责设置自动加载规则和条件，只有在引用start项目中符合条件是才回自动装配。

/**
 * 该配置文件需要在spring.factories中引入
 * 在SpringBoot启动台的时候通过SpringFactoriesLoader会加载项目中spring.factories文件
 *
 * 配置自动装载器
 */
@Configuration
@EnableConfigurationProperties({AutoConfiguraionProperties.class})
@ConditionalOnClass({CompanyStarterService.class})
@ConditionalOnProperty(prefix="company.starter",name = "enable",havingValue = "true")
public class AutoStarterConfiguration {

    private AutoConfiguraionProperties properties;

    public AutoStarterConfiguration(AutoConfiguraionProperties properties){
        this.properties = properties;
    }

    @Bean
    @ConditionalOnMissingBean(CompanyStarterService.class)
    public CompanyStarterService companyStarterService(){
        return new CompanyStarterService(this.properties);
    }

}

@ConfigurationProperties配置项映射

对于自动装配中需要使用的配置项，可以通过自定义@ConfigurationProperties的方式从application.yml中获取配置内容。

/**
 * 自定义starter的application配置映射文件
 * 可以将application.properies或者application.yml中属性映射到java类
 */
@Data
@ConfigurationProperties(prefix = "company.starter")
public class AutoConfiguraionProperties {

    private String host;

    private Integer port;

}

在Autoconfigure中通过@Bean 配置IOC容器加载类

通过@Bean 配置来决定哪些类可以自动装配到IOC容器，并在系统中使用

@Bean
@ConditionalOnMissingBean(CompanyStarterService.class)
public CompanyStarterService companyStarterService(){
    return new CompanyStarterService(this.properties);
}