【SpringBoot源码剥析】| 自动配置原理

命运对每个人都是一样的,不一样的是各自的努力和付出不同,付出的越多,努力的越多,得到的回报也越多,在你累的时候请看一下身边比你成功却还比你更努力的人,这样,你就会更有动力。

导读:本篇文章讲解 【SpringBoot源码剥析】| 自动配置原理,希望对大家有帮助,欢迎收藏,转发!站点地址:www.bmabk.com,来源:原文

1. 概述

本文,我们来分享 Spring Boot 自动配置的实现源码。在故事的开始,我们先来说两个事情:

  • 自动配置和自动装配的区别?
  • Spring Boot 配置的原理

2. 自动配置 VS 自动装配

在这篇文章的开始,狮子是有点混淆自动配置和自动装配的概念,后来经过 Google 之后,发现两者是截然不如同的:

  • 自动配置:是 SpringBoot 提供的,实现通过 jar 包的依赖,能够自动配置应用程序。例如说:我们引入 spring-boot-starter-web 之后,就自动引入了 Spring MVC 相关的 jar 包,从而自动配置 Spring MVC 。
  • 自动装配:是 Spring 提供的 IOC 注入方式,具体看看 《Spring源码剥析 —— Beans 自动装配》文档。

3. 自动装配原理

可以查看下《Spring Boot的自动装配原理》

4. @SpringBootApplication

image-20230419151852631

org.springframework.boot.autoconfigure.@SpringBootApplication 注解,基本我们的 Spring Boot 应用,一定会去有这样一个注解。并且,通过使用它,不仅仅能标记这是一个 Spring Boot 应用,而且能够开启自动配置的功能。这是为什么呢?

tips:

@SpringBootApplication 注解,它在 spring-boot-autoconfigure 模块中。所以,我们使用 Spring Boot 项目时,如果不想使用自动配置功能,就不用引入它。当然,我们貌似不太会存在这样的需求,是吧~

@SpringBootApplication 是一个组合注解。代码如下:

/**
 * Indicates a {@link Configuration configuration} class that declares one or more
 * {@link Bean @Bean} methods and also triggers {@link EnableAutoConfiguration
 * auto-configuration} and {@link ComponentScan component scanning}. This is a convenience
 * annotation that is equivalent to declaring {@code @Configuration},
 * {@code @EnableAutoConfiguration} and {@code @ComponentScan}.
 *
 * @author Phillip Webb
 * @author Stephane Nicoll
 * @author Andy Wilkinson
 * @since 1.2.0
 */
@Target(ElementType.TYPE)			// 注解的适用范围,Type表示注解可以描述在类、接口、注解或枚举中
@Retention(RetentionPolicy.RUNTIME)	// 表示注解的生命周期,Runtime运行时
@Documented							// 表示注解可以记录在javadoc中
@Inherited							// 表示可以被子类继承该注解
// ----------------------上面是源注解,下面是组合注解(重点)-----------------------------
@SpringBootConfiguration			// 标明该类为配置类
@EnableAutoConfiguration			// 标明该类为配置类
@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
		@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })	//注解扫描
public @interface SpringBootApplication {			//源码

	/**
	 * Exclude specific auto-configuration classes such that they will never be applied.
	 * @return the classes to exclude
	 */
	@AliasFor(annotation = EnableAutoConfiguration.class)
	Class<?>[] exclude() default {};

	/**
	 * Exclude specific auto-configuration class names such that they will never be
	 * applied.
	 * @return the class names to exclude
	 * @since 1.3.0
	 */
	@AliasFor(annotation = EnableAutoConfiguration.class)
	String[] excludeName() default {};

	/**
	 * Base packages to scan for annotated components. Use {@link #scanBasePackageClasses}
	 * for a type-safe alternative to String-based package names.
	 * <p>
	 * <strong>Note:</strong> this setting is an alias for
	 * {@link ComponentScan @ComponentScan} only. It has no effect on {@code @Entity}
	 * scanning or Spring Data {@link Repository} scanning. For those you should add
	 * {@link org.springframework.boot.autoconfigure.domain.EntityScan @EntityScan} and
	 * {@code @Enable...Repositories} annotations.
	 * @return base packages to scan
	 * @since 1.3.0
	 */
	@AliasFor(annotation = ComponentScan.class, attribute = "basePackages")
	String[] scanBasePackages() default {};

	/**
	 * Type-safe alternative to {@link #scanBasePackages} for specifying the packages to
	 * scan for annotated components. The package of each class specified will be scanned.
	 * <p>
	 * Consider creating a special no-op marker class or interface in each package that
	 * serves no purpose other than being referenced by this attribute.
	 * <p>
	 * <strong>Note:</strong> this setting is an alias for
	 * {@link ComponentScan @ComponentScan} only. It has no effect on {@code @Entity}
	 * scanning or Spring Data {@link Repository} scanning. For those you should add
	 * {@link org.springframework.boot.autoconfigure.domain.EntityScan @EntityScan} and
	 * {@code @Enable...Repositories} annotations.
	 * @return base packages to scan
	 * @since 1.3.0
	 */
	@AliasFor(annotation = ComponentScan.class, attribute = "basePackageClasses")
	Class<?>[] scanBasePackageClasses() default {};

