Spring注解之@Autowired

前言

    说起Spring的@Autowired注解,想必大家已经熟悉的不能再熟悉了。本文就针对此最常用的注解,梳理一下它的功能和原理,争取从源码的角度将此注解讲通,如有写的不准确的地方,欢迎各位园友拍砖。

注:此篇博文基于Spring5.1.10.RELEASE,SpringBoot2.1.9.RELEASE

正文

    首先看一下@Autowired注解的源码

 1 package org.springframework.beans.factory.annotation;
 2 
 3 import java.lang.annotation.Documented;
 4 import java.lang.annotation.ElementType;
 5 import java.lang.annotation.Retention;
 6 import java.lang.annotation.RetentionPolicy;
 7 import java.lang.annotation.Target;
 8 
 9 @Target({ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD, ElementType.ANNOTATION_TYPE})
10 @Retention(RetentionPolicy.RUNTIME)
11 @Documented
12 public @interface Autowired {
13 
14     /**
15      * Declares whether the annotated dependency is required.
16      * <p>Defaults to {@code true}.
17      */
18     boolean required() default true;
19 
20 }

    可以看到,此注解运行时生效,且适用范围很广,从构造器,到方法,到参数、属性、注解,都可以加上@Autowired注解。它还有一个属性required,此属性用于控制如果找不到要依赖注入的对象时是否报错,默认true即默认找不到要注入的对象时会报错。下面我们慢慢梳理,将@Autowired的使用场景一一罗列出来。

一、普通用法,依赖注入成员变量

下面将要用的测试类贴出来,首先是接口

1 package com.mybokeyuan.springAutowiredDemo;
2 
3 public interface IndexInterface {
4 }

再就是两个子类

1 package com.mybokeyuan.springAutowiredDemo;
2 
3 import org.springframework.stereotype.Component;
4 
5 @Component
6 public class IndexService implements IndexInterface{
7 
8 }
1 package com.mybokeyuan.springAutowiredDemo;
2 
3 import org.springframework.stereotype.Component;
4 
5 @Component
6 public class OtherIndexService implements IndexInterface{
7     
8 }

核心类(后续的各种场景演示均只基于此类进行改动)

 1 package com.mybokeyuan.springAutowiredDemo;
 2 
 3 import org.springframework.beans.factory.annotation.Autowired;
 4 import org.springframework.stereotype.Component;
 5 
 6 @Component
 7 public class MyService {
 8 
 9     @Autowired
10     private IndexService indexService;
11 
12 }

扫描配置类

1 package com.mybokeyuan.springAutowiredDemo;
2 
3 import org.springframework.context.annotation.ComponentScan;
4 import org.springframework.context.annotation.Configuration;
5 
6 @Configuration
7 @ComponentScan("com.mybokeyuan.springAutowiredDemo")
8 public class AutowiredConfig {
9 }

main方法类

 1 package com.mybokeyuan.springAutowiredDemo.client;
 2 
 3 import com.mybokeyuan.springAutowiredDemo.AutowiredConfig;
 4 import com.mybokeyuan.springAutowiredDemo.MyService;
 5 import org.springframework.context.annotation.AnnotationConfigApplicationContext;
 6 
 7 public class DemoClientTest {
 8     public static void main(String[] args) {
 9         AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(AutowiredConfig.class);
10         System.out.println(ac.getBean(MyService.class));
11 
12     }
13 }

运行main方法时,如果在第10行打了断点,会看到MyService中的indexService属性已经依赖注入了值,这是我们最常使用@Autowired注解的场景。

二、依赖注入方法

 MyService类如下所示

 1 package com.mybokeyuan.springAutowiredDemo;
 2 
 3 import org.springframework.beans.factory.annotation.Autowired;
 4 import org.springframework.context.ApplicationContext;
 5 import org.springframework.stereotype.Component;
 6 
 7 import java.util.List;
 8 
 9 @Component
10 public class MyService {
11 
12     private IndexService indexService;
13 
14     @Autowired
15     public void getIndexInterf (IndexService index) {
16         indexService = index;
17     }
18 
19     @Autowired
20     private ApplicationContext applicationContext;
21 
22 }

