Spring的@Resource原理

说到Spring，没有人不知道IOC与DI，自动注入最常见的注解就是@Autowired和@Resource，因此有一道经典的面试题：@Autowired和@Resource的区别，绝大多数人的答案就是byType和byName。真的这么简单吗？本人先不回答这个问题，而是从零开始探讨@Resource的原理。
首先看一下这个注解的定义：

@Target({TYPE, FIELD, METHOD})
@Retention(RUNTIME)
public @interface Resource {
    /**
     * The JNDI name of the resource.  For field annotations,
     * the default is the field name.  For method annotations,
     * the default is the JavaBeans property name corresponding
     * to the method.  For class annotations, there is no default
     * and this must be specified.
     */
    String name() default "";

    /**
     * The name of the resource that the reference points to. It can
     * link to any compatible resource using the global JNDI names.
     *
     * @since Common Annotations 1.1
     */

    String lookup() default "";

    /**
     * The Java type of the resource.  For field annotations,
     * the default is the type of the field.  For method annotations,
     * the default is the type of the JavaBeans property.
     * For class annotations, there is no default and this must be
     * specified.
     */
    Class<?> type() default java.lang.Object.class;
}

首先这个注解可以使用在一个类、方法或属性上面，通常我们都只注入属性。注意，没有@Target里面没有CONSTRUCTOR，也就是说这个注解不能使用在构造方法上。也就是不支持构造注入。
另外这个类的报名也不是以org.springframework开头的，而是属于一个标准（JSR-250），属于这个标准的注解还有@PostConstruct和@PreDestroy。
如果这个注解是使用在属性和方法上，那么在对应Bean实例化的时候容器会注入一个请求资源的对象，如果这个注解是使用在类上面的话，程序在运行时才会查找。
虽然这个注解没有标识是继承性的，但是在父类的属性和方法中使用这个注解，子类是可以获益的。

package com.example.managingtransactions;

import javax.annotation.Resource;

public class SimpleMovieLister {

    private MovieFinder movieFinder;

    @Resource(name = "myMovieFinder")
    public void setMovieFinder(MovieFinder movieFinder) {
        this.movieFinder = movieFinder;
    }
}

以上就是一个@Resource注解使用在方法上的一个例子，当SimpleMovieLister类型的Bean在实例化的时候，因为 @Resource注解的存在，首先会查找这个注解的各种信息，然后注入beanName为myMovieFinder的那个Bean作为属性值。
如果注解中不明确指定name属性，那么默认的值会根据属性名称或setter方法的名称来推断。比如说在属性上，就会直接使用这个属性名称（field name），如果是setter方法上，则是property name，一般情况下，都是一样的。比如以下在setterMethod上使用，那么默认查找的beanName就是movieFinder.

public class SimpleMovieLister {

    private MovieFinder movieFinder;

    @Resource
    public void setMovieFinder(MovieFinder movieFinder) {
        this.movieFinder = movieFinder;
    }
}

但是如果在Spring容器中不存在对应名称的Bean，是不是就没法注入的呢？当然不是，@Resource获取容器根据类型进行匹配。因此在以下的案例中，如果Spring容器中不存在一个名称为customerPreferenceDao的bean的话，那么就会按照类型CustomerPreferenceDao进行匹配了。对于一些容器中已知常见的类型的话，则不会如此复杂。比如BeanFactory, ApplicationContext, ResourceLoader就不需要按照对应类型去查找了。

public class MovieRecommender {

    @Resource
    private CustomerPreferenceDao customerPreferenceDao;

    @Resource
    private ApplicationContext context;

    public MovieRecommender() {
    }

    // ...
}

也就是说，@Resource其实既是byName也是byType的。

那么这个属性是如何起作用的呢？下面就依照源码来进行说明。同时从源码来验证以上的观点。
在idea里面搜索一下这个注解，如下图所示

绝大多数的结果指向类CommonAnnotationBeanPostProcessor.
当然在Spring的官方文档中也有相关的说明，感兴趣的话可以自己去阅读一下。https://docs.spring.io/spring/docs/5.0.17.RELEASE/spring-framework-reference/core.html#beans-resource-annotation
查看这个类的继承结构