	/**
	 * Specify whether {@link Bean @Bean} methods should get proxied in order to enforce
	 * bean lifecycle behavior, e.g. to return shared singleton bean instances even in
	 * case of direct {@code @Bean} method calls in user code. This feature requires
	 * method interception, implemented through a runtime-generated CGLIB subclass which
	 * comes with limitations such as the configuration class and its methods not being
	 * allowed to declare {@code final}.
	 * <p>
	 * The default is {@code true}, allowing for 'inter-bean references' within the
	 * configuration class as well as for external calls to this configuration's
	 * {@code @Bean} methods, e.g. from another configuration class. If this is not needed
	 * since each of this particular configuration's {@code @Bean} methods is
	 * self-contained and designed as a plain factory method for container use, switch
	 * this flag to {@code false} in order to avoid CGLIB subclass processing.
	 * <p>
	 * Turning off bean method interception effectively processes {@code @Bean} methods
	 * individually like when declared on non-{@code @Configuration} classes, a.k.a.
	 * "@Bean Lite Mode" (see {@link Bean @Bean's javadoc}). It is therefore behaviorally
	 * equivalent to removing the {@code @Configuration} stereotype.
	 * @since 2.2
	 * @return whether to proxy {@code @Bean} methods
	 */
	@AliasFor(annotation = Configuration.class)
	boolean proxyBeanMethods() default true;

}

下面,我们来逐个看 @SpringBootApplication 上的每个注解。

4.1 @Inherited

Java 自带的注解。

java.lang.annotation.@Inherited 注解,使用此注解声明出来的自定义注解,在使用自定义注解时,如果注解在类上面时,子类会自动继承此注解,否则的话,子类不会继承此注解。

这里一定要记住,使用 @Inherited 声明出来的注解,只有在类上使用时才会有效,对方法,属性等其他无效。

4.2 @SpringBootConfiguration

Spring Boot 自定义的注解

org.springframework.boot.@SpringBootConfiguration 注解,标记这是一个 Spring Boot 配置类。代码如下:

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
//	------------------上面是源注解,下面是组合注解---------------
@Configuration
public @interface SpringBootConfiguration {

}
  • 可以看到,它上面继承自 @Configuration 注解,所以两者功能也一致,可以将当前类内声明的一个或多个以 @Bean 注解标记的方法的实例纳入到 Spring 容器中,并且实例名就是方法名。

4.3 @ComponentScan

Spring 自定义的注解

org.springframework.context.annotation.@ComponentScan 注解,扫描指定路径下的 Component(@Componment@Configuration@Service 等等)。

4.4 @EnableAutoConfiguration

Spring Boot 自定义的注解

org.springframework.boot.autoconfigure.@EnableAutoConfiguration 注解,用于开启自动配置功能,是 spring-boot-autoconfigure 项目最核心的注解。代码如下:

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
// ----------------------上面是源注解,下面是组合注解(重点)-----------------------------
@AutoConfigurationPackage							// 自动配置包
@Import(AutoConfigurationImportSelector.class)		// Spring的底层注解@Import,给容器中导入一个组件:
public @interface EnableAutoConfiguration {

	String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";

	/**
	 * Exclude specific auto-configuration classes such that they will never be applied.
	 * @return the classes to exclude
	 */
	Class<?>[] exclude() default {};

	/**
	 * Exclude specific auto-configuration class names such that they will never be
	 * applied.
	 * @return the class names to exclude
	 * @since 1.3.0
	 */
	String[] excludeName() default {};

}
  • org.springframework.boot.autoconfigure.@AutoConfigurationPackage 注解,主要功能自动配置包,**它会获取主程序类所在的包路径,并将包路径(包括子包)下的所有组件注册到 Spring IOC 容器中。**代码如下:

    @Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Inherited
    
    // spring的底层注解@Import,给容器中导入一个组件;
    // 导入的组件是AuGoConfigurationPackages.Registrar.class
    @Import(AutoConfigurationPackages.Registrar.class)
    public @interface AutoConfigurationPackage {
    
    }
    
    • org.springframework.context.annotation.@Import 注解,可用于资源的导入。
    • AutoConfigurationPackages.Registrar ,有点神奇,这里先不说。最后再去看「6. AutoConfigurationPackages」 小节。
  • @Import(AutoConfigurationImportSelector.class) 注解部分,是重头戏的开始。

    • org.springframework.context.annotation.@Import 注解,可用于资源的导入。
    • AutoConfigurationImportSelector ,导入自动配置相关的资源。