运行main方法后,会发现该类中的indexService完成了注入,这样的用法类似于set方法的功能。并且可以看到,applicationContext也注入了。所以往后就不要用ApplicationContextAware了,直接@Autowired轻快便捷的达到目的。

三、构造方法注入参数

 MyService类如下所示:

 1 package com.mybokeyuan.springAutowiredDemo;
 2 
 3 import org.springframework.beans.factory.annotation.Autowired;
 4 import org.springframework.stereotype.Component;
 5 
 6 import java.util.List;
 7 
 8 @Component
 9 public class MyService {
10 
11 
12     private IndexService indexService;
13 
14     private List<IndexInterface> indexList;
15 
16     @Autowired
17     public MyService (List<IndexInterface> indexList, IndexService indexService) {
18         this.indexList = indexList;
19         this.indexService = indexService;
20     }
21 }

        运行后会发现成员变量indexList和indexService中已经注入了值。此处需要注意一点,如果有两个自定义构造方法,两个都没加@Autowired注解,则会报错,因为Spring不知道你要用哪个构造方法初始化;

如果只有一个构造方法加了@Autowired注解,那么就会用这个构造方法初始化;同理,如果有多个构造方法都加了@Autowired注解,那么还是会报错。

四、注入Map、List等集合

 在【一、普通用法】中的MyService里添加几个成员变量,如下所示:

 1 package com.mybokeyuan.springAutowiredDemo;
 2 
 3 import org.springframework.beans.factory.annotation.Autowired;
 4 import org.springframework.stereotype.Component;
 5 
 6 import java.util.List;
 7 import java.util.Map;
 8 import java.util.Set;
 9 
10 @Component
11 public class MyService {
12     
13     @Autowired
14     private IndexService indexService;
15 
16     @Autowired
17     private List<IndexInterface> indexList;
18 
19     @Autowired
20     private Map<String, IndexInterface> indexMap;
21 
22     @Autowired
23     private Set<IndexInterface> indexSet;
24 }

再次运行main方法,在断点中可以看到从Spring中获取到的MyService对象中,已经完成了对后面三个集合的依赖注入,如下图所示:

 

可以看到,IndexInterface接口的两个实现类全部注入到了集合中,且Map里面的key默认就是两个实现类各自的beanName。

 

五、源码分析

        看了上面的各种使用场景,想必大家会对这个最熟悉的注解有了一丝陌生的感觉,不过不要紧,下面咱们慢慢来脱下TA的神秘衣服,对ta重新熟悉起来。我这里是以下面的MyService类为例子进行的源码debug分析。

 1 package com.mybokeyuan.springAutowiredDemo;
 2 
 3 import org.springframework.beans.factory.annotation.Autowired;
 4 import org.springframework.context.ApplicationContext;
 5 import org.springframework.stereotype.Component;
 6 
 7 import java.util.List;
 8 
 9 @Component
10 public class MyService {
11 
12 
13     private IndexService indexService;
14 
15     private List<IndexInterface> indexList;
16 
17     @Autowired
18     public void getIndexInterf (IndexService index) {
19         indexService = index;
20     }
21 
22     @Autowired
23     private ApplicationContext applicationContext;
24 
25     @Autowired
26     public MyService (List<IndexInterface> indexList) {
27         this.indexList = indexList;
28     }
29 }

        首先在AutowiredAnnotationBeanPostProcessor#postProcessProperties的方法中打上一个断点,然后右键断点加上条件过滤 beanName.equals("myService"),debug运行main方法,会在断点处停住,此时我们的调用栈是下图这样的:

        相信对Spring源码有过了解的园友对调用栈中的方法都不陌生,从下往上看,先经过了refresh方法,在finishBeanFactoryInitialization方法中getBean,然后走getObject的时候触发bean的初始化。

