SpringBoot自动装配机制(源码)

前言

SpringBoot主启动类被@SpringBootApplication所修饰,点击进去该注解,出现上图,会发现其为组合注解,本章节将会基于注解进行解释其自动装配在源码层面是怎么实现的,完整的注解调用链路如下图所示:

1.元注解

@Target注解

  • 注解的作用目标
  • @Target(ElementType.TYPE)                                           //接口、类、枚举、注解
  • @Target(ElementType.FIELD)                                         //字段、枚举的常量
  • @Target(ElementType.METHOD)                                   //方法
  • @Target(ElementType.PARAMETER)                              //方法参数
  • @Target(ElementType.CONSTRUCTOR)                        //构造函数
  • @Target(ElementType.LOCAL_VARIABLE)                     //局部变量
  • @Target(ElementType.ANNOTATION_TYPE)                //注解
  • @Target(ElementType.PACKAGE)                                 //包    

@Retention注解

  • 修饰注解,是注解的注解,称为元注解
  • SOURCE,     // 编译器处理完Annotation后不存储在class中  
  • CLASS,       // 编译器把Annotation存储在class中,这是默认值  
  • RUNTIME  // 编译器把Annotation存储在class中,可以由虚拟机读取,反射需要

@Documented注解

  • 这个Annotation可以被写入javadoc

上述三个元注解也是实现自定义注解的基础,不是很清楚的可以先看这篇:自定义注解

@Inherited 注解

  • 作用先看这篇:@Inherited作用,简而言之:

@SpringBootApplication注解被@Inherited修饰,则SpringBoot主启动类也就具备了@SpringBootApplication注解的:

@SpringBootConfiguration

@EnableAutoConfiguration

@ComponentScan

2.@ComponentScan注解

这个注解原来在SpringFramework中比较常见,而且其出现位置为配置文件:spring配置文件的applicationContext.xml或者springmvc的配置文件中,用来标识:扫描的包路径,这样就可以将我们定义的注解扫描进去。

在SpringBoot中,其关键作用是:默认扫描当前配置类所在包及子包下的所有组件, exclude 属性会将主启动类、自动配置类屏蔽掉

2.1 TypeExcludeFilter注解

其核心代码简单PO出,依赖BeanFactory,这个BeanFactory就是SpringFramework接口体系中的顶层,定义了基本的方法,如:getBean,containsBean,isSingleton,getType,isTypeMatch等。如下图(体系要比这个更丰富,推荐大家自己在Idea中生成查看,看SpringBoot源码的前提,建议先看Spring源码):

TypeExcludeFilter核心方法为match(),其关键作用在于:拓展组件的过滤提供一种扩展机制,能让我们向IOC容器中注册一些自定义的组件过滤器,以在包扫描的过程中过滤它们会从 BeanFactory 中获取所有类型为 TypeExcludeFilter 的组件,去执行自定义的过滤方法。

2.2 AutoConfigurationExcludeFilter注解

其核心方法和TypeExcludeFilter一样,match()方法,但是实现有所区别,AutoConfigurationExcludeFilter的核心是:判断是否是一个配置类,且同时是否是一个自动配置的配置类

2.3 问题:SpringBoot怎么过滤不需要的组件

【面试题】:Spring IOC容器在boot中也是存在的对吧,那有一些Bean我不想在启动时就注入IOC容器,这种情况有遇到过吗?

【个人理解】:目前还没遇到,不过要是实现的话,在启动类上加上@ComponentScan注解,在value中写上指定的:*.class是可以实现的【参见2.4小结】,或继承TypeExcludeFilter ,重写match方法,如默认会加载com.test.TestService这个bean,则重写的方法中,

public class MyTypeExcludeFilter extends TypeExcludeFilter {
    @Override
    public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory)
            throws IOException {
        if("com.test.TestService".equals(metadataReader.getClassMetadata().getClassName())){
            return false;
        }
        return true;
    }
}

或者直接在boot配置文件中添加,其是支持的【但是我没细究如何配置,这个百度下应该就有】,如下:

2.4 小结

上述之后我们都能知道两个Exclude都有match方法,但是匹配什么?过滤什么?至少我在第一次看的时候还是很懵的,目前我的认知总结如下,可能不是很准确,提供出来给大家参考一下:

@ComponentScan注解会扫描Bean完成IOC注入,但是有一部分我们是不需要注入进IOC容器的,那么这种场景下我们就可以借助于我们这一小章节的注解进行实现,其实现方法就是:

import org.springframework.context.annotation.FilterType;

import org.springframework.context.annotation.ComponentScan;

@ComponentScan(excludeFilters = {@ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE, classes = {TestBean.class})})

这种方式是官方给的一个参考方式,但是我们也可以清楚的看到弊端:仅适用于少量的,如果需要规避的扫描类很多,这个classes将会变的非常冗杂,当然也有很多解决方案,如继承TypeExcludeFilter ,重写match方法,更多方式自行百度下就行。

关于@AutoConfigurationExcludeFilter,能搜到的资料很少,区别就在于多了一部分AutoConfiguration,所以我目前的认知是:二者都能用来处理组件过滤,但是是TypeFilter接口的两种实现,一种主要服务于主启动类组件,一种服务于自动配置的组件,二者结合实现一个完整的组件过滤

上图的BeanFactoryAware,BeanClassLoaderAware在Spring IOC容器中比较常见,也是Spring的Bean生命周期中会遇到的组件,这里就不再赘述,有需要的百度学习下即可,贴个简单的IOC接口体系(实际要更丰富)。

3.@SpringBootConfiguration注解

官方给的解释也是:@SpringBootConfiguration 是对 @Configuration注解(这个我们可能就比较熟悉了,不了解的参考:@Configuration)的一种封装,在上图我们也可看出,其核心作用是:标注在配置类上,且是主启动类(如果@Configuration标注就不必强调是主启动类),基于这个注解,其所在的包路径位置获取之后EnableAutoConfiguration(第4节详细论述)注解扫描的依据,进而扫描出配置文件。

这里也说明了为什么SpringBoot的主启动类,我们是放在包的最外层,因为只有这样,我们的basePackage才能够获取到全部组件。

4.@EnableAutoConfiguration注解

我们简单了解下SpringFramework的装配吧:

其中:@Repository,@Service,@Controller为Component的衍生注解,后面配置实现可以参考这里:链接

【SpringFramework总结】

基于以上三种任意一种方式(我们常用的还是第一种注解模式),就可以实现对应的装配机制,所谓的装配就是告诉我们的Spring我们要用哪些Bean,顶层的BeanFactory的子类ApplicationContext帮我们实现底层细节【IOC接口体系2.3小结有简略版】,IOC容器帮我们完成Bean的注入实现,其缓存机制帮我们规避循环依赖,以实现一个装配体系。

【SpringBoot自动装配开始】

这里我觉得还是直接拷贝其官方解释更好,也顺便翻译一下(个人理解可能会有偏差)

Enable auto-configuration of the Spring Application Context, attempting to guess and
configure beans that you are likely to need. Auto-configuration classes are usually
applied based on your classpath and what beans you have defined. For example, if you
have {@code tomcat-embedded.jar} on your classpath you are likely to want a
{@link TomcatServletWebServerFactory} (unless you have defined your own
{@link ServletWebServerFactory} bean).

-- Spring的自动配置上下文,会大致预估你需要使用的Bean,其依据就是项目中classpath中的jar、配置文件+我们自己定义的Bean(借助于上面SpringFramework的方式之一),举例:比如引入了tomcat-embedded.jar,那么自动配置认为你大概率会使用TomcatServletWebServerFactory,于是就帮你初始化,除非你自己定义了一个自定义Bean:ServletWebServerFactory,即:自定义的优先级>系统默认配置,同级覆盖
    
When using {@link SpringBootApplication @SpringBootApplication}, the auto-configuration
of the context is automatically enabled and adding this annotation has therefore no
additional effect.

-- 当使用@SpringBootApplication注解时,自动配置注解再加到主启动类上不会有什么用,也是因为@SpringBootApplication注解是组合注解,其内部已经包含了自动配置的注解
    