它实现了多个接口，其中与@Resource最相关的就是InstantiationAwareBeanPostProcessor和MergedBeanDefinitionPostProcessor，BeanFactoryAware也有一些关系，因为要注入的对象是通过这个接口引入的beanFactory进行查找的。
至于前两个接口，可以查看本人的博客：
https://blog.csdn.net/m0_37607945/article/details/107404447
和
https://blog.csdn.net/m0_37607945/article/details/107411096
通过实现InstantiationAwareBeanPostProcessor接口，可以在一个bean实例化的前后对bean进行处理，在CommonAnnotationBeanPostProcessor中就是在bean实例化之后进行属性填充的，也就是注入资源到标有@Resource的类属性或类方法对应的属性上。而MergedBeanDefinitionPostProcessor是在bean实例化之后与属性填充值前进行@Resource注解元数据的解析操作的。
大致流程如下：
bean实例化->@Resource元数据解析->@Resource资源注入。

在CommonAnnotationBeanPostProcessor类中对应的方法为：
postProcessMergedBeanDefinition元数据解析和postProcessProperties资源注入，分别属于MergedBeanDefinitionPostProcessor和InstantiationAwareBeanPostProcessor定义的方法。

在类中打上断点如下所示：

debug运行程序，查看调用栈信息

bean的实例化

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
		throws BeanCreationException {

	// Instantiate the bean.
	BeanWrapper instanceWrapper = null;
	if (mbd.isSingleton()) {
		instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
	}
	if (instanceWrapper == null) {
	    // 此处会创建bean实例
		instanceWrapper = createBeanInstance(beanName, mbd, args);
	}
	final Object bean = instanceWrapper.getWrappedInstance();
	Class<?> beanType = instanceWrapper.getWrappedClass();
	if (beanType != NullBean.class) {
		mbd.resolvedTargetType = beanType;
	}

	// Allow post-processors to modify the merged bean definition.
	synchronized (mbd.postProcessingLock) {
		if (!mbd.postProcessed) {
			try {
			    // 此处进行注解元数据解析
				applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
			}
			catch (Throwable ex) {
				throw new BeanCreationException(mbd.getResourceDescription(), beanName,
						"Post-processing of merged bean definition failed", ex);
			}
			mbd.postProcessed = true;
		}
	}
   
    .. Bean的初始化过程忽略
}

注解元数据解析

遍历容器中的所有MergedBeanDefinitionPostProcessor进行后置处理

/**
 * Apply MergedBeanDefinitionPostProcessors to the specified bean definition,
 * invoking their {@code postProcessMergedBeanDefinition} methods.
 * @param mbd the merged bean definition for the bean
 * @param beanType the actual type of the managed bean instance
 * @param beanName the name of the bean
 * @see MergedBeanDefinitionPostProcessor#postProcessMergedBeanDefinition
 */
protected void applyMergedBeanDefinitionPostProcessors(RootBeanDefinition mbd, Class<?> beanType, String beanName) {
	for (BeanPostProcessor bp : getBeanPostProcessors()) {
		if (bp instanceof MergedBeanDefinitionPostProcessor) {
			MergedBeanDefinitionPostProcessor bdp = (MergedBeanDefinitionPostProcessor) bp;
			bdp.postProcessMergedBeanDefinition(mbd, beanType, beanName);
		}
	}
}

然后就会进入到类CommonAnnotationBeanPostProcessor中

@Override
public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
	super.postProcessMergedBeanDefinition(beanDefinition, beanType, beanName);
	InjectionMetadata metadata = findResourceMetadata(beanName, beanType, null);
	metadata.checkConfigMembers(beanDefinition);
}

首先会调用父类的方法，父类会针对bean生命周期相关注解元数据的解析，在当前类中会设置bean生命周期所使用的注解类型

/**
 * Create a new CommonAnnotationBeanPostProcessor,
 * with the init and destroy annotation types set to
 * {@link javax.annotation.PostConstruct} and {@link javax.annotation.PreDestroy},
 * respectively.
 */
public CommonAnnotationBeanPostProcessor() {
	setOrder(Ordered.LOWEST_PRECEDENCE - 3);
	setInitAnnotationType(PostConstruct.class);
	setDestroyAnnotationType(PreDestroy.class);
	ignoreResourceType("javax.xml.ws.WebServiceContext");
}

分别是PostConstruct和PreDestroy，这里不详细谈论了。
调用完父类的方法后，就会执行查找@Resource的逻辑了、