bean的初始化是一个很复杂地方,在AbstractAutowireCapableBeanFactory#doCreateBean方法中,先创建一个BeanWrapper,它的内部成员变量wrappedObject中存放的就是实例化的MyService对象,只是此时未完成初始化,所以属性都是null(如下图所示)。再往后进入populateBean方法进行属性注入,这才逐渐逼近我们的目的地。

         不过在进入populateBean之前,需要先去看一下前置方法,即BeanWrapper创建的方法createBeanInstance。Spring在这个方法中先推断出合适的构造方法,然后实例化bean。在推断构造方法的时候(AbstractAutowireCapableBeanFactory#determineConstructorsFromBeanPostProcessors方法中调用了AutowiredAnnotationBeanPostProcessor#determineCandidateConstructors方法进行的推断),有一个筛选标准就是会根据是否有@Autowired注解来选择用哪个构造器,具体详见AutowiredAnnotationBeanPostProcessor#findAutowiredAnnotation方法,此方法如下所示,功能就是看看当前构造器上加没加注解。

 1     @Nullable
 2     private AnnotationAttributes findAutowiredAnnotation(AccessibleObject ao) {
 3         if (ao.getAnnotations().length > 0) {  // autowiring annotations have to be local
 4             for (Class<? extends Annotation> type : this.autowiredAnnotationTypes) {// 此集合中只有两个值,一个是Autowired注解,一个是Value注解
 5                 AnnotationAttributes attributes = AnnotatedElementUtils.getMergedAnnotationAttributes(ao, type);
 6                 if (attributes != null) {
 7                     return attributes;
 8                 }
 9             }
10         }
11         return null;
12     }

此处构造器的推断和属性注入,就是使用场景三【三、构造方法注入参数】中,@Autowired注解加在构造器上发挥的作用。

走完createBeanInstance方法得到的BeanWrapper中,可以看到属性wrappedObject中已经对indexList进行了依赖注入

 

进行到这里,有必要重新梳理清楚类构造器注入时的调用关系,示例的调用栈图如下所示:

1、在myService对象进行实例化调用构造器时,执行AbstractAutowireCapableBeanFactory#autowireConstructor方法;

2、进入到另一个类ConstructorResolver的autowireConstructor方法中;

2.1、调用同类下的resolveAutowiredArgument方法,该方法会调用DefaultListableBeanFactory下的resolveDependency方法,此方法会调用到findAutowireCandidates方法,在该方法中有如下代码

1 for (String candidate : candidateNames) {
2             if (!isSelfReference(beanName, candidate) && isAutowireCandidate(candidate, descriptor)) {
3                 addCandidateEntry(result, candidate, descriptor, requiredType);
4             }
5         }

其中的candidateNames就是构造器中要注入的对象名字indexService和otherIndexService,此处通过循环调用addCandidateEntry来获取这两个name对应的bean;

2.2、在DefaultListableBeanFactory的addCandidateEntry方法中,调到了DependencyDescriptor#resolveCandidate方法,在此方法中调用的getBean方法获取它的成员变量bean。

DependencyDescriptor#resolveCandidate方法如下所示:

1     public Object resolveCandidate(String beanName, Class<?> requiredType, BeanFactory beanFactory)
2             throws BeansException {
3 
4         return beanFactory.getBean(beanName);
5     }

 然后又进入了下一次的getBean逻辑。此处就是这样完成的构造器方法参数注入。

 

    下面进入populateBean中。看源码经过一个for循环和一个NAME或者TYPE模式的判断之后,进入了BeanPostProcessor的循环调用中,通过遍历后置处理器,调用了AutowiredAnnotationBeanPostProcessor#postProcessProperties,也就是一开始我们打断点的地方,该方法源码如下:

 1 @Override
 2     public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
 3         InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);
 4         try {
 5             metadata.inject(bean, beanName, pvs);
 6         }
 7         catch (BeanCreationException ex) {
 8             throw ex;
 9         }
10         catch (Throwable ex) {
11             throw new BeanCreationException(beanName, "Injection of autowired dependencies failed", ex);
12         }
13         return pvs;
14     }

在第13行打断点,发现到13行的时候,bean中的属性已经被注入了,所以可以知道,是在第5行进行的属性注入。