Auto-configuration tries to be as intelligent as possible and will back-away as you
define more of your own configuration. You can always manually {@link #exclude()} any
configuration that you never want to apply (use {@link #excludeName()} if you don't
have access to them). You can also exclude them via the
{@code spring.autoconfigure.exclude} property. Auto-configuration is always applied
after user-defined beans have been registered.

 -- 自动化配置会尽可能地智能化,当你的配置和自动化配置一致时,自动化配置自动就会失效。即用户配置>自动化配置权限。对于你不需要自动化配置的,可以通过exclude进行手动排除(就像上面2.3小结我们举例的
@ComponentScan(excludeFilters = {@ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE, classes = {TestBean.class})})),当然你也可以在配置文件中进行排除:spring.autoconfigure.exclude。
	最后说了下,自动化配置的永远在用户定义的Bean注册之后进行。
    
The package of the class that is annotated with {@code @EnableAutoConfiguration},
usually via {@code @SpringBootApplication}, has specific significance and is often used
as a 'default'. For example, it will be used when scanning for {@code @Entity} classes.
It is generally recommended that you place {@code @EnableAutoConfiguration} (if you're
not using {@code @SpringBootApplication}) in a root package so that all sub-packages
and classes can be searched.

-- 就是说@SpringBootApplication,@EnableAutoConfiguration标注的类是具备意义的,一般会被系统认作默认配置启动类,因此建议标注有 @SpringBootApplication注解的文件最好放在根包中,这样所有的子包才能被扫描到。
    
Auto-configuration classes are regular Spring {@link Configuration @Configuration}
beans. They are located using the {@link SpringFactoriesLoader} mechanism (keyed
against this class). Generally auto-configuration beans are
{@link Conditional @Conditional} beans (most often using
{@link ConditionalOnClass @ConditionalOnClass} and
{@link ConditionalOnMissingBean @ConditionalOnMissingBean} annotations).
    
-- 被@Configuration标注的Spring的Bean就被认为是一个配置类,等同于ApplicationContext.xml,采用SpringFactoriesLoader机制,自动装配Bean常用以下注解实现:@Conditional,@ConditionalOnClass,@ConditionalOnMissingBean

其完整代码如下所示,可看到它也是一个组合注解,主要包括4个元注解+2个自定义注解,所以这两个注解应该就是帮我们实现自动化配置的核心所在了。

4.1 @AutoConfigurationPackage注解概述

这个注解看起来就比较简单了,没有特别的代码,也只有4个元注解+1个自定义注解,但是可以看到这个注解@Import和上面的@EnableAutoConfiguration内部的value还是不一样的,区别在4.2讲解。

  • @EnableAutoConfiguration:AutoConfigurationImportSelector.class
  • @AutoConfigurationPackage:AutoConfigurationPackages.Registrar.class

前面我们也有提到,主启动类必须放在所有自定义组件的包的最外层,以保证Spring能扫描到它们,就是@AutoConfigurationPackage发挥的作用,【作用小结】:保证Spring扫描到所有子包,完成资源的加载.

其实现原理如下4.1.1:


4.2 AutoConfigurationPackage实现原理

在4.1的图可看到,他引入了一个@Import注解,这个注解引入了AutoConfigurationPackages.Registrar

Register 实现了 ImportBeanDefinitionRegister 接口,通过它实现向IOC容器手动注册组件,在重写的 registerBeanDefinitions 方法中,调用外部类的 AutoConfigurationPackages 的 register 方法,其中传参为:new PackageImport(metadata).getPackageName(),而实例化PackageImport的有参构造方法:

PackageImport(AnnotationMetadata metadata) {
    this.packageName = ClassUtils.getPackageName(metadata.getClassName());
}

可看到是通过metadata的类名来获取所在的包名,所以需要明确下metadata是什么?怎么获取的?为什么通过这个就可以获取到对应根包路径?

/**
 * Register bean definitions as necessary based on the given annotation metadata of
 * the importing {@code @Configuration} class.
 * <p>Note that {@link BeanDefinitionRegistryPostProcessor} types may <em>not</em> be
 * registered here, due to lifecycle constraints related to {@code @Configuration}
 * class processing.
 * <p>The default implementation is empty.
 * @param importingClassMetadata annotation metadata of the importing class
 * @param registry current bean definition registry
 */
default void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
}

4.2.1.metadata是什么及获取方式?

这个是官方提供的registerBeanDefinitions方法的释义,重点就在:

@param importingClassMetadata annotation metadata of the importing class,即:传参是导入类的原信息,实际就是被@Import标注的class信息,实际就是我们每个SpringBoot启动类的类信息【这里我们能知道,他通过Register类重写的registerBeanDefinitions方法获取被@Import标注的类信息,即SpringBoot启动类的类信息,而启动类我们都是放在根包下面的,所以大概知道个端倪了】

4.2.2.metadata能做什么?

拿到了metadata这个形参,具体做什么就是这个方法要做的了,所以我们再回头看下这个4.1.1中的register方法。