5. AutoConfigurationImportSelector

org.springframework.boot.autoconfigure.AutoConfigurationImportSelector ,实现 DeferredImportSelector、BeanClassLoaderAware、ResourceLoaderAware、BeanFactoryAware、EnvironmentAware、Ordered 接口,处理 @EnableAutoConfiguration 注解的资源导入。

5.1 getCandidateConfigurations

getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) 方法,获得符合条件的配置类的数组。代码如下:

protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
    // <1> 加载指定类型 EnableAutoConfiguration 对应的,在 `META-INF/spring.factories` 里的类名的数组
	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;
}
  • <1> 处,调用 getSpringFactoriesLoaderFactoryClass() 方法,获得要从 META-INF/spring.factories 加载的指定类型为 EnableAutoConfiguration 类。代码如下:

    protected Class<?> getSpringFactoriesLoaderFactoryClass() {
    	return EnableAutoConfiguration.class;
    }
    
    • <1> 处,调用 SpringFactoriesLoader.loadFactoryNames(Class<?> factoryClass, ClassLoader classLoader) 方法,加载指定类型 EnableAutoConfiguration 对应的,在 META-INF/spring.factories 里的类名的数组。看看下图,相信就明白了:【SpringBoot源码剥析】| 自动配置原理 configurations

一般来说,和网络上 Spring Boot 敢于这块的源码解析,我们就可以结束了。如果单纯是为了了解原理 Spring Boot 自动配置的原理,这里结束也是没问题的。因为,拿到 Configuration 配置类后,后面的就是 Spring Java Config 的事情了。

😜 但是(“但是”同学,你赶紧坐下),具有倒腾精神的🦁,觉得还是继续瞅瞅 getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) 方法是怎么被调用的。所以,我们来看看调用它的方法调用链,如下图所示:调用链 调用链

  • ① 处、 refresh 方法的调用,我们在 《【SpringBoot源码剥析】 —— SpringApplication》 中,SpringApplication 启动时,会调用到该方法。

  • ② 处、getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) 方法被调用。

  • ③ 处、那么此处,就是问题的关键。代码如下:

    private final DeferredImportSelector.Group group;
    
    public Iterable<Group.Entry> getImports() {
    	for (DeferredImportSelectorHolder deferredImport : this.deferredImports) {
    		this.group.process(deferredImport.getConfigurationClass().getMetadata(),
    				deferredImport.getImportSelector()); // <1>
    	}
    	return this.group.selectImports();				 // <2>
    }
    
    • <1> 处,调用 DeferredImportSelector.Group#process(AnnotationMetadata metadata, DeferredImportSelector selector) 方法,处理被 @Import 注解的注解。

    • <2>处,调用DeferredImportSelector.Group#this.group.selectImports()方法,选择需要导入的。例如:

      selectImports

      selectImports

      • 这里,我们可以看到需要导入的 Configuration 配置类。
    • 具体 <1><2> 处,在 「5.3 AutoConfigurationGroup」 详细解析。

5.2 getImportGroup

getImportGroup() 方法,获得对应的 Group 实现类。代码如下:

@Override // 实现自 DeferredImportSelector 接口
public Class<? extends Group> getImportGroup() {
	return AutoConfigurationGroup.class;
}
  • 关于 AutoConfigurationGroup 类,在 「5.3 AutoConfigurationGroup」 详细解析。

5.3 AutoConfigurationGroup

AutoConfigurationGroup ,是 AutoConfigurationImportSelector 的内部类,实现 DeferredImportSelector.Group、BeanClassLoaderAware、BeanFactoryAware、ResourceLoaderAware 接口,自动配置的 Group 实现类。

5.3.1 属性

/**
 * AnnotationMetadata 的映射
 *
 * KEY:配置类的全类名
 */
private final Map<String, AnnotationMetadata> entries = new LinkedHashMap<>();
/**
 * AutoConfigurationEntry 的数组
 */
private final List<AutoConfigurationEntry> autoConfigurationEntries = new ArrayList<>();

private ClassLoader beanClassLoader;
private BeanFactory beanFactory;
private ResourceLoader resourceLoader;

/**
 * 自动配置的元数据
 */