继续跟踪第5行,进入InjectionMetadata#inject方法:

 1 public void inject(Object target, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
 2         Collection<InjectedElement> checkedElements = this.checkedElements;
 3         Collection<InjectedElement> elementsToIterate =
 4                 (checkedElements != null ? checkedElements : this.injectedElements);
 5         if (!elementsToIterate.isEmpty()) {
 6             for (InjectedElement element : elementsToIterate) {
 7                 if (logger.isTraceEnabled()) {
 8                     logger.trace("Processing injected element of bean '" + beanName + "': " + element);
 9                 }
10                 element.inject(target, beanName, pvs);
11             }
12         }
13     }

 发现是从当前metadata对象中取的element对象,而通过断点可以看到,checkedElements中的Member对象就是当前bean中加了@Autowired注解的成员变量或者普通方法在反射包中对应的对象,随后通过element的inject方法进行的注入。那么问题来了,element对象是如何创建来的?inject方法又是如何将bean注入到成员变量中的?

 对于element对象的创建,还要返回postProcessProperties方法中查看上面的findAutowiringMetadata方法:

 1 private InjectionMetadata findAutowiringMetadata(String beanName, Class<?> clazz, @Nullable PropertyValues pvs) {
 2         // Fall back to class name as cache key, for backwards compatibility with custom callers.
 3         String cacheKey = (StringUtils.hasLength(beanName) ? beanName : clazz.getName());
 4         // Quick check on the concurrent map first, with minimal locking.
 5         InjectionMetadata metadata = this.injectionMetadataCache.get(cacheKey);
 6         if (InjectionMetadata.needsRefresh(metadata, clazz)) {
 7             synchronized (this.injectionMetadataCache) {
 8                 metadata = this.injectionMetadataCache.get(cacheKey);
 9                 if (InjectionMetadata.needsRefresh(metadata, clazz)) {
10                     if (metadata != null) {
11                         metadata.clear(pvs);
12                     }
13                     metadata = buildAutowiringMetadata(clazz);
14                     this.injectionMetadataCache.put(cacheKey, metadata);
15                 }
16             }
17         }
18         return metadata;
19     }

 

 通过断点到这个方法中,发现此时injectionMetadataCache中已经有了myService对应的InjectionMetadata,此方法只是从map中取出返回。没办法了,还要继续追寻下去,AutowiredAnnotationBeanPostProcessor中的injectionMetadataCache属性是什么时候触发的初始化?

在当前类中查询injectionMetadataCache的put方法,发现只有这一个地方,所以继续在这里断点一下,看看什么时候触发的injectionMetadataCache.put。

 

 发现原来就是在doCreateBean的applyMergedBeanDefinitionPostProcessors方法中触发的put操作。

下面继续追寻inject方法中Spring如何完成的属性注入。

属性注入进入内部类 AutowiredFieldElement的方法inject中,方法注入进入的是AutowiredMethodElement中。在inject方法中可以看到我们的老朋友DefaultListableBeanFactory#resolveDependency方法,即通过这个方法获取到对应的bean对象,最后通过反射完成的赋值或方法调用。

这里我们第二次遇到DefaultListableBeanFactory#resolveDependency,发现它是@Autowired注解注入构造器参数、注入成员变量、注入方法参数必经的方法,所以必须继续搞明白它。

