前言
最近在刷到很多文章讲解Spring IOC依赖注入时@Autowire和@Resource注解的区别，不同的文章总结出来的点有异同，所以还是看源码自己总结一下其两者的区别，及其用法。
大家有没有想过两者的功能差不多，那为啥Spring还提供两种依赖注入方式呢？
我们知道@Autowire注解是Spring框架提供的，所以在使用该注解时依赖于该框架，而@Resource注解是JDK自带的，不需要依赖第三方。大多数IOC框架对@Resource都做了支持，而@Autowire只能使用Spring，所以当我们使用@Resource注解后，切换了其它框架，就可能不需要去修改该注解了，也能支持其注入功能。
正文
@Autowire注入过程
public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
// 1、该方法会尝试从缓存中取当前Bean字段中使用了@Autowire的字段信息或方法信息。
InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);
try {
// 进行属性注入
metadata.inject(bean, beanName, pvs);
}
catch (BeanCreationException ex) {
throw ex;
}
catch (Throwable ex) {
throw new BeanCreationException(beanName, "Injection of autowired dependencies failed", ex);
}
return pvs;
}1、步骤1从缓存中取不到值时，会通过反射的方式遍历当前bean的所有字段信息和方法信息，并判断其是否使用了@Autowire注解，并封装到对应的处理器中，后面注入步骤会进行遍历进行查询处理及注入。@Autowire可以注解在方法、字段、构造器上，构造器注入在创建bean的时候进行的。
2、步骤2会根据步骤1中查询出来的信息遍历，由于字段和方法会分别封装成InjectedElement类型的不同子类实现，所以不同的类型会调用不同的子类实现方法进行处理。
doResolveDependency
@Nullable
public Object doResolveDependency(DependencyDescriptor descriptor, @Nullable String beanName,
@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
//..................
//此处省略了部分代码
//..................
//尝试从bean工厂中查询出需要注入类型的所有Bean对象，@Qualifier注解的解析是在这个步骤中进行的
Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);
//beanFactory工厂中查询不到时,抛出异常
if (matchingBeans.isEmpty()) {
//如果descriptor需要注入
if (isRequired(descriptor)) {
//抛出NoSuchBeanDefinitionException或BeanNotOfRequiredTypeException以解决不可 解决的依赖关系
raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
}
//返回null，表示么有找到候选Bean对象
return null;
}
//定义用于存储唯一的候选Bean名变量
String autowiredBeanName;
//定义用于存储唯一的候选Bean对象变量
Object instanceCandidate;
//如果beanFactory工厂中存在多个类型的bean时
if (matchingBeans.size() > 1) {
//筛选出符合要求的bean
autowiredBeanName = determineAutowireCandidate(matchingBeans, descriptor);
//如果autowiredBeanName为null
if (autowiredBeanName == null) {
//如果查询不到合适的，而且该属性并非require=true的，可以赋值为null
if (isRequired(descriptor) || !indicatesMultipleBeans(type)) {
//让descriptor尝试选择其中一个实例，默认实现是抛出NoUniqueBeanDefinitionException.
return descriptor.resolveNotUnique(descriptor.getResolvableType(), matchingBeans);
}
else {
// In case of an optional Collection/Map, silently ignore a non-unique case:
// possibly it was meant to be an empty collection of multiple regular beans
// (before 4.3 in particular when we didn't even look for collection beans).
// 如果是可选的Collection/Map,则静默忽略一个非唯一情况：
// 可能是多个常规bean的空集合
// (尤其是在4.3之前，设置在我们没有寻找collection bean的时候 )
return null;
}
}
//获取autowiredBeanName对应的候选Bean对象
instanceCandidate = matchingBeans.get(autowiredBeanName);
}
else {
//如果查询出来只有一个时，则将该bean作为注入值
Map.Entry<String, Object> entry = matchingBeans.entrySet().iterator().next();
//让autowireBeanName引用该元素的候选bean名
autowiredBeanName = entry.getKey();
//让instanceCandidate引用该元素的候选bean对象
instanceCandidate = entry.getValue();
}
//如果候选bean名不为null，
if (autowiredBeanNames != null) {
//将autowiredBeanName添加到autowiredBeanNames中，又添加一次
autowiredBeanNames.add(autowiredBeanName);
}
//如果instanceCandidate是Class实例，对其进行实例化
if (instanceCandidate instanceof Class) {
//让instanceCandidate引用 descriptor对autowiredBeanName解析为该工厂的Bean实例
instanceCandidate = descriptor.resolveCandidate(autowiredBeanName, type, this);
}
//定义一个result变量，用于存储最佳候选Bean对象
Object result = instanceCandidate;
//如果reuslt是NullBean的实例
if (result instanceof NullBean) {
//如果descriptor需要注入
if (isRequired(descriptor)) {
//抛出NoSuchBeanDefinitionException或BeanNotOfRequiredTypeException以解决不可 解决的依赖关系
raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
}
//返回null，表示找不到最佳候选Bean对象
result = null;
}
//如果result不是type的实例
if (!ClassUtils.isAssignableValue(type, result)) {
//抛出Bean不是必需类型异常
throw new BeanNotOfRequiredTypeException(autowiredBeanName, type, instanceCandidate.getClass());
}
//返回最佳候选Bean对象【result】
return result;
}
finally {
//设置上一个切入点对象
ConstructorResolver.setCurrentInjectionPoint(previousInjectionPoint);
}
}1、尝试从缓存中获取被注入类型的所有Bean；
2、并对获取到Bean容器进行遍历，判断被注入类型是否有@Qualifier注解，有则进行名称匹配，匹配到时返回一个符合条件的Bean容器，否则返回所有注入类型的Bean用于后续进一步筛选。
3、如果获取不到时，判断该属性是否必须注入，如果非必须注入可以注入null;
4、如果匹配到的类型Bean只有一个时，则认为是符合要求的，返回该值后进行注入。
5、如果匹配到多个Bean时，根据匹配条件来筛选；
@Qualifier匹配过程见： isAutowireCandidate(BeanDefinitionHolder bdHolder, DependencyDescriptor descriptor)方法详解
多个bean的匹配过程见： determineAutowireCandidate(matchingBeans, descriptor)方法详解
isAutowireCandidate
public boolean isAutowireCandidate(BeanDefinitionHolder bdHolder, DependencyDescriptor descriptor) {
//判断要注入的字段是否有@Quilifier注解
boolean match = super.isAutowireCandidate(bdHolder, descriptor);
if (match) {
//校验是否匹配
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;
}determineAutowireCandidate
protected String determineAutowireCandidate(Map<String, Object> candidates, DependencyDescriptor descriptor) {
//通过反射的方式去查询已匹配的Bean容器中是否有@Primary注解，如果有多个则抛出异常，如果只有一个则代表该Bean对象为符合注入条件的
Class<?> requiredType = descriptor.getDependencyType();
String primaryCandidate = determinePrimaryCandidate(candidates, requiredType);
if (primaryCandidate != null) {
return primaryCandidate;
}
//判断已匹配的Bean容器中是否有@Priority注解，并比较其优先级大小，挑选出符合的一个
String priorityCandidate = determineHighestPriorityCandidate(candidates, requiredType);
if (priorityCandidate != null) {
return priorityCandidate;
}
// Fallback
// 这里将匹配的bean容器遍历后，挨个判断bean名称与要注入类型的名称是否相同，不同则去别名缓存中查询，看是否有别名与要注入类型的名称一样，有则匹配
for (Map.Entry<String, Object> entry : candidates.entrySet()) {
String candidateName = entry.getKey();
Object beanInstance = entry.getValue();
if ((beanInstance != null && this.resolvableDependencies.containsValue(beanInstance)) ||
matchesBeanName(candidateName, descriptor.getDependencyName())) {
return candidateName;
}
}
return null;
}1、通过反射的方式去查询已匹配的Bean容器中是否有@Primary注解，如果有多个则抛出异常，如果只有一个则代表该Bean对象为符合注入条件的
2、判断已匹配的Bean容器中是否有@Priority注解，并比较其优先级大小，挑选出符合的一个
3、这里将匹配的bean容器遍历后，挨个判断bean名称与要注入类型的名称是否相同，不同则去别名缓存中查询，看是否有别名与要注入类型的名称一样，有则匹配；
@Resource注入过程
public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
//查询注入对象或者方法中是否有@Resource注解
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;
}1、遍历当前Bean的属性及其方法，判断是否有@Resource注解，并封装成对应的包装类
2、对其进行查找注入
autowireResource
protected Object autowireResource(BeanFactory factory, LookupElement element, @Nullable String requestingBeanName)
throws NoSuchBeanDefinitionException {
// 自动装配的对象
Object resource;
// 自动装配的名字
Set<String> autowiredBeanNames;
// 依赖的属性名
String name = element.name;
//默认BeanFacory是AutowireCapableBeanFactory工厂类型
if (factory instanceof AutowireCapableBeanFactory) {
AutowireCapableBeanFactory beanFactory = (AutowireCapableBeanFactory) factory;
// 创建依赖描述
DependencyDescriptor descriptor = element.getDependencyDescriptor();
//这里的factory.containsBean(name)会根据需要注入的属性名称去BeanFactory工厂中进行查询，如果查询到了直接获取后进行注入，如果查询不到时，调用beanFactory.resolveDependency方法进行查找，该方法流程与@Autowire一样。
if (this.fallbackToDefaultTypeMatch && element.isDefaultName && !factory.containsBean(name)) {
//如果容器中还没有此bean，则会使用resolveDependency()方法将符合bean type的bean definetion调用一次getBean()
// 从这些bean选出符合requestingBeanName的bean
autowiredBeanNames = new LinkedHashSet<>();
resource = beanFactory.resolveDependency(descriptor, requestingBeanName, autowiredBeanNames, null);
if (resource == null) {
throw new NoSuchBeanDefinitionException(element.getLookupType(), "No resolvable resource object");
}
}
else {
//如果容器中有此bean则取出这个bean对象作为属性值
resource = beanFactory.resolveBeanByName(name, descriptor);
autowiredBeanNames = Collections.singleton(name);
}
}
else {
resource = factory.getBean(name, element.lookupType);
autowiredBeanNames = Collections.singleton(name);
}
//.......
//.......
return resource;
}@Resouce解析与@Autowire解析异同：
1、@Resouce会先尝试使用beanName名称去beanFactory工厂中查询是否有该定义信息，如果有则直接取出。
2、如果步骤1不满足时，走后面按类型匹配的步骤，该步骤与@Autowire调用的方法一致，所以流程是一样的；
总结
@Autowire解析步骤：
- 尝试从缓存中获取被注入类型的所有Bean；
- 并对获取到Bean容器进行遍历，判断被注入类型是否有@Qualifier注解，有则进行名称匹配，匹配到时返回一个符合条件的Bean容器，否则返回所有注入类型的Bean用于后续进一步筛选。
- 如果获取不到时，判断该属性是否必须注入，如果非必须注入可以注入null;
- 如果匹配到的类型Bean只有一个时，则认为是符合要求的，返回该值后进行注入。
如果匹配到多个Bean时，根据匹配条件来筛选：
- 通过反射的方式去查询已匹配的Bean容器中是否有@Primary注解，如果有多个则抛出异常，如果只有一个则代表该Bean对象为符合注入条件的
- 判断已匹配的Bean容器中是否有@Priority注解，并比较其优先级大小，挑选出符合的一个，数值越低优选级越高
- 这里将匹配的bean容器遍历后，挨个判断bean名称与要注入类型的名称是否相同，不同则去别名缓存中查询，看是否有别名与要注入类型的名称一样，有则匹配；
@Resouce解析步骤：
- 根据beanName去工厂中查询是否有该定义信息，有则获取Bean对象，没有则进行类型匹配操作；
- 尝试从缓存中获取被注入类型的所有Bean；
- 并对获取到Bean容器进行遍历，判断被注入类型是否有@Qualifier注解，有则进行名称匹配，匹配到时返回一个符合条件的Bean容器，否则返回所有注入类型的Bean用于后续进一步筛选。
- 如果获取不到时，判断该属性是否必须注入，如果非必须注入可以注入null;
- 如果匹配到的类型Bean只有一个时，则认为是符合要求的，返回该值后进行注入。
如果匹配到多个Bean时，根据匹配条件来筛选：
- 通过反射的方式去查询已匹配的Bean容器中是否有@Primary注解，如果有多个则抛出异常，如果只有一个则代表该Bean对象为符合注入条件的;
- 判断已匹配的Bean容器中是否有@Priority注解，并比较其优先级大小，挑选出符合的一个，数值越低优选级越高;
- 这里将匹配的bean容器遍历后，挨个判断bean名称与要注入类型的名称是否相同，不同则去别名缓存中查询，看是否有别名与要注入类型的名称一样，有则匹配；