private AutoConfigurationMetadata autoConfigurationMetadata;
  • entries 属性,AnnotationMetadata 的映射。其中,KEY 为 配置类的全类名。在后续我们将看到的 AutoConfigurationGroup.process(...) 方法中,被进行赋值。例如:【SpringBoot源码剥析】| 自动配置原理 entries

  • autoConfigurationEntries 属性,AutoConfigurationEntry 的数组。

    • 其中,AutoConfigurationEntry 是 AutoConfigurationImportSelector 的内部类,自动配置的条目。代码如下:

      protected static class AutoConfigurationEntry {
      
          /**
           * 配置类的全类名的数组
           */
          private final List<String> configurations;
          /**
           * 排除的配置类的全类名的数组 
           */
          private final Set<String> exclusions;
          
          // 省略构造方法和 setting/getting 方法
          
      }
      
      • 属性比较简单。
    • 在后续我们将看到的 AutoConfigurationGroup.process(...) 方法中,被进行赋值。例如:【SpringBoot源码剥析】| 自动配置原理autoConfigurationEntries

  • autoConfigurationMetadata 属性,自动配置的元数据(Metadata)。

    • 通过 getAutoConfigurationMetadata() 方法,会初始化该属性。代码如下:

      private AutoConfigurationMetadata getAutoConfigurationMetadata() {
          // 不存在,则进行加载
      	if (this.autoConfigurationMetadata == null) {
      		this.autoConfigurationMetadata = AutoConfigurationMetadataLoader.loadMetadata(this.beanClassLoader);
      	}
      	// 存在,则直接返回
      	return this.autoConfigurationMetadata;
      }
      
      • 关于 AutoConfigurationMetadataLoader 类,我们先不去愁。避免,我们调试的太过深入。TODO 后续在补充下。

      • 返回的类型是 PropertiesAutoConfigurationMetadata ,比较简单

      • 如下是一个返回值的示例:

        【SpringBoot源码剥析】| 自动配置原理

        autoConfigurationEntries

        • 可能会有点懵逼,这么多,并且 KEY / VALUE 结果看不懂?不要方,我们简单来说下 CouchbaseReactiveRepositoriesAutoConfiguration 配置类。如果它生效,需要 classpath 下有 Bucket、ReactiveCouchbaseRepository、Flux 三个类,所以红线那个条目,对应的就是 CouchbaseReactiveRepositoriesAutoConfiguration 类上的 @ConditionalOnClass({ Bucket.class, ReactiveCouchbaseRepository.class, Flux.class }) 注解部分。
    • 所以,autoConfigurationMetadata 属性,用途就是制定配置类(Configuration)的生效条件(Condition)。

5.3.2 process

process(AnnotationMetadata annotationMetadata, DeferredImportSelector deferredImportSelector) 方法,进行处理。代码如下:

@Override
public void process(AnnotationMetadata annotationMetadata, DeferredImportSelector deferredImportSelector) {
    // 断言
    Assert.state(
            deferredImportSelector instanceof AutoConfigurationImportSelector,
            () -> String.format("Only %s implementations are supported, got %s",
                    AutoConfigurationImportSelector.class.getSimpleName(),
                    deferredImportSelector.getClass().getName()));
    // <1> 获得 AutoConfigurationEntry 对象 
    AutoConfigurationEntry autoConfigurationEntry = ((AutoConfigurationImportSelector) deferredImportSelector)
            .getAutoConfigurationEntry(getAutoConfigurationMetadata(), annotationMetadata);
    // <2> 添加到 autoConfigurationEntries 中
    this.autoConfigurationEntries.add(autoConfigurationEntry);
    // <3> 添加到 entries 中
    for (String importClassName : autoConfigurationEntry.getConfigurations()) {
        this.entries.putIfAbsent(importClassName, annotationMetadata);
    }
}
  • annotationMetadata 参数,一般来说是被 @SpringBootApplication 注解的元数据。因为,@SpringBootApplication 组合了 @EnableAutoConfiguration 注解。
  • deferredImportSelector 参数,@EnableAutoConfiguration 注解的定义的 @Import 的类,即 AutoConfigurationImportSelector 对象。
  • <1> 处,调用 AutoConfigurationImportSelector#getAutoConfigurationEntry(AutoConfigurationMetadata autoConfigurationMetadata, AnnotationMetadata annotationMetadata) 方法,获得 AutoConfigurationEntry 对象。详细解析,见 「5.4 AutoConfigurationEntry」 。因为这块比较重要,所以先跳过去瞅瞅。
  • <2> 处,添加到 autoConfigurationEntries 中。
  • <3> 处,添加到 entries 中。

5.3.3 selectImports

#selectImports() 方法,获得要引入的配置类。代码如下:

@Override
public Iterable<Entry> selectImports() {
    // <1> 如果为空,则返回空数组
    if (this.autoConfigurationEntries.isEmpty()) {
        return Collections.emptyList();
    }
    // <2.1> 获得 allExclusions
    Set<String> allExclusions = this.autoConfigurationEntries.stream()
            .map(AutoConfigurationEntry::getExclusions)
            .flatMap(Collection::stream).collect(Collectors.toSet());
    // <2.2> 获得 processedConfigurations
    Set<String> processedConfigurations = this.autoConfigurationEntries.stream()
            .map(AutoConfigurationEntry::getConfigurations)
            .flatMap(Collection::stream)
            .collect(Collectors.toCollection(LinkedHashSet::new));
    // <2.3> 从 processedConfigurations 中,移除排除的
    processedConfigurations.removeAll(allExclusions);
    // <3> 处理,返回结果
    return sortAutoConfigurations(processedConfigurations, getAutoConfigurationMetadata()) // <3.1> 排序
                .stream()
                .map((importClassName) -> new Entry(this.entries.get(importClassName), importClassName)) // <3.2> 创建 Entry 对象
                .collect(Collectors.toList()); // <3.3> 转换成 List
}
  • <1> 处,如果为空,则返回空数组。

  • <2.1><2.2><2.3> 处,获得要引入的配置类集合。 比较奇怪的是,上面已经做过一次移除的处理,这里又做一次。不过,没多大关系,可以先无视。

  • <3> 处,处理,返回结果。

    • <3.1> 处,调用 #sortAutoConfigurations(Set<String> configurations, AutoConfigurationMetadata autoConfigurationMetadata) 方法,排序。代码如下:

      private List<String> sortAutoConfigurations(Set<String> configurations, AutoConfigurationMetadata autoConfigurationMetadata) {
      	return new AutoConfigurationSorter(getMetadataReaderFactory(), autoConfigurationMetadata).getInPriorityOrder(configurations);
      }
      
      • 具体的排序逻辑,胖友自己看。实际上,还是涉及哪些,例如说 @Order 注解。
    • <3.2> 处,创建 Entry 对象。

      • <3.3> 处,转换成 List 。结果如下图:结果 结果

5.4 getAutoConfigurationEntry

这是一个关键方法。因为会调用到,我们会在 「5.1 getCandidateConfigurations」的方法。

getAutoConfigurationEntry(AutoConfigurationMetadata autoConfigurationMetadata, AnnotationMetadata annotationMetadata) 方法,获得 AutoConfigurationEntry 对象。代码如下:

protected AutoConfigurationEntry getAutoConfigurationEntry(AutoConfigurationMetadata autoConfigurationMetadata, AnnotationMetadata annotationMetadata) {
    // <1> 判断是否开启。如未开启,返回空数组。
    if (!isEnabled(annotationMetadata)) {
        return EMPTY_ENTRY;
    }
    // <2> 获得注解的属性
    AnnotationAttributes attributes = getAttributes(annotationMetadata);
    // <3> 获得符合条件的配置类的数组
    List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
    // <3.1> 移除重复的配置类
    configurations = removeDuplicates(configurations);
    // <4> 获得需要排除的配置类
    Set<String> exclusions = getExclusions(annotationMetadata, attributes);
    // <4.1> 校验排除的配置类是否合法
    checkExcludedClasses(configurations, exclusions);
    // <4.2> 从 configurations 中,移除需要排除的配置类
    configurations.removeAll(exclusions);
    // <5> 根据条件(Condition),过滤掉不符合条件的配置类
    configurations = filter(configurations, autoConfigurationMetadata);
    // <6> 触发自动配置类引入完成的事件
    fireAutoConfigurationImportEvents(configurations, exclusions);
    // <7> 创建 AutoConfigurationEntry 对象
    return new AutoConfigurationEntry(configurations, exclusions);
}

这里每一步都是细节的方法,所以会每一个方法,都会是引导到对应的小节的方法。

虽然有点长,但是很不复杂。简单的来说,加载符合条件的配置类们,然后移除需要排除(exclusion)的。

  • <1> 处,调用 #isEnabled(AnnotationMetadata metadata) 方法,判断是否开启。如未开启,返回空数组。详细解析,见 「5.4.1 isEnabled」 。

  • <2> 处,调用 #getAttributes(AnnotationMetadata metadata) 方法,获得注解的属性。详细解析,见 「5.4.2 getAttributes」

  • 【重要】<3> 处,调用 getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) 方法,获得符合条件的配置类的数组。

    嘻嘻,到达此之后,整个细节是不是就串起来了!

    • <3.1> 处,调用 #removeDuplicates(List<T> list) 方法,移除重复的配置类。代码如下:

      protected final <T> List<T> removeDuplicates(List<T> list) {
      	return new ArrayList<>(new LinkedHashSet<>(list));
      }
      
      • 简单粗暴
  • <4> 处,调用 #getExclusions(AnnotationMetadata metadata, AnnotationAttributes attributes) 方法,获得需要排除的配置类。详细解析,见 「5.4.3 getExclusions」 。

    • <4.1> 处,调用 #checkExcludedClasses(List<String> configurations, Set<String> exclusions) 方法,校验排除的配置类是否合法。详细解析,见 「5.4.4 checkExcludedClasses」 。
    • <4.2> 处,从 configurations 中,移除需要排除的配置类。
  • <5> 处,调用 #filter(List<String> configurations, AutoConfigurationMetadata autoConfigurationMetadata) 方法,根据条件(Condition),过滤掉不符合条件的配置类。

  • <6> 处,调用 #fireAutoConfigurationImportEvents(List<String> configurations, Set<String> exclusions) 方法,触发自动配置类引入完成的事件。详细解析,见 「5.4.5 fireAutoConfigurationImportEvents」]。

  • <7> 处,创建 AutoConfigurationEntry 对象。