大致思路是:首先会判断当前IOC容器中,是否已经有这个AutoConfigurationPackages,其中的BEAN是这个类的静态变量:private static final String BEAN = AutoConfigurationPackages.class.getName();

如果已经有了,则将其添加到basePackage【这个我们前面也有提到,实际就是一个去重之后是String数组,存储根包及所有子包组件,包含系统默认组件+用户自定义组件】中

如果没有,会创建一个新的Bean【存放在一个ConcurrentHashMap中维护,初始化size=256】,在else逻辑第三行会发现调用了一样方法:addIndexedArgumentValue,不同之处在于这里的第二个参数是直接传入的packageNames,即直接将主启动类的包名添加到basePackage中.即该注解还会帮我们完成Bean的注册与缓存。


4.2.3.问题:basePackages去重?为什么if-else两套?

【面试题】:register方法能获取所有的basePackage你刚讲到了,但是他怎么做到去重的呢?为什么这里需要有if-else两套逻辑,而且两套逻辑里的packageNames一个是直接添加,一个是调用方法呢?

【个人理解】:去重就是借助于一个Set<String>做到的,如下源码:

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);
}

之所以就if-else两套逻辑,也是和Spring的Bean的IOC工厂一样,Bean是有缓存的,Bean的创建是单例+缓存进行存储的,底层是借助于一个size=256的ConcurrentHashMap【可能会问你Map体系了,顺便转移话题深度】进行存储,可以规避一些性能损耗,也可以快速响应,第一次那就先创建再添加,第一次创建的肯定没有添加到basePackage中,之后可能就已经添加过了,就需要进行去重了。一句带过就是:首次创建的Bean不会存在packageNames重复问题,而已存在的Bean可能已经添加过,需要借助于Set<String>进行去重,保证最后的basePackages都是唯一的。


4.2.4.小结

结合以上,我们能知道SpringBoot的自动配置,重要的一环就是获取全部的basePackage,而获取的方式是借助于@AutoConfigurationPackage 注解所引入的AutoConfigurationPackages.Register,对应的就是AutoConfigurationPackages下面的Register方法,该方法重写的registerBeanDefinitions方法帮我们获取全部的basePackages,同时帮我们做Bean注入,缓存,packageNames去重处理,以保证获取的name均为唯一。

4.3 AutoConfigurationImportSelector[核心]

注意每一层调用关系不要混乱,4.1-4.2平级,4.1.1是4.1的调用,4.1主要作用是获取basePackage,4.1.1是它的实现细节。

下面是AutoConfigurationImportSelector的继承关系视图,可以看到他继承了一系列的Aware接口,这也就保证了Bean在被初始化之后,能够获取对应的Aware资源【Aware系列在Spring的Bean声明周期中有强烈存在感,不是很清楚的可以百度下】

4.3.1 @DeferredImportSelector

DeferredImportSelector继承自ImportSelector,DeferredImportSelector 的执行时机,是在 @Configuration 注解中的其他逻辑被处理完毕之后(包括对 @ImportResource@Bean 这些注解的处理)再执行 ,即DeferredImportSelector 的执行时机比 ImportSelector 更晚。

4.3.2 实现原理[核心]

【步骤1】:判断系统配置项是否开启了自动配置,也就是 isEnabled 方法,该方法默认true,未开启直接结束。

protected boolean isEnabled(AnnotationMetadata metadata) {
    if (getClass() == AutoConfigurationImportSelector.class) {
        return getEnvironment().getProperty(EnableAutoConfiguration.ENABLED_OVERRIDE_PROPERTY, Boolean.class, true);
    }
    return true;
}

getProperty方法三个参数

  • 第一个:当前环境变量配置的key,会通过这个key查找配置文件配置的value
  • 第二个:返回类型,转义成Boolean
  • 第三个:默认值true

【步骤2】:获取元数据,入参path:META-INF/spring-autoconfigure-metadata.properties

static AutoConfigurationMetadata loadMetadata(ClassLoader classLoader, String path) {
    try {
        Enumeration<URL> urls = (classLoader != null) ? classLoader.getResources(path)
            : ClassLoader.getSystemResources(path);
        Properties properties = new Properties();
        while (urls.hasMoreElements()) {
            properties.putAll(PropertiesLoaderUtils.loadProperties(new UrlResource(urls.nextElement())));
        }
        return loadMetadata(properties);
    }
    catch (IOException ex) {
        throw new IllegalArgumentException("Unable to load @ConditionalOnClass location [" + path + "]", ex);
    }
}

