源码分析@Autowired和@Resource的区别
从源码角度剖析@Autowired和@Resource自动注入的实现，帮助理解其工作原理，正确区分二者区别，避免误用、错用。
零、前言
@Autowired和@Resource注解都可以在Spring应用中进行声明式的依赖注入。以前都是看的网上关于两者的区别，但是实际和网上说的有出入，故从源码角度进行分析、验证。
以下源码基于spring 5.3.20（通过springboot 2.7.0引入）
一、结论
1、@Autowired注解总结
- 可用于构造函数，成员变量以及set方法
- 从Spring 4.3开始，如果目标Bean只有一个构造函数，则在该构造函数上可以省略
@Autowired注解；如果目标Bean有多个构造函数则不可省略
@Autowired注入方式：
- 按照type查找bean，如果使用
@Qualifier注解声明了name，则从结果集中取出与该name相匹配的bean返回（此时可以视为通过name和type获取bean，但实质是先通过type获取所有bean，然后通过name筛选，详情见后文findAutowireCandidates()方法源码分析） - 如果没有使用
@Qualifier注解，且找到多个bean，则判断这些bean中是否有使用@Primary注解和@Priority注解，有就返回优先级最高的哪一个bean，没有就按照字段名称去匹配bean，匹配成功返回，不成功抛出异常。（详情见后文determineAutowireCandidate()方法源码解析）
整体注入流程如下所示：
2、@Resource注解总结
-
可用于成员变量以及set方法
-
若不指定name属性，则会把name属性值处理为字段名或set方法标识的字段名
-
若指定type属性，则type属性值必须与字段类型或set方法返回值类型为父子关系（type属性值可以是子类，也可以是超类），否则会抛出异常
-
@Resource先按照name属性值注入，若未找到，则按type属性值注入。即默认的name或指定的name找不到 bean ，就会按type注入
整体注入流程如下所示：
二、@Autowired注入过程源码分析
1、AutowiredAnnotationBeanPostProcessor#buildAutowiringMetadata()：切入点
首先定位到org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor#buildAutowiringMetadata()方法，代码如下。可以看到，如果是在属性上声明@Autowired，则构造AutowiredFieldElement对象，如果是在方法上声明@Autowired，则构造AutowiredFieldElement对象。
private InjectionMetadata buildAutowiringMetadata(Class<?> clazz) {
if (!AnnotationUtils.isCandidateClass(clazz, this.autowiredAnnotationTypes)) {
return InjectionMetadata.EMPTY;
}
List<InjectionMetadata.InjectedElement> elements = new ArrayList<>();
Class<?> targetClass = clazz;
do {
final List<InjectionMetadata.InjectedElement> currElements = new ArrayList<>();
// 字段调用
ReflectionUtils.doWithLocalFields(targetClass, field -> {
MergedAnnotation<?> ann = findAutowiredAnnotation(field);
if (ann != null) {
if (Modifier.isStatic(field.getModifiers())) {
if (logger.isInfoEnabled()) {
logger.info("Autowired annotation is not supported on static fields: " + field);
}
return;
}
boolean required = determineRequiredStatus(ann);
// 构造AutowiredFieldElement对象
currElements.add(new AutowiredFieldElement(field, required));
}
});
// 方法调用
ReflectionUtils.doWithLocalMethods(targetClass, method -> {
Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);
if (!BridgeMethodResolver.isVisibilityBridgeMethodPair(method, bridgedMethod)) {
return;
}
MergedAnnotation<?> ann = findAutowiredAnnotation(bridgedMethod);
if (ann != null && method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) {
if (Modifier.isStatic(method.getModifiers())) {
if (logger.isInfoEnabled()) {
logger.info("Autowired annotation is not supported on static methods: " + method);
}
return;
}
if (method.getParameterCount() == 0) {
if (logger.isInfoEnabled()) {
logger.info("Autowired annotation should only be used on methods with parameters: " +
method);
}
}
boolean required = determineRequiredStatus(ann);
PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
// 构造AutowiredMethodElement对象
currElements.add(new AutowiredMethodElement(method, required, pd));
}
});
elements.addAll(0, currElements);
targetClass = targetClass.getSuperclass();
}
while (targetClass != null && targetClass != Object.class);
return InjectionMetadata.forElements(elements, clazz);
}
AutowiredFieldElement和AutowiredFieldElement对象很类似，都是构造器初始化数据，inject()获取bean，现以AutowiredFieldElement为例进行说明。
2、AutowiredFieldElement对象
private class AutowiredFieldElement extends InjectionMetadata.InjectedElement {
private final boolean required;
private volatile boolean cached;
@Nullable
private volatile Object cachedFieldValue;
// 1、构造器初始化数据，由于@Autowired就一个required属性，故非常见到那
public AutowiredFieldElement(Field field, boolean required) {
super(field, null);
this.required = required;
}
// 2、inject()方法获取bean
@Override
protected void inject(Object bean, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
Field field = (Field) this.member;
Object value;
if (this.cached) {
try {
// 2.1 开启缓存，调用resolvedCachedArgument获取bean
value = resolvedCachedArgument(beanName, this.cachedFieldValue);
}
catch (NoSuchBeanDefinitionException ex) {
// Unexpected removal of target bean for cached argument -> re-resolve
// 调用resolvedCachedArgument获取bean，则调用resolveFieldValue获取bean
value = resolveFieldValue(field, bean, beanName);
}
}
else {
// 2.2 调用resolveFieldValue获取bean
value = resolveFieldValue(field, bean, beanName);
}
if (value != null) {
ReflectionUtils.makeAccessible(field);
field.set(bean, value);
}
}
// 3、调用resolveFieldValue()获取bean
@Nullable
private Object resolveFieldValue(Field field, Object bean, @Nullable String beanName) {
DependencyDescriptor desc = new DependencyDescriptor(field, this.required);
desc.setContainingClass(bean.getClass());
Set<String> autowiredBeanNames = new LinkedHashSet<>(1);
Assert.state(beanFactory != null, "No BeanFactory available");
TypeConverter typeConverter = beanFactory.getTypeConverter();
Object value;
try {
// 3.1 实际上就是调用beanFactory.resolveDependency方法
value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);
}
catch (BeansException ex) {
throw new UnsatisfiedDependencyException(null, beanName, new InjectionPoint(field), ex);
}
synchronized (this) {
if (!this.cached) {
Object cachedFieldValue = null;
if (value != null || this.required) {
cachedFieldValue = desc;
registerDependentBeans(beanName, autowiredBeanNames);
if (autowiredBeanNames.size() == 1) {
String autowiredBeanName = autowiredBeanNames.iterator().next();
if (beanFactory.containsBean(autowiredBeanName) &&
beanFactory.isTypeMatch(autowiredBeanName, field.getType())) {
cachedFieldValue = new ShortcutDependencyDescriptor(
desc, autowiredBeanName, field.getType());
}
}
}
this.cachedFieldValue = cachedFieldValue;
this.cached = true;
}
}
return value;
}
}
如果开启缓存，则inject()方法直接调用resolvedCachedArgument()方法获取bean，否则调用resolveFieldValue()方法，而resolveFieldValue()方法又会去调用beanFactory.resolveDependency()方法，即调用org.springframework.beans.factory.support.DefaultListableBeanFactory#resolveDependency()方法，进而调用doResolveDependency()方法
3、DefaultListableBeanFactory对象
3.1 resolveDependency()：@Lazy懒加载处理
总结：如果使用了@Lazy，则生成cglib代理对象返回；否则调用doResolveDependency()方法获取bean
@Override
@Nullable
public Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,
@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
descriptor.initParameterNameDiscovery(getParameterNameDiscoverer());
if (Optional.class == descriptor.getDependencyType()) {
return createOptionalDependency(descriptor, requestingBeanName);
}
else if (ObjectFactory.class == descriptor.getDependencyType() ||
ObjectProvider.class == descriptor.getDependencyType()) {
return new DependencyObjectProvider(descriptor, requestingBeanName);
}
else if (javaxInjectProviderClass == descriptor.getDependencyType()) {
return new Jsr330Factory().createDependencyProvider(descriptor, requestingBeanName);
}
// 上面是一些特殊逻辑处理，下面才是主流程
else {
// 如果使用@Autowired的同时使用了@Lazy，则这里返回一个cglib代理对象，否则返回null
Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(
descriptor, requestingBeanName);
if (result == null) {
// 也就是说只有单独使用@Autowired才会进这里
result = doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);
}
return result;
}
}
3.2 doResolveDependency()：获取bean的处理流程
// 注入依赖时未使用@Lazy注解，调用此方法
@Nullable
public Object doResolveDependency(DependencyDescriptor descriptor, @Nullable String beanName,
@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
......
// 1、按类型查找所有的bean，未通过@Qualifier指定name时，查到几个就是几个；
// 若通过@Qualifier指定name，则将查到的bean与name进行匹配，没有匹配的就返回空集合
// findAutowireCandidates()方法详解见下文
Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);
if (matchingBeans.isEmpty()) { // 没有找到
if (isRequired(descriptor)) { // required值为true，必须有值，抛出异常
raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
}
return null; //required值为false，返回null
}
String autowiredBeanName;
Object instanceCandidate;
// 2、按类型找到多个bean
if (matchingBeans.size() > 1) {
// 从多个bean中找到那唯一一个，没有找到返回null
// 寻找规则：@Primary > @Priority (若有多个，返回优先级最高的那个，值越小优先级越高) > 按照字段名匹配
// determineAutowireCandidate()方法详解见下文
autowiredBeanName = determineAutowireCandidate(matchingBeans, descriptor);
if (autowiredBeanName == null) {
// 没有从多个bean中选出唯一一个，而且还是必须的，则抛出异常
if (isRequired(descriptor) || !indicatesMultipleBeans(type)) {
return descriptor.resolveNotUnique(descriptor.getResolvableType(), matchingBeans);
}
else {
return null;
}
}
instanceCandidate = matchingBeans.get(autowiredBeanName);
}
else {
// We have exactly one match.
// 3、按类型找到一个bean，直接返回
Map.Entry<String, Object> entry = matchingBeans.entrySet().iterator().next();
autowiredBeanName = entry.getKey();
instanceCandidate = entry.getValue();
}
......
}
3.3 findAutowireCandidates()：通过类型查找bean的处理流程
方法路径：org.springframework.beans.factory.support.DefaultListableBeanFactory#findAutowireCandidates()
总结：
- 获取所有类型的bean
- 如果使用@Qualifier声明name，则将指定name的bean放入结果集中，若没有则返回空
- 如果未使用@Qualifier声明name，则将所有bean放入结果集中，返回
protected Map<String, Object> findAutowireCandidates(
@Nullable String beanName, Class<?> requiredType, DependencyDescriptor descriptor) {
// 1、获取该类型的所有bean
String[] candidateNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
this, requiredType, true, descriptor.isEager());
// 2、将resolvableDependencies集合中类型相同的bean放到result中
Map<String, Object> result = CollectionUtils.newLinkedHashMap(candidateNames.length);
for (Map.Entry<Class<?>, Object> classObjectEntry : this.resolvableDependencies.entrySet()) {
Class<?> autowiringType = classObjectEntry.getKey();
if (autowiringType.isAssignableFrom(requiredType)) {
Object autowiringValue = classObjectEntry.getValue();
autowiringValue = AutowireUtils.resolveAutowiringValue(autowiringValue, requiredType);
if (requiredType.isInstance(autowiringValue)) {
result.put(ObjectUtils.identityToString(autowiringValue), autowiringValue);
break;
}
}
}
// 3、循环所有bean数组，将满足条件的bean放入result中
for (String candidate : candidateNames) {
// isSelfReference：判断是否为自引用
// isAutowireCandidate：判断指定的 bean 是否有资格作为自动装配候选者。
// 如果没有使用@Qualifier声明name，则都有资格；若声明了name，则只有beanName等于name时才有资格
// 具体调用路径见后文
if (!isSelfReference(beanName, candidate) && isAutowireCandidate(candidate, descriptor)) {
addCandidateEntry(result, candidate, descriptor, requiredType);
}
}
// 后备匹配选项，暂时忽略
......
return result;
}
isAutowireCandidate()方法调用流程简单说明（通过debug可以快速走出来）
// 第一步：重载方法
@Override
public boolean isAutowireCandidate(String beanName, DependencyDescriptor descriptor)
throws NoSuchBeanDefinitionException {
return isAutowireCandidate(beanName, descriptor, getAutowireCandidateResolver());
}
// 第二步：重载方法
protected boolean isAutowireCandidate(
String beanName, DependencyDescriptor descriptor, AutowireCandidateResolver resolver)
throws NoSuchBeanDefinitionException {
String bdName = BeanFactoryUtils.transformedBeanName(beanName);
if (containsBeanDefinition(bdName)) {
// 2、走这里
return isAutowireCandidate(beanName, getMergedLocalBeanDefinition(bdName), descriptor, resolver);
}
else if (containsSingleton(beanName)) {
return isAutowireCandidate(beanName, new RootBeanDefinition(getType(beanName)), descriptor, resolver);
}
// 代码省略
......
}
// 第三步:
protected boolean isAutowireCandidate(String beanName, RootBeanDefinition mbd,
DependencyDescriptor descriptor, AutowireCandidateResolver resolver) {
// 代码省略
......
// 3、走这里
return resolver.isAutowireCandidate(holder, descriptor);
}
// 第四步：org.springframework.beans.factory.annotation.QualifierAnnotationAutowireCandidateResolver#isAutowireCandidate()
@Override
public boolean isAutowireCandidate(BeanDefinitionHolder bdHolder, DependencyDescriptor descriptor) {
boolean match = super.isAutowireCandidate(bdHolder, descriptor);
if (match) {
// 4、判断Qualifier注解声明的name是否与当前bean匹配
match = checkQualifiers(bdHolder, descriptor.getAnnotations());
if (match) {
MethodParameter methodParam = descriptor.getMethodParameter();
if (methodParam != null) {
Method method = methodParam.getMethod();
if (method == null || void.class == method.getReturnType()) {
match = checkQualifiers(bdHolder, methodParam.getMethodAnnotations());
}
}
}
}
return match;
}
// 第五步：将给定的限定符（即Qualifier声明的name）与候选 bean 的beanName匹配
protected boolean checkQualifiers(BeanDefinitionHolder bdHolder, Annotation[] annotationsToSearch) {
......
}
3.4 determineAutowireCandidate()：找到多个bean的处理流程
方法路径：org.springframework.beans.factory.support.DefaultListableBeanFactory#determineAutowireCandidate()
总结：
- 判断是否有使用@Primary注解的bean，有直接返回，没有返回null
- 判断是否有使用@Priority注解的bean，没有返回null；有一个直接返回；有多个，返回优先级最高的那个（@Priority值越小优先级越高）
- 既没有使用@Primary，也没有使用@Priority，用被@Autowired注解字段名称当做beanName去匹配，匹配成功直接返回，否则返回null
@Nullable
protected String determineAutowireCandidate(Map<String, Object> candidates, DependencyDescriptor descriptor) {
Class<?> requiredType = descriptor.getDependencyType();
// 1、判断是否有使用@Primary注解的bean，有直接返回，没有返回null
String primaryCandidate = determinePrimaryCandidate(candidates, requiredType);
if (primaryCandidate != null) {
return primaryCandidate;
}
// 2、判断是否有使用@Priority注解的bean，没有返回null；有一个直接返回；有多个，返回优先级最高的那个（@Priority值越小优先级越高）
String priorityCandidate = determineHighestPriorityCandidate(candidates, requiredType);
if (priorityCandidate != null) {
return priorityCandidate;
}
// Fallback
// 3、既没有使用@Primary，也没有使用@Priority，用被@Autowired注解字段名称当做beanName去匹配，匹配成功直接返回，否则返回null
for (Map.Entry<String, Object> entry : candidates.entrySet()) {
String candidateName = entry.getKey();
Object beanInstance = entry.getValue();
// matchesBeanName()：判断候选bean集合中是否存在与字段名称相同的bean
if ((beanInstance != null && this.resolvableDependencies.containsValue(beanInstance)) ||
matchesBeanName(candidateName, descriptor.getDependencyName())) {
return candidateName;
}
}
return null;
}
三、@Resource注入过程源码分析
1、CommonAnnotationBeanPostProcessor#buildResourceMetadata()：切入点
首先定位到org.springframework.context.annotation.CommonAnnotationBeanPostProcessor#buildResourceMetadata()方法，里面有这么一段代码：判断字段是否使用@Resource注解：先判断是否为静态字段，然后判断字段类型是否为忽略的类型，若不是则构建一个ResourceElement对象。
......
else if (field.isAnnotationPresent(Resource.class)) {
// 判断是否为静态字段
if (Modifier.isStatic(field.getModifiers())) {
throw new IllegalStateException("@Resource annotation is not supported on static fields");
}
// 判断字段类型是否为忽略的类型，若不是则构建一个ResourceElement对象
if (!this.ignoredResourceTypes.contains(field.getType().getName())) {
currElements.add(new ResourceElement(field, field, null));
}
}
......
2、ResourceElement对象
对象路径：org.springframework.context.annotation.CommonAnnotationBeanPostProcessor.ResourceElement()
ResourceElement类包含2个方法：一个构造器，一个getResourceToInject()方法。构造器只要功能就是初始化数据，代码如下：
public ResourceElement(Member member, AnnotatedElement ae, @Nullable PropertyDescriptor pd) {
super(member, pd);
Resource resource = ae.getAnnotation(Resource.class);
// 1、获取注解的name属性值
String resourceName = resource.name();
// 2、获取注解的type属性值
Class<?> resourceType = resource.type();
// 3、判断name属性值是否为默认值""
this.isDefaultName = !StringUtils.hasLength(resourceName);
if (this.isDefaultName) {
// 3.1 获取被注解原始的名称：用在字段上，则拿到的就是字段名称，否则是set方法
resourceName = this.member.getName();
// 3.2 如果是方法，则截取set后的元素，并将首字母改为小写
if (this.member instanceof Method && resourceName.startsWith("set") && resourceName.length() > 3) {
resourceName = Introspector.decapitalize(resourceName.substring(3));
}
}
else if (embeddedValueResolver != null) {
// 4、指定了name属性，则进行解析（占位符的处理等）
resourceName = embeddedValueResolver.resolveStringValue(resourceName);
}
// 5、若显示指定了type属性值，则判断指定的值与字段的类型或set方法返回值类型是否为父子关系，若不是则抛出异常
if (Object.class != resourceType) {
checkResourceType(resourceType);
}
else {
// 未指定type属性值，使用默认值Object.class，则获取字段类型或set方法的返回值类型
resourceType = getResourceType();
}
// 6、将name属性值和type属性值赋值给成员变量
this.name = (resourceName != null ? resourceName : "");
this.lookupType = resourceType;
String lookupValue = resource.lookup();
this.mappedName = (StringUtils.hasLength(lookupValue) ? lookupValue : resource.mappedName());
// 7、@Lazy懒加载处理
Lazy lazy = ae.getAnnotation(Lazy.class);
this.lazyLookup = (lazy != null && lazy.value());
}
@Override
protected Object getResourceToInject(Object target, @Nullable String requestingBeanName) {
// this.lazyLookup = true，表示使用了@Lazy注解，此时调用buildLazyResourceProxy返回cglib代理对象，否则调用getResource方法
return (this.lazyLookup ? buildLazyResourceProxy(this, requestingBeanName) :
getResource(this, requestingBeanName));
}
总结：
- 从这里可以看出，只要你不指定name属性，则都会把name属性值处理未字段名或set方法声明的字段名称
- 除非你指定的type属性值与字段类型或set方法返回值类型为父子关系（指定值可以是子类，也可以是超类），否则都会抛出异常
- @Resource 在不指定 name 的情况下，默认的name是字段名或set方法标识的字段名称；如果默认的name 或指定的name找不到 bean ，就会按 type 注入。
3、autowireResource()：获取bean流程
调用链：getResourceToInject() -> getResource() -> autowireResource
方法路径：org.springframework.context.annotation.CommonAnnotationBeanPostProcessor.autowireResource()
protected Object autowireResource(BeanFactory factory, LookupElement element, @Nullable String requestingBeanName)
throws NoSuchBeanDefinitionException {
Object resource;
Set<String> autowiredBeanNames;
String name = element.name;
// 1、判断beanFactory类型
if (factory instanceof AutowireCapableBeanFactory) {
AutowireCapableBeanFactory beanFactory = (AutowireCapableBeanFactory) factory;
DependencyDescriptor descriptor = element.getDependencyDescriptor();
// 1.1 根据 name 属性值获取不到bean
if (this.fallbackToDefaultTypeMatch && element.isDefaultName && !factory.containsBean(name)) {
autowiredBeanNames = new LinkedHashSet<>();
// 1.1.1 根据 type 类型获取bean
resource = beanFactory.resolveDependency(descriptor, requestingBeanName, autowiredBeanNames, null);
// 1.1.2 获取不到抛出异常
if (resource == null) {
throw new NoSuchBeanDefinitionException(element.getLookupType(), "No resolvable resource object");
}
}
// 1.2 根据name属性获取到bean，判断类型是否相同，不同抛出异常
else {
resource = beanFactory.resolveBeanByName(name, descriptor);
autowiredBeanNames = Collections.singleton(name);
}
}
else { // 2、根据name属性获取到bean，判断类型是否相同，不同抛出异常
resource = factory.getBean(name, element.lookupType);
autowiredBeanNames = Collections.singleton(name);
}
if (factory instanceof ConfigurableBeanFactory) {
ConfigurableBeanFactory beanFactory = (ConfigurableBeanFactory) factory;
for (String autowiredBeanName : autowiredBeanNames) {
if (requestingBeanName != null && beanFactory.containsBean(autowiredBeanName)) {
beanFactory.registerDependentBean(autowiredBeanName, requestingBeanName);
}
}
}
return resource;
}
只有经历过，才会懂得了！