整个 「5.4 getAutoConfigurationEntry」看完后,请跳回 「5.3.3 selectImports」

5.4.1 isEnabled

isEnabled(AnnotationMetadata metadata) 方法,判断是否开启自动配置。代码如下:

protected boolean isEnabled(AnnotationMetadata metadata) {
    // 判断 "spring.boot.enableautoconfiguration" 配置判断,是否开启自动配置。
    // 默认情况下(未配置),开启自动配置。
	if (getClass() == AutoConfigurationImportSelector.class) {
		return getEnvironment().getProperty(EnableAutoConfiguration.ENABLED_OVERRIDE_PROPERTY, Boolean.class, true);
	}
	return true;
}

5.4.2 getAttributes

getAttributes(AnnotationMetadata metadata) 方法,获得注解的属性。代码如下:

protected AnnotationAttributes getAttributes(AnnotationMetadata metadata) {
	String name = getAnnotationClass().getName();
	// 获得注解的属性
	AnnotationAttributes attributes = AnnotationAttributes.fromMap(metadata.getAnnotationAttributes(name, true));
	// 断言
	Assert.notNull(attributes,
			() -> "No auto-configuration attributes found. Is "
					+ metadata.getClassName() + " annotated with "
					+ ClassUtils.getShortName(name) + "?");
	return attributes;
}
  • 注意,此处 getAnnotationClass().getName() 返回的是 @EnableAutoConfiguration 注解,所以这里返回的注解属性,只能是 excludeexcludeName 这两个。

  • 举个例子,假设 Spring 应用上的注解如下:

    @SpringBootApplication(exclude = {SpringApplicationAdminJmxAutoConfiguration.class},
        scanBasePackages = "cn.iocoder")
    
    • 返回的结果,如下图:【SpringBoot源码剥析】| 自动配置原理 attributes

5.4.3 getExclusions

getExclusions(AnnotationMetadata metadata, AnnotationAttributes attributes) 方法,获得需要排除的配置类。代码如下:

// AutoConfigurationImportSelector.java

protected Set<String> getExclusions(AnnotationMetadata metadata, AnnotationAttributes attributes) {
	Set<String> excluded = new LinkedHashSet<>();
	// 注解上的 exclude 属性
	excluded.addAll(asList(attributes, "exclude"));
	// 注解上的 excludeName 属性
	excluded.addAll(Arrays.asList(attributes.getStringArray("excludeName")));
	// 配置文件的 spring.autoconfigure.exclude 属性
	excluded.addAll(getExcludeAutoConfigurationsProperty());
	return excluded;
}
  • 一共有三种方式,配置排除属性。

  • 该方法会调用如下的方法,比较简单,胖友自己瞅瞅。

    private List<String> getExcludeAutoConfigurationsProperty() {
        // 一般来说,会走这块的逻辑
    	if (getEnvironment() instanceof ConfigurableEnvironment) {
    		Binder binder = Binder.get(getEnvironment());
    		return binder.bind(PROPERTY_NAME_AUTOCONFIGURE_EXCLUDE, String[].class).map(Arrays::asList).orElse(Collections.emptyList());
    	}
    	String[] excludes = getEnvironment().getProperty(PROPERTY_NAME_AUTOCONFIGURE_EXCLUDE, String[].class);
    	return (excludes != null) ? Arrays.asList(excludes) : Collections.emptyList();
    }
    
    protected final List<String> asList(AnnotationAttributes attributes, String name) {
    	String[] value = attributes.getStringArray(name);
    	return Arrays.asList(value);
    }
    

5.4.4 checkExcludedClasses

checkExcludedClasses(List<String> configurations, Set<String> exclusions) 方法,校验排除的配置类是否合法。代码如下:

private void checkExcludedClasses(List<String> configurations, Set<String> exclusions) {
    // 获得 exclusions 不在 invalidExcludes 的集合,添加到 invalidExcludes 中
    List<String> invalidExcludes = new ArrayList<>(exclusions.size());
    for (String exclusion : exclusions) {
        if (ClassUtils.isPresent(exclusion, getClass().getClassLoader()) // classpath 存在该类
                && !configurations.contains(exclusion)) { // configurations 不存在该类
            invalidExcludes.add(exclusion);
        }
    }
    // 如果 invalidExcludes 非空,抛出 IllegalStateException 异常
    if (!invalidExcludes.isEmpty()) {
        handleInvalidExcludes(invalidExcludes);
    }
}

/**
 * Handle any invalid excludes that have been specified.
 * @param invalidExcludes the list of invalid excludes (will always have at least one
 * element)
 */