private InjectionMetadata findResourceMetadata(String beanName, final Class<?> clazz, @Nullable PropertyValues pvs) {
	// Fall back to class name as cache key, for backwards compatibility with custom callers.
	String cacheKey = (StringUtils.hasLength(beanName) ? beanName : clazz.getName());
	// Quick check on the concurrent map first, with minimal locking.
	InjectionMetadata metadata = this.injectionMetadataCache.get(cacheKey);
	if (InjectionMetadata.needsRefresh(metadata, clazz)) {
		synchronized (this.injectionMetadataCache) {
			metadata = this.injectionMetadataCache.get(cacheKey);
			if (InjectionMetadata.needsRefresh(metadata, clazz)) {
				if (metadata != null) {
					metadata.clear(pvs);
				}
				metadata = buildResourceMetadata(clazz);
				this.injectionMetadataCache.put(cacheKey, metadata);
			}
		}
	}
	return metadata;
}

这里只是涉及到一些缓存优化的逻辑，首先从缓存中获取相关元数据信息，如果获取不到则会调用buildResourceMetadata进行创建，创建完成后，再放到缓存当中。
缓存定义如下

private final transient Map<String, InjectionMetadata> injectionMetadataCache = new ConcurrentHashMap<>(256);

第一次肯定缓存肯定是没有值的，会进入到buildResourceMetadata当中

private InjectionMetadata buildResourceMetadata(final Class<?> clazz) {
	List<InjectionMetadata.InjectedElement> elements = new ArrayList<>();
	Class<?> targetClass = clazz;

	do {
		final List<InjectionMetadata.InjectedElement> currElements = new ArrayList<>();

		ReflectionUtils.doWithLocalFields(targetClass, field -> {
			if (webServiceRefClass != null && field.isAnnotationPresent(webServiceRefClass)) {
				if (Modifier.isStatic(field.getModifiers())) {
					throw new IllegalStateException("@WebServiceRef annotation is not supported on static fields");
				}
				currElements.add(new WebServiceRefElement(field, field, null));
			}
			else if (ejbRefClass != null && field.isAnnotationPresent(ejbRefClass)) {
				if (Modifier.isStatic(field.getModifiers())) {
					throw new IllegalStateException("@EJB annotation is not supported on static fields");
				}
				currElements.add(new EjbRefElement(field, field, null));
			}
			else if (field.isAnnotationPresent(Resource.class)) {
				if (Modifier.isStatic(field.getModifiers())) {
					throw new IllegalStateException("@Resource annotation is not supported on static fields");
				}
				if (!this.ignoredResourceTypes.contains(field.getType().getName())) {
					currElements.add(new ResourceElement(field, field, null));
				}
			}
		});

		ReflectionUtils.doWithLocalMethods(targetClass, method -> {
			Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);
			if (!BridgeMethodResolver.isVisibilityBridgeMethodPair(method, bridgedMethod)) {
				return;
			}
			if (method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) {
				if (webServiceRefClass != null && bridgedMethod.isAnnotationPresent(webServiceRefClass)) {
					if (Modifier.isStatic(method.getModifiers())) {
						throw new IllegalStateException("@WebServiceRef annotation is not supported on static methods");
					}
					if (method.getParameterCount() != 1) {
						throw new IllegalStateException("@WebServiceRef annotation requires a single-arg method: " + method);
					}
					PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
					currElements.add(new WebServiceRefElement(method, bridgedMethod, pd));
				}
				else if (ejbRefClass != null && bridgedMethod.isAnnotationPresent(ejbRefClass)) {
					if (Modifier.isStatic(method.getModifiers())) {
						throw new IllegalStateException("@EJB annotation is not supported on static methods");
					}
					if (method.getParameterCount() != 1) {
						throw new IllegalStateException("@EJB annotation requires a single-arg method: " + method);
					}
					PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
					currElements.add(new EjbRefElement(method, bridgedMethod, pd));
				}
				else if (bridgedMethod.isAnnotationPresent(Resource.class)) {
					if (Modifier.isStatic(method.getModifiers())) {
						throw new IllegalStateException("@Resource annotation is not supported on static methods");
					}
					Class<?>[] paramTypes = method.getParameterTypes();
					if (paramTypes.length != 1) {
						throw new IllegalStateException("@Resource annotation requires a single-arg method: " + method);
					}
					if (!this.ignoredResourceTypes.contains(paramTypes[0].getName())) {
						PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
						currElements.add(new ResourceElement(method, bridgedMethod, pd));
					}
				}
			}
		});

		elements.addAll(0, currElements);
		targetClass = targetClass.getSuperclass();
	}
	while (targetClass != null && targetClass != Object.class);

	return new InjectionMetadata(clazz, elements);
}