可以看到在三目运算符中,用户配置>系统配置,AutoConfigurationMetadata是借助于属性文件实现的内部类进行返回的。

【步骤3】:核心是加载自动配置类,上来还是判断是否开启了自动配置,没则直接结束

protected AutoConfigurationEntry getAutoConfigurationEntry(AutoConfigurationMetadata autoConfigurationMetadata,
			AnnotationMetadata annotationMetadata) {
    if (!isEnabled(annotationMetadata)) {
        return EMPTY_ENTRY;
    }
    // 1.获取所有的attributes
    AnnotationAttributes attributes = getAttributes(annotationMetadata);
    
    // 2.SPI机制加载自动配置类configurations
    List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
   
    // 3.步骤2结果去重
    configurations = removeDuplicates(configurations);
    
     // 4.基于1获取全部去重的Exclusion【过滤限制的配置项】
    Set<String> exclusions = getExclusions(annotationMetadata, attributes);
    
    /**
     * 5.检查是否有无效Exclusion,有则抛出IllegalStateException
     * The following classes could not be excluded because they are not auto-configuration classes
	 * 不能排除下列类,因为它们不是自动配置类
     */
    checkExcludedClasses(configurations, exclusions);
    
    // 6.清空configurations中的exclusions
    configurations.removeAll(exclusions);
   
     // 7.重新生成configurations,前面4.2的继承体系在这里发挥作用
    configurations = filter(configurations, autoConfigurationMetadata);
    fireAutoConfigurationImportEvents(configurations, exclusions);
    return new AutoConfigurationEntry(configurations, exclusions);
}

其中方法调用链路粗略绘制,如下所示:

关于SpringFactoriesLoader.loadFactoryNames方法,这里还是需要说明一下,关键就在于这个方法,帮我们实现的全局自动配置

所以自动装配最后还是会回到配置文件,基于配置文件spring.factories的:   org.springframework.boot.autoconfigure.EnableAutoConfiguration=,去加载自动配置类的全限定类名,这个结果会是一个很长的字符串,如下:

之后装配到IOC容器中,之后的自动配置类就可以通过 ImportSelector 和 @Import 的机制被创建出,开始生效。

【SpringBoot自动装配结束】

4.3.3 自动装配做了什么

自动装配的最大好处,我觉得以下面这个例子说明应该就比较直观了。在传统的SSM框架中,我们使用Redis时候,需要在xml中定义Bean才可以使用,如:

<!-- redis template definition -->
<bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
  <property name="connectionFactory" ref="jedisConnectionFactory" />
  <property name="keySerializer">
    <bean class="org.springframework.data.redis.serializer.StringRedisSerializer" />
  </property>
  <property name="valueSerializer">
    <bean class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer" />
  </property>
  <property name="hashKeySerializer">
    <bean class="org.springframework.data.redis.serializer.StringRedisSerializer" />
  </property>
  <property name="hashValueSerializer">
    <bean class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer" />
  </property>
  <!--开启事务  -->  
  <property name="enableTransactionSupport" value="true"></property>  
</bean>

用的时候就这样声明式调用:

@Autowired 
public RedisTemplate redisTemplate;

但是在SpringBoot框架中,我们引入jar包之后,只需要下面这样就可以直接使用,仔细看下你的SpringBoot项目是不是直接使用的,原因就在于自动化配置帮我们实现了。这应该就是最直观的感受了。

5.总结

@SpringBootApplication这个组合注解,主要分4个元注解+3个自定义注解:

@ComponentScan告诉去哪里扫描,如果遇到不想在启动初期加载进IOC容器的,主启动类组件通过TypeExcludeFilter,自动配置组件通过AutoConfigurationExcludeFilter进行过滤。

@SpringBootConfiguration标注主启动类,声明为一个配置类,为@EnableAutoConfiguration服务。

@EnableAutoConfiguration是自动化配置的核心,标识开启自动配置,是一个派生注解,其两个核心:@AutoConfigurationPackage帮助完成Bean注册,获取全部去重的packageNames;@AutoConfigurationImportSelector核心是借助于ImportSelector接口的selectImport方法实现,层层调用之后,最终会获取spring.factories文件下的配置信息,取到EnableAutoConfiguration指定的值,将这些值作为自动配置类导入到容器中,自动配置类就生效,帮我们进行自动配置工作。以前我们需要自己配置的东西,自动配置类都帮我们完成了。