protected void handleInvalidExcludes(List<String> invalidExcludes) {
    StringBuilder message = new StringBuilder();
    for (String exclude : invalidExcludes) {
        message.append("\t- ").append(exclude).append(String.format("%n"));
    }
    throw new IllegalStateException(String.format("The following classes could not be excluded because they are"
                    + " not auto-configuration classes:%n%s", message));
}
  • 不合法的定义,exclusions 存在于 classpath 中,但是不存在 configurations 。这样做的目的是,如果不存在的,就不要去排除啦!
  • 代码比较简单,自己瞅瞅即可。

5.4.5 fireAutoConfigurationImportEvents

fireAutoConfigurationImportEvents(List<String> configurations, Set<String> exclusions) 方法,触发自动配置类引入完成的事件。代码如下:

private void fireAutoConfigurationImportEvents(List<String> configurations, Set<String> exclusions) {
    // <1> 加载指定类型 AutoConfigurationImportListener 对应的,在 `META-INF/spring.factories` 里的类名的数组。
	List<AutoConfigurationImportListener> listeners = getAutoConfigurationImportListeners();
	if (!listeners.isEmpty()) {
	    // <2> 创建 AutoConfigurationImportEvent 事件
		AutoConfigurationImportEvent event = new AutoConfigurationImportEvent(this, configurations, exclusions);
		// <3> 遍历 AutoConfigurationImportListener 监听器们,逐个通知
		for (AutoConfigurationImportListener listener : listeners) {
		    // <3.1> 设置 AutoConfigurationImportListener 的属性
			invokeAwareMethods(listener);
			// <3.2> 通知
			listener.onAutoConfigurationImportEvent(event);
		}
	}
}
  • <1> 处,调用 #getAutoConfigurationImportListeners() 方法,加载指定类型 AutoConfigurationImportListener 对应的,在 META-INF/spring.factories 里的类名的数组。例如:【SpringBoot源码剥析】| 自动配置原理 listeners

  • <2> 处,创建 AutoConfigurationImportEvent 事件。

  • <3> 处,遍历 AutoConfigurationImportListener 监听器们,逐个通知。

    • <3.1> 处,调用 #invokeAwareMethods(Object instance) 方法,设置 AutoConfigurationImportListener 的属性。代码如下:

      private void invokeAwareMethods(Object instance) {
          // 各种 Aware 属性的注入
      	if (instance instanceof Aware) {
      		if (instance instanceof BeanClassLoaderAware) {
      			((BeanClassLoaderAware) instance).setBeanClassLoader(this.beanClassLoader);
      		}
      		if (instance instanceof BeanFactoryAware) {
      			((BeanFactoryAware) instance).setBeanFactory(this.beanFactory);
      		}
      		if (instance instanceof EnvironmentAware) {
      			((EnvironmentAware) instance).setEnvironment(this.environment);
      		}
      		if (instance instanceof ResourceLoaderAware) {
      			((ResourceLoaderAware) instance).setResourceLoader(this.resourceLoader);
      		}
      	}
      }
      
      • 各种 Aware 属性的注入。
    • <3.2> 处,调用 AutoConfigurationImportListener#onAutoConfigurationImportEvent(event) 方法,通知监听器。目前只有一个 ConditionEvaluationReportAutoConfigurationImportListener 监听器,没啥逻辑,有兴趣自己看哈。

6. AutoConfigurationPackages

org.springframework.boot.autoconfigure.AutoConfigurationPackages ,自动配置所在的包名。可能这么解释有点怪怪的,我们来看下官方注释:

Class for storing auto-configuration packages for reference later (e.g. by JPA entity scanner).
  • 简单来说,就是将使用 @AutoConfigurationPackage 注解的类所在的包(package),注册成一个 Spring IOC 容器中的 Bean 。酱紫,后续有其它模块需要使用,就可以通过获得该 Bean ,从而获得所在的包。例如说,JPA 模块,需要使用到。

6.1 Registrar

Registrar ,是 AutoConfigurationPackages 的内部类,实现 ImportBeanDefinitionRegistrar、DeterminableImports 接口,注册器,用于处理 @AutoConfigurationPackage 注解。代码如下:

static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {

	@Override
	public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
		register(registry, new PackageImport(metadata).getPackageName()); // <X>
	}

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

}
  • PackageImport 是 AutoConfigurationPackages 的内部类,用于获得包名。代码如下:

    private static final class PackageImport {
    
        /**
         * 包名
         */
        private final String packageName;
    
        PackageImport(AnnotationMetadata metadata) {
            this.packageName = ClassUtils.getPackageName(metadata.getClassName());
        }
    
        public String getPackageName() {
            return this.packageName;
        }
    
        @Override
        public boolean equals(Object obj) {
            if (obj == null || getClass() != obj.getClass()) {
                return false;
            }
            return this.packageName.equals(((PackageImport) obj).packageName);
        }
    
        @Override
        public int hashCode() {
            return this.packageName.hashCode();
        }
    
        @Override
        public String toString() {
            return "Package Import " + this.packageName;
        }
    
    }
    
    • 如下是一个示例:PackageImportPackageImport
  • <X> 处,调用 #register(BeanDefinitionRegistry registry, String... packageNames) 方法,注册一个用于存储报名(package)的 Bean 到 Spring IOC 容器中。详细解析,见 「6.2 register」。