不难看出这个方法相当的长，但是逻辑还是简单的，大体上，就是遍历一个类的所有属性和所有方法查找元数据信息，而且遍历所有父类，查找到元数据后构造一个InjectionMetadata类型对象返回。

// 遍历所有属性
ReflectionUtils.doWithLocalFields(targetClass, field -> {...}
// 遍历所有方法
ReflectionUtils.doWithLocalMethods(targetClass, method -> {...}
// 遍历所有父类
while (targetClass != null && targetClass != Object.class);

在针对每个属性和方法进行查找的时候，同时会考虑支持@WebServiceRef和@EJB，这个也不是我们讨论的范畴，而且一般使用较少，忽略相关代码，那么简化如下：
在属性中查找@Resource注解元数据

// 当前是否是否包含@Resource注解
else if (field.isAnnotationPresent(Resource.class)) {
    // 不支持静态属性
	if (Modifier.isStatic(field.getModifiers())) {
		throw new IllegalStateException("@Resource annotation is not supported on static fields");
	}
	// 在ignoredResourceTypes集合中不包含这个类
	if (!this.ignoredResourceTypes.contains(field.getType().getName())) {
		currElements.add(new ResourceElement(field, field, null));
	}
}

首先如果一个属性中包含@Resource注解，但是不能是静态属性，而且属性类型不能是在ignoredResourceTypes这个集合中的，可以通过在这个集合中添加那些你不想通过@Resource来注入的类，比如在CommonAnnotationBeanPostProcessor构造器中就添加了javax.xml.ws.WebServiceContext这个类被忽略了。如果不违背上面两个条件的话，就会构造一个ResourceElement类型的对象并添加到currElements 列表中。

在方法中查找@Resource注解元数据

else if (bridgedMethod.isAnnotationPresent(Resource.class)) {
	if (Modifier.isStatic(method.getModifiers())) {
		throw new IllegalStateException("@Resource annotation is not supported on static methods");
	}
	Class<?>[] paramTypes = method.getParameterTypes();
	if (paramTypes.length != 1) {
		throw new IllegalStateException("@Resource annotation requires a single-arg method: " + method);
	}
	if (!this.ignoredResourceTypes.contains(paramTypes[0].getName())) {
		PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
		currElements.add(new ResourceElement(method, bridgedMethod, pd));
	}
}

在方法上包含@Resource注解也不一定就可以，首先不能是静态方法，其实对应方法的参数个数必须是一个，最后注解类型不能在ignoredResourceTypes，除了方法参数个数的限制外，其他与上面属性的相同。如果满足条件的话最后也会构造一个ResourceElement并添加到currElements 列表中。

最后将遍历属性和方法收集到元数据信息也就是currElements 列表以及类类型构造一个InjectionMetadata对象返回了。

这里涉及到两个类InjectionMetadata和ResourceElement，可以简单的理解为存储@Resource元数据的信息的容器，比如说要注入的resourceName实例名称、resourceType实例类型、（isField）属性注入还是方法注入、（Member）对应的属性或者方法对象、

public ResourceElement(Member member, AnnotatedElement ae, @Nullable PropertyDescriptor pd) {
	// 记录对应属性或方法的信息
	super(member, pd);
	// 获取对应注解
	Resource resource = ae.getAnnotation(Resource.class);
	// 注入名称
	String resourceName = resource.name();
	// 注入类型
	Class<?> resourceType = resource.type();
	// 如果没有设置注入的名称 此时会默认
	this.isDefaultName = !StringUtils.hasLength(resourceName);
	if (this.isDefaultName) {
	    // 对应方法或者属性的名称 
		resourceName = this.member.getName();
		if (this.member instanceof Method && resourceName.startsWith("set") && resourceName.length() > 3) {
			// 如果是方法就会截取掉set并将第一个字母小写
			resourceName = Introspector.decapitalize(resourceName.substring(3));
		}
	}
	else if (embeddedValueResolver != null) {
	    //  支持占位符
		resourceName = embeddedValueResolver.resolveStringValue(resourceName);
	}
	if (Object.class != resourceType) {
		checkResourceType(resourceType);
	}
	else {
		// No resource type specified... check field/method.
		resourceType = getResourceType();
	}
	this.name = (resourceName != null ? resourceName : "");
	this.lookupType = resourceType;
	String lookupValue = resource.lookup();
	this.mappedName = (StringUtils.hasLength(lookupValue) ? lookupValue : resource.mappedName());
	Lazy lazy = ae.getAnnotation(Lazy.class);
	this.lazyLookup = (lazy != null && lazy.value());
}

从以上这段代码不难看出，如果传递了对应注解的name属性，则使用定义的，如果没有，则系统默认为对应的属性名称或者setter方法中除掉set三个前缀并将首字符小写的字符串（按照JavaBean原则其实就是属性名称）。另外如果embeddedValueResolver不为空的话，还支持注入名称使用占位符或者SPEL语法模式。在目前Spring容器中应该来说都是存在的。因为CommonAnnotationBeanPostProcessor实现了BeanFactoryAware接口，在CommonAnnotationBeanPostProcessor实例化的时候就会调用如下的方法设置embeddedValueResolver属性值：

@Override
public void setBeanFactory(BeanFactory beanFactory) {
	Assert.notNull(beanFactory, "BeanFactory must not be null");
	this.beanFactory = beanFactory;
	if (this.resourceFactory == null) {
		this.resourceFactory = beanFactory;
	}
	if (beanFactory instanceof ConfigurableBeanFactory) {
		this.embeddedValueResolver = new EmbeddedValueResolver((ConfigurableBeanFactory) beanFactory);
	}
}

其中这个EmbeddedValueResolver就可以用解析占位符和SPEL语法了。
最后还会解析注解中的lookup属性和mappedName，前者优先，作为mappedName.
InjectionMetadata对象更简单，就是简单的存储一下被注入的类和InjectedElement信息列表。

public InjectionMetadata(Class<?> targetClass, Collection<InjectedElement> elements) {
	this.targetClass = targetClass;
	this.injectedElements = elements;
}

收集完以上信息之后，会进行checkConfigMembers操作，其实也就是将对应的注解信息添加到beanDefinition中.

public void checkConfigMembers(RootBeanDefinition beanDefinition) {
	Set<InjectedElement> checkedElements = new LinkedHashSet<>(this.injectedElements.size());
	for (InjectedElement element : this.injectedElements) {
		Member member = element.getMember();
		if (!beanDefinition.isExternallyManagedConfigMember(member)) {
			beanDefinition.registerExternallyManagedConfigMember(member);
			checkedElements.add(element);
			if (logger.isTraceEnabled()) {
				logger.trace("Registered injected element on class [" + this.targetClass.getName() + "]: " + element);
			}
		}
	}
	this.checkedElements = checkedElements;
}

// RootBeanDefinition#registerExternallyManagedConfigMember

@Nullable
private Set<Member> externallyManagedConfigMembers;

public void registerExternallyManagedConfigMember(Member configMember) {
	synchronized (this.postProcessingLock) {
		if (this.externallyManagedConfigMembers == null) {
			this.externallyManagedConfigMembers = new HashSet<>(1);
		}
		this.externallyManagedConfigMembers.add(configMember);
	}
}

资源注入

这个步骤是在bean实例化完成后、经过实例化后置处理器的后置处理之后进行的，如下图所示：详细可参考源码org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#populateBean

@Override
public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
	InjectionMetadata metadata = findResourceMetadata(beanName, bean.getClass(), pvs);
	try {
		metadata.inject(bean, beanName, pvs);
	}
	catch (Throwable ex) {
		throw new BeanCreationException(beanName, "Injection of resource dependencies failed", ex);
	}
	return pvs;
}

与解析元数据信息相同的是，首先也会调用findResourceMetadata方法，但是此时缓存中存在相关信息，直接从缓存中就会获取到元数据信息了。


执行InjectionMetadata的inject方法，从前面的分析可以知道，在InjectionMetadata对象当中存在ResourceElement信息，而ResourceElement对象存储了需要被注入的各种信息，因此inject方法无非就是遍历这个信息进行注入操作了。

public void inject(Object target, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
	Collection<InjectedElement> checkedElements = this.checkedElements;
	Collection<InjectedElement> elementsToIterate =
			(checkedElements != null ? checkedElements : this.injectedElements);
	if (!elementsToIterate.isEmpty()) {
		for (InjectedElement element : elementsToIterate) {
			if (logger.isTraceEnabled()) {
				logger.trace("Processing injected element of bean '" + beanName + "': " + element);
			}
			element.inject(target, beanName, pvs);
		}
	}
}

进行InjectedElement（ResourceElement的父类）对象的注入操作。

/**
 * Either this or {@link #getResourceToInject} needs to be overridden.
 */
protected void inject(Object target, @Nullable String requestingBeanName, @Nullable PropertyValues pvs)
		throws Throwable {

	if (this.isField) {
		Field field = (Field) this.member;
		ReflectionUtils.makeAccessible(field);
		// 获取Resource资源并进行设置 
		field.set(target, getResourceToInject(target, requestingBeanName));
	}
	else {
		if (checkPropertySkipping(pvs)) {
			return;
		}
		try {
			Method method = (Method) this.member;
			ReflectionUtils.makeAccessible(method);
			method.invoke(target, getResourceToInject(target, requestingBeanName));
		}
		catch (InvocationTargetException ex) {
			throw ex.getTargetException();
		}
	}
}

以上的操作无非就是先查找到对应的Resource资源然后再进行对应属性或者方法的反射操作设置属性了。重点还是在getResourceToInject方法中。

@Override
protected Object getResourceToInject(Object target, @Nullable String requestingBeanName) {
	return (this.lazyLookup ? buildLazyResourceProxy(this, requestingBeanName) :
			getResource(this, requestingBeanName));
}

首先判断是否懒查找模式（包含@Resource注解的同时包含@Lazy注解），如果是懒查找的模式，则是构建一个代理，如果不是则是获取资源对象。此处先看getResource方法。
获取资源

/**
 * Obtain the resource object for the given name and type.
 * @param element the descriptor for the annotated field/method
 * @param requestingBeanName the name of the requesting bean
 * @return the resource object (never {@code null})
 * @throws NoSuchBeanDefinitionException if no corresponding target resource found
 */
protected Object getResource(LookupElement element, @Nullable String requestingBeanName)
		throws NoSuchBeanDefinitionException {

	if (StringUtils.hasLength(element.mappedName)) {
		return this.jndiFactory.getBean(element.mappedName, element.lookupType);
	}
	if (this.alwaysUseJndiLookup) {
		return this.jndiFactory.getBean(element.name, element.lookupType);
	}
	if (this.resourceFactory == null) {
		throw new NoSuchBeanDefinitionException(element.lookupType,
				"No resource factory configured - specify the 'resourceFactory' property");
	}
	return autowireResource(this.resourceFactory, element, requestingBeanName);
}

前两个if主要是JNDI，不是我们通常使用Spring的姿势，因此还是要看autowireResource方法

/**
 * Obtain a resource object for the given name and type through autowiring
 * based on the given factory.
 * @param factory the factory to autowire against
 * @param element the descriptor for the annotated field/method
 * @param requestingBeanName the name of the requesting bean
 * @return the resource object (never {@code null})
 * @throws NoSuchBeanDefinitionException if no corresponding target resource found
 */
protected Object autowireResource(BeanFactory factory, LookupElement element, @Nullable String requestingBeanName)
		throws NoSuchBeanDefinitionException {

	Object resource;
	Set<String> autowiredBeanNames;
	String name = element.name;

	if (factory instanceof AutowireCapableBeanFactory) {
		AutowireCapableBeanFactory beanFactory = (AutowireCapableBeanFactory) factory;
		DependencyDescriptor descriptor = element.getDependencyDescriptor();
		// 如果容器中不包含对应名称的bean但是fallbackToDefaultTypeMatch设置为true,就会按照类型进行查找了
		if (this.fallbackToDefaultTypeMatch && element.isDefaultName && !factory.containsBean(name)) {
			autowiredBeanNames = new LinkedHashSet<>();
			resource = beanFactory.resolveDependency(descriptor, requestingBeanName, autowiredBeanNames, null);
			if (resource == null) {
				throw new NoSuchBeanDefinitionException(element.getLookupType(), "No resolvable resource object");
			}
		}
		else {
			resource = beanFactory.resolveBeanByName(name, descriptor);
			autowiredBeanNames = Collections.singleton(name);
		}
	}
	else {
	    // 直接按照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;
}

从上面不难看出，首先如果容器中不包含对应名称的bean的时候，而且fallbackToDefaultTypeMatch设置为true，才会按照类型去查找，只不过这个属性默认为true.可以通过setter方法进行设置

public void setFallbackToDefaultTypeMatch(boolean fallbackToDefaultTypeMatch) {
	this.fallbackToDefaultTypeMatch = fallbackToDefaultTypeMatch;
}

这里查找的name也是在之前构ResourceElement设置的，首先是取注解中的name属性，没有的话，则默认为类属性名称。

@Autowired applies to fields, constructors, and multi-argument methods, allowing for narrowing through qualifier annotations at the parameter level. In contrast, @Resource is supported only for fields and bean property setter methods with a single argument. As a consequence, you should stick with qualifiers if your injection target is a constructor or a multi-argument method