追踪resolveDependency方法,进入DefaultListableBeanFactory#resolveMultipleBeans方法,该方法属于@Autowired注解的核心方法,虽然很长,但需要贴出源代码:

 1 @Nullable
 2     private Object resolveMultipleBeans(DependencyDescriptor descriptor, @Nullable String beanName,
 3             @Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) {
 4 
 5         final Class<?> type = descriptor.getDependencyType();
 6                 // 0、暂时不清楚是做什么用的...
 7         if (descriptor instanceof StreamDependencyDescriptor) {
 8             Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);
 9             if (autowiredBeanNames != null) {
10                 autowiredBeanNames.addAll(matchingBeans.keySet());
11             }
12             Stream<Object> stream = matchingBeans.keySet().stream()
13                     .map(name -> descriptor.resolveCandidate(name, type, this))
14                     .filter(bean -> !(bean instanceof NullBean));
15             if (((StreamDependencyDescriptor) descriptor).isOrdered()) {
16                 stream = stream.sorted(adaptOrderComparator(matchingBeans));
17             }
18             return stream;
19         }
20         else if (type.isArray()) { // 1、判断要注入的是不是一个数组,可见除了集合注入外,也可以以数组的形式注入bean
21             Class<?> componentType = type.getComponentType();
22             ResolvableType resolvableType = descriptor.getResolvableType();
23             Class<?> resolvedArrayType = resolvableType.resolve(type);
24             if (resolvedArrayType != type) {
25                 componentType = resolvableType.getComponentType().resolve();
26             }
27             if (componentType == null) {
28                 return null;
29             }
30             Map<String, Object> matchingBeans = findAutowireCandidates(beanName, componentType,
31                     new MultiElementDescriptor(descriptor));
32             if (matchingBeans.isEmpty()) {
33                 return null;
34             }
35             if (autowiredBeanNames != null) {
36                 autowiredBeanNames.addAll(matchingBeans.keySet());
37             }
38             TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
39             Object result = converter.convertIfNecessary(matchingBeans.values(), resolvedArrayType);
40             if (result instanceof Object[]) {
41                 Comparator<Object> comparator = adaptDependencyComparator(matchingBeans);
42                 if (comparator != null) {
43                     Arrays.sort((Object[]) result, comparator);
44                 }
45             }
46             return result;
47         }
48         else if (Collection.class.isAssignableFrom(type) && type.isInterface()) { // 2、判断注入的是不是集合的接口类(List、Set等)
49             Class<?> elementType = descriptor.getResolvableType().asCollection().resolveGeneric();
50             if (elementType == null) {
51                 return null;
52             }
53             Map<String, Object> matchingBeans = findAutowireCandidates(beanName, elementType,
54                     new MultiElementDescriptor(descriptor));
55             if (matchingBeans.isEmpty()) {
56                 return null;
57             }
58             if (autowiredBeanNames != null) {
59                 autowiredBeanNames.addAll(matchingBeans.keySet());
60             }
61             TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
62             Object result = converter.convertIfNecessary(matchingBeans.values(), type);
63             if (result instanceof List) {
64                 Comparator<Object> comparator = adaptDependencyComparator(matchingBeans);
65                 if (comparator != null) {
66                     ((List<?>) result).sort(comparator);
67                 }
68             }
69             return result;
70         }
71         else if (Map.class == type) { ///3、判断要注入的是不是map类
72             ResolvableType mapType = descriptor.getResolvableType().asMap();
73             Class<?> keyType = mapType.resolveGeneric(0);
74             if (String.class != keyType) {
75                 return null;
76             }
77             Class<?> valueType = mapType.resolveGeneric(1);
78             if (valueType == null) {
79                 return null;
80             }
81             Map<String, Object> matchingBeans = findAutowireCandidates(beanName, valueType,
82                     new MultiElementDescriptor(descriptor));
83             if (matchingBeans.isEmpty()) {
84                 return null;
85             }
86             if (autowiredBeanNames != null) {
87                 autowiredBeanNames.addAll(matchingBeans.keySet());
88             }
89             return matchingBeans;
90         }
91         else { // 4、其他情况返回空,进入doResolveDependency方法做默认处理
92             return null;
93         }
94     }

主要看1/2/3的注释,可以知道Spring支持多种注入方式就是在这里实现的。我们能发现,在获取bean的时候都是调用了findAntowireCandidates方法,而且第4中默认的情况,在外部的doResolveDenpency方法中也调用了findAutowireCandidates方法。

至于findAutowireCandidates方法是如何完成的属性获取?是通过type还是name获取到的bean?我们下期继续!

 

 

posted on 2019-11-24 22:57  淡墨痕  阅读(22402)  评论(1编辑  收藏  举报