6.2 register

register(BeanDefinitionRegistry registry, String... packageNames) 方法,注册一个用于存储报名(package)的 Bean 到 Spring IOC 容器中。代码如下:

private static final String BEAN = AutoConfigurationPackages.class.getName();

public static void register(BeanDefinitionRegistry registry, String... packageNames) {
    // <1> 如果已经存在该 BEAN ,则修改其包(package)属性
	if (registry.containsBeanDefinition(BEAN)) {
		BeanDefinition beanDefinition = registry.getBeanDefinition(BEAN);
		ConstructorArgumentValues constructorArguments = beanDefinition.getConstructorArgumentValues();
		constructorArguments.addIndexedArgumentValue(0, addBasePackages(constructorArguments, packageNames));
    // <2> 如果不存在该 BEAN ,则创建一个 Bean ,并进行注册
    } else { GenericBeanDefinition beanDefinition = new GenericBeanDefinition();
		beanDefinition.setBeanClass(BasePackages.class);
		beanDefinition.getConstructorArgumentValues().addIndexedArgumentValue(0, packageNames);
		beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
		registry.registerBeanDefinition(BEAN, beanDefinition);
	}
}
  • 注册的 BEAN 的类型,为 BasePackages 类型。它是 AutoConfigurationPackages 的内部类。代码如下:

    static final class BasePackages {
    
    	private final List<String> packages;
    
    	private boolean loggedBasePackageInfo;
    
    	BasePackages(String... names) {
    		List<String> packages = new ArrayList<>();
    		for (String name : names) {
    			if (StringUtils.hasText(name)) {
    				packages.add(name);
    			}
    		}
    		this.packages = packages;
    	}
    
    	public List<String> get() {
    		if (!this.loggedBasePackageInfo) {
    			if (this.packages.isEmpty()) {
    				if (logger.isWarnEnabled()) {
    					logger.warn("@EnableAutoConfiguration was declared on a class "
    							+ "in the default package. Automatic @Repository and "
    							+ "@Entity scanning is not enabled.");
    				}
    			} else {
    				if (logger.isDebugEnabled()) {
    					String packageNames = StringUtils
    							.collectionToCommaDelimitedString(this.packages);
    					logger.debug("@EnableAutoConfiguration was declared on a class "
    							+ "in the package '" + packageNames
    							+ "'. Automatic @Repository and @Entity scanning is "
    							+ "enabled.");
    				}
    			}
    			this.loggedBasePackageInfo = true;
    		}
    		return this.packages;
    	}
    
    }
    
    • 就是一个有 packages 属性的封装类。
  • <1>处,如果已经存在该BEAN,则修改其包(package)属性。而合并package的逻辑,通过#addBasePackages(ConstructorArgumentValues constructorArguments, String[] packageNames)方法,进行实现。代码如下:

    private static String[] addBasePackages(ConstructorArgumentValues constructorArguments, String[] packageNames) {
    	// 获得已存在的
        String[] existing = (String[]) constructorArguments.getIndexedArgumentValue(0, String[].class).getValue();
    	// 进行合并
        Set<String> merged = new LinkedHashSet<>();
    	merged.addAll(Arrays.asList(existing));
    	merged.addAll(Arrays.asList(packageNames));
    	return StringUtils.toStringArray(merged);
    }
    
  • <2> 处,如果不存在该 BEAN ,则创建一个 Bean ,并进行注册。

6.3 has

#has(BeanFactory beanFactory) 方法,判断是否存在该 BEAN 在传入的容器中。代码如下:

public static boolean has(BeanFactory beanFactory) {
	return beanFactory.containsBean(BEAN) && !get(beanFactory).isEmpty();
}

6.4 get

get(BeanFactory beanFactory) 方法,获得 BEAN 。代码如下:

public static List<String> get(BeanFactory beanFactory) {
	try {
		return beanFactory.getBean(BEAN, BasePackages.class).get();
	} catch (NoSuchBeanDefinitionException ex) {
		throw new IllegalStateException("Unable to retrieve @EnableAutoConfiguration base packages");
	}
}

版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。

文章由半码博客整理,本文链接:https://www.bmabk.com/index.php/post/143124.html

(0)

相关推荐

发表回复

登录后才能评论
半码博客——专业性很强的中文编程技术网站,欢迎收藏到浏览器,订阅我们!