关于Spring中@Autowired、@Resource和@Inject注解的区别请看：@Autowired、@Resource和@Inject注解的区别（最详细），本片文章将会带领你进行源码分析@Autowired、@Resource注解的不同。
在上面所说的那篇博客中，我们知道：
Spring对于@Autowired、@Resource注解使用不同的后置处理器进行处理
@Autowired、@Resource之间的处理方式不同，@Autowired是根据类型，@Resource是根据名称
在进行源码分析之前，你需要了解以下Bean的生命周期：Spring中bean的生命周期（最详细），其中在第五次调用bean的后置处理器时，完成属性的依赖注入，第五次调用bean的后置处理器的步骤：拿到Spring容器中所有的实现了BeanPostProcessor接口的类，然后判断其是否为InstantiationAwareBeanPostProcessor接口的实现类，如果是调用postProcessProperties方法，完成属性赋值。
在@Autowired、@Resource和@Inject注解的区别（最详细）文章中，已经知道了Spring使用AutowiredAnnotationBeanPostProcessor和CommonAnnotationBeanPostProcessor类分别处理@Autowired注解和@Resource注解，他们都实现了InstantiationAwareBeanPostProcessor类，所以标注了@Autowired、@Resource会在第六次调用bean的后置处理器的时候完成属性注入。
从上面两张类的关系图可以看到其都间接实现了InstantiationAwareBeanPostProcessor类，下面我们就一起分析一下源码：
代码块1.AbstractAutowireCapableBeanFactory#populateBean方法
-
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
-
// Give any InstantiationAwareBeanPostProcessors the opportunity to modify the
-
// state of the bean before properties are set. This can be used, for example,
-
// to support styles of field injection.
-
boolean continueWithPropertyPopulation =
true;
-
-
//1.第五次后置处理器，对应着我之前博客里面写的bean生命周期，首先判断这个bean是否是合成的，这个绝大多数是不是合成的，然后判断是否有InstantiationAwareBeanPostProcessors的接口
-
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
-
//2.拿到所有的BeanPostProcessors处置处理器
-
for (BeanPostProcessor bp : getBeanPostProcessors()) {
-
//3.逐一判断这个后置处理器是否是InstantiationAwareBeanPostProcessor类型的，因为BeanPostProcessor接口是为了统一进行管理bean后置处理器的
-
//BeanPostProcessor还有子接口，用于实现不同的作用，可以参考bean后置处理器那篇博客
-
if (bp
instanceof InstantiationAwareBeanPostProcessor) {
-
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
-
if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
-
continueWithPropertyPopulation =
false;
-
break;
-
}
-
}
-
}
-
}
-
//4.如果为true，则说明在第五次调用后置处理的时候返回为false，这样就不会进行属性注入了
-
//所以当你想bean中不进行属性注入，可以实现InstantiationAwareBeanPostProcessor的postProcessAfterInstantiation方法
-
if (!continueWithPropertyPopulation) {
-
return;
-
}
-
-
PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() :
null);
-
-
// 5.解析自动装配模式为AUTOWIRE_BY_NAME和AUTOWIRE_BY_TYPE（现在几乎不用，现在默认是AUTOWIRE_NO）
-
/**
-
* <bean id="fruit" class="com.joonwhee.open.demo.simple.Fruit" autowire="byName">
-
* <property name="color" value="Red"/>
-
* </bean>
-
* id值跟Fruit里的属性名一致
-
* <bean id="apple" class="com.joonwhee.open.demo.simple.Apple"/>
-
* public class Fruit {
-
* private Apple apple;//apple 会根据名称完成自动注入
-
* private String color;
-
* }
-
* */
-
if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME || mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) {
-
MutablePropertyValues newPvs =
new MutablePropertyValues(pvs);
-
// Add property values based on autowire by name if applicable.
-
if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME) {
-
autowireByName(beanName, mbd, bw, newPvs);
-
}
-
// Add property values based on autowire by type if applicable.
-
if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) {
-
autowireByType(beanName, mbd, bw, newPvs);
-
}
-
pvs = newPvs;
-
}
-
//6.检查是否有InstantiationAwareBeanPostProcessors接口的类
-
boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
-
boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);
-
-
if (hasInstAwareBpps || needsDepCheck) {
-
if (pvs ==
null) {
-
pvs = mbd.getPropertyValues();
-
}
-
PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
-
if (hasInstAwareBpps) {
-
//7.执行第六次后置处理器，完成属性赋值
-
for (BeanPostProcessor bp : getBeanPostProcessors()) {
-
if (bp
instanceof InstantiationAwareBeanPostProcessor) {
-
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
-
//在Spring5.1之后，使用的是postProcessProperties方法完成属性注入
-
PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
-
if (pvsToUse ==
null) {
-
if (filteredPds ==
null) {
-
filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
-
}
-
pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
-
if (pvsToUse ==
null) {
-
return;
-
}
-
}
-
pvs = pvsToUse;
-
}
-
}
-
}
-
//8.依赖检查，对应depends-on属性
-
if (needsDepCheck) {
-
checkDependencies(beanName, mbd, filteredPds, pvs);
-
}
-
}
-
//9.将所有PropertyValues中的属性填充到bean中
-
if (pvs !=
null) {
-
applyPropertyValues(beanName, mbd, bw, pvs);
-
}
-
}
AbstractAutowireCapableBeanFactory#populateBean方法是在Spring启动时，完成非懒加载单实例bean注册到容器时会执行的方法，可以对着Spring中bean的生命周期（最详细）来进行分析，populateBean方法会执行bean生命周期的第五、第六次后置处理器，第五次就不做分析了，关键进行分析第六次完成属性注入的生命周期，在populateBean方法中的第7步，会拿到所有的BeanPostProcessors方法，然后判断是否是InstantiationAwareBeanPostProcessor类型的，如果是则执行postProcessPropertyValues方法完成属性注入，因为AutowiredAnnotationBeanPostProcessor和CommonAnnotationBeanPostProcessor类都实现了InstantiationAwareBeanPostProcessor接口，所以会在第7步进行调用各自的方法，我们先看一下getBeanPostProcessors方法，看代码块2。
然后看一下AutowiredAnnotationBeanPostProcessor的postProcessProperties方法，看代码块3.
CommonAnnotationBeanPostProcessor的postProcessProperties方法，看代码块8.
代码块2.AbstractBeanFactory#getBeanPostProcessors方法
-
/**
-
* Return the list of BeanPostProcessors that will get applied
-
* to beans created with this factory.
-
*/
-
//就是简单的返回容器中所有的beanPostProcessors
-
public List<BeanPostProcessor> getBeanPostProcessors() {
-
return
this.beanPostProcessors;
-
}
代码块3. AutowiredAnnotationBeanPostProcessor#postProcessProperties方法
-
@Override
-
public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
-
//1.获取这个类中所有标注了@Autowired的属性和方法，并把它们封装在InjectionMetadata对象中
-
InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);
-
try {
-
//2.完成bean的属性注入
-
metadata.inject(bean, beanName, pvs);
-
}
-
catch (BeanCreationException ex) {
-
throw ex;
-
}
-
return pvs;
-
}
第1步，解析出这个类中所有的标注了@Autowired的属性和方法，看代码块4，第2步，完成对bean属性的注入，看代码块6.
代码块4.AutowiredAnnotationBeanPostProcessor#findAutowiringMetadata方法
-
private InjectionMetadata findAutowiringMetadata(String beanName, Class<?> clazz, @Nullable PropertyValues pvs) {
-
// Fall back to class name as cache key, for backwards compatibility with custom callers.
-
//1.得到bean的名称
-
String cacheKey = (StringUtils.hasLength(beanName) ? beanName : clazz.getName());
-
// Quick check on the concurrent map first, with minimal locking.
-
//2.先从缓存中获取已经解析过的类，在完成对一个类的解析之后，会进行缓存，第二次就不用在去解析了
-
InjectionMetadata metadata =
this.injectionMetadataCache.get(cacheKey);
-
//3.判断是否刷新
-
if (InjectionMetadata.needsRefresh(metadata, clazz)) {
-
//4.加锁
-
synchronized (
this.injectionMetadataCache) {
-
//6.再次从缓存中获取解析之后的类
-
metadata =
this.injectionMetadataCache.get(cacheKey);
-
if (InjectionMetadata.needsRefresh(metadata, clazz)) {
-
if (metadata !=
null) {
-
metadata.clear(pvs);
-
}
-
//7.完成对类的解析，获取所有的标注了@Autowired的属性和方法
-
metadata = buildAutowiringMetadata(clazz);
-
//8.放入到缓存中
-
this.injectionMetadataCache.put(cacheKey, metadata);
-
}
-
}
-
}
-
return metadata;
-
}
在第7步中会完成对类的解析，解析出所有标注了@Autowired的属性和方法，看代码块5.
代码块5.AutowiredAnnotationBeanPostProcessor#buildAutowiringMetadata方法
-
private InjectionMetadata buildAutowiringMetadata(final Class<?> clazz) {
-
List<InjectionMetadata.InjectedElement> elements =
new ArrayList<>();
-
Class<?> targetClass = clazz;
-
-
do {
-
final List<InjectionMetadata.InjectedElement> currElements =
new ArrayList<>();
-
-
//1.解析类中属性标注@Autowired注解的情况
-
ReflectionUtils.doWithLocalFields(targetClass, field -> {
-
AnnotationAttributes ann = findAutowiredAnnotation(field);
-
if (ann !=
null) {
-
//2.如果这个属性是static修饰的，即使被@Autowired标注也不会进行属性的自动注入，直接返回
-
//这里使用的是lamda表达式，虽然有返回，但是不是退出buildAutowiringMetadata方法，不懂的自行百度
-
if (Modifier.isStatic(field.getModifiers())) {
-
return;
-
}
-
//3.判断@Autowired注解里面的required字段
-
boolean required = determineRequiredStatus(ann);
-
//4.封装成AutowiredFieldElement对象，添加到currElements集合中
-
currElements.add(
new AutowiredFieldElement(field, required));
-
}
-
});
-
-
ReflectionUtils.doWithLocalMethods(targetClass, method -> {
-
Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);
-
if (!BridgeMethodResolver.isVisibilityBridgeMethodPair(method, bridgedMethod)) {
-
return;
-
}
-
AnnotationAttributes ann = findAutowiredAnnotation(bridgedMethod);
-
if (ann !=
null && method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) {
-
if (Modifier.isStatic(method.getModifiers())) {
-
//5.如果这个方法是static修饰的，即使被@Autowired标注也不会进行属性的自动注入，直接返回
-
return;
-
}
-
boolean required = determineRequiredStatus(ann);
-
//6.判断@Autowired注解里面的required字段
-
PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
-
currElements.add(
new AutowiredMethodElement(method, required, pd));
-
}
-
});
-
-
elements.addAll(
0, currElements);
-
//7.解析父类，这个可以看出Spring想的真周到
-
targetClass = targetClass.getSuperclass();
-
}
-
while (targetClass !=
null && targetClass != Object.class);
-
-
return
new InjectionMetadata(clazz, elements);
-
}
可以看到如果属性和方法被static修饰的话，是不会完成属性的自动注入的，在第7步中，还会递归解析当前类的父类，这一点我感觉Spring做的真周到，你想到的没想到的，Spring都会帮你做。
代码块6.InjectionMetadata#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);
-
//1.拿到类中(包括父类)标注了@Autowired注解的属性和方法
-
if (!elementsToIterate.isEmpty()) {
-
for (InjectedElement element : elementsToIterate) {
-
//2.遍历，然后对每一个完成属性注入，这个是分属性和方法的，他们都实现了InjectedElement类，重写了inject方法
-
//这里已属性注入为例
-
element.inject(target, beanName, pvs);
-
}
-
}
-
}
第2步遍历类中所有的标注了@Autowired属性和方法，具体看代码块7
代码块7.AutowiredFieldElement#inject方法
-
@Override
-
protected void inject(Object bean, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
-
//1.记住这里是调用InjectedElement的方法，标注了@Autowired注解的属性和方法都会被封装成InjectedElement类，
-
//所以这里使用this.member就是获取封装在InjectedElement的属性
-
Field field = (Field)
this.member;
-
Object value;
-
//2.是否已有解析之后的缓存，如果有，则直接从缓存里面取
-
if (
this.cached) {
-
value = resolvedCachedArgument(beanName,
this.cachedFieldValue);
-
}
-
else {
-
//3.将属性和@Autowired注解里面的@Autowired字段封装成DependencyDescriptor对象
-
DependencyDescriptor desc =
new DependencyDescriptor(field,
this.required);
-
desc.setContainingClass(bean.getClass());
-
-
Set<String> autowiredBeanNames =
new LinkedHashSet<>(
1);
-
TypeConverter typeConverter = beanFactory.getTypeConverter();
-
try {
-
//4.从容器中获取所依赖的bean，由于该方法过于复杂，我只看懂了一点，所以这个方法就不行解析，我大致说一下过程
-
//首先会判断需要注入属性的类型是否是Array、Collection、Map类型的，如果是，则查找所有属性的泛型类型进行注入
-
//例如Map<String,Student> map,然后Spring判断是Map类型，将就回去查找Value所对应的类型是Student，
-
//然后就会查找所有的Student类型，以bean的id为key，以Student的实例为Value注入到这个map中
-
//如果不是Array、Collection、Map类型的，就是去查找所有的需要注入属性的类型，如果只有一个，则直接注入，
-
//如发现多个就会查找一个最优，会先通过@Primary注解查找最优，如果找不到会通过@Priority注解查找最优，如果该找不到
-
//就是用基本策略，使用属性的名称进行逐个匹配查找到的bean的id，如果属性的名称和bean的id相同即为最优，如果还找打不到
-
//那么就不要意思了，直接报错了
-
value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);
-
}
-
catch (BeansException ex) {
-
throw
new UnsatisfiedDependencyException(
null, beanName,
new InjectionPoint(field), ex);
-
}
-
//5.放到缓存中，下次不用进行解析了
-
synchronized (
this) {
-
if (!
this.cached) {
-
if (value !=
null ||
this.required) {
-
this.cachedFieldValue = desc;
-
registerDependentBeans(beanName, autowiredBeanNames);
-
//步骤如果autowiredBeanNames大于1，说明是Array、Collection、Map类型
-
if (autowiredBeanNames.size() ==
1) {
-
String autowiredBeanName = autowiredBeanNames.iterator().next();
-
//6.如果是1个，也需要判断是不是Array、Collection、Map类型
-
if (beanFactory.containsBean(autowiredBeanName) &&
-
beanFactory.isTypeMatch(autowiredBeanName, field.getType())) {
-
this.cachedFieldValue =
new ShortcutDependencyDescriptor(
-
desc, autowiredBeanName, field.getType());
-
}
-
}
-
}
-
else {
-
this.cachedFieldValue =
null;
-
}
-
this.cached =
true;
-
}
-
}
-
}
-
if (value !=
null) {
-
ReflectionUtils.makeAccessible(field);
-
field.set(bean, value);
-
}
-
}
-
}
其中第4步是最重点，也是最难得看懂的，如果想要了解这个方法，可以参考大神写的博客：Spring IoC：createBean 详解（上），这篇文章从代码块9开始讲的就是这个方法，反正我是看懵逼了，有兴趣的可以看看，到这里关于@Autowired源码就介绍完了。
下面我们来看一下CommonAnnotationBeanPostProcessor的postProcessProperties方法。
代码块8.CommonAnnotationBeanPostProcessor#postProcessProperties方法
-
@Override
-
public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
-
//1.获取这个类中所有标注了@Resource的属性和方法，并把它们封装在InjectionMetadata对象中
-
InjectionMetadata metadata = findResourceMetadata(beanName, bean.getClass(), pvs);
-
try {
-
//2.完成bean的属性注入
-
metadata.inject(bean, beanName, pvs);
-
}
-
catch (Throwable ex) {
-
throw
new BeanCreationException(beanName,
"Injection of resource dependencies failed", ex);
-
}
-
return pvs;
-
}
CommonAnnotationBeanPostProcessor和AutowiredAnnotationBeanPostProcessor的postProcessProperties方法基本一样。
第1步，解析出所有标注了@Resource的属性和方法，并把它们封装在InjectionMetadata对象中，具体看代码块9。
第2步，完成bean的属性注入，具体看代码块13.
代码块9.CommonAnnotationBeanPostProcessor#findResourceMetadata方法
-
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.
-
//1.得到bean的名称
-
String cacheKey = (StringUtils.hasLength(beanName) ? beanName : clazz.getName());
-
// Quick check on the concurrent map first, with minimal locking.
-
//2.先从缓存中获取已经解析过的类，在完成对一个类的解析之后，会进行缓存，第二次就不用在去解析了
-
InjectionMetadata metadata =
this.injectionMetadataCache.get(cacheKey);
-
//3.判断是否刷新
-
if (InjectionMetadata.needsRefresh(metadata, clazz)) {
-
//4.加锁
-
synchronized (
this.injectionMetadataCache) {
-
//5.再次从缓存中获取解析之后的类
-
metadata =
this.injectionMetadataCache.get(cacheKey);
-
if (InjectionMetadata.needsRefresh(metadata, clazz)) {
-
if (metadata !=
null) {
-
metadata.clear(pvs);
-
}
-
//6.完成对类的解析，获取所有的标注了@Resource的属性和方法
-
metadata = buildResourceMetadata(clazz);
-
//7.放入到缓存中
-
this.injectionMetadataCache.put(cacheKey, metadata);
-
}
-
}
-
}
-
return metadata;
-
}
这个方法和AutowiredAnnotationBeanPostProcessor的一样就不多介绍，关键看一下第6步，进行解析@Resource注解，解析的时候就不一样了，具体看代码块10。
代码块10.CommonAnnotationBeanPostProcessor#buildResourceMetadata方法
-
private InjectionMetadata buildResourceMetadata(final Class<?> clazz) {
-
List<InjectionMetadata.InjectedElement> elements =
new ArrayList<>();
-
Class<?> targetClass = clazz;
-
-
do {
-
final List<InjectionMetadata.InjectedElement> currElements =
new ArrayList<>();
-
//1.解析标注了@Resource注解的属性，
-
ReflectionUtils.doWithLocalFields(targetClass, field -> {
-
//2.判断是否标注了@WebServiceRef注解，这个没看
-
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));
-
}
-
//3.判断是否标注了@EJB注解，这个没看
-
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));
-
}
-
//4.判断是否标注了@Resource注解，
-
else
if (field.isAnnotationPresent(Resource.class)) {
-
//5.@Resource注解如果标注在static修饰的属性上，直接报错，不知道上面你是否记得@Autowired是怎么处理static修饰的属性的
-
//忘记的翻看上文代码
-
if (Modifier.isStatic(field.getModifiers())) {
-
throw
new IllegalStateException(
"@Resource annotation is not supported on static fields");
-
}
-
//6.判断是否是需要被忽略的类型
-
if (!
this.ignoredResourceTypes.contains(field.getType().getName())) {
-
currElements.add(
new ResourceElement(field, field,
null));
-
}
-
}
-
});
-
//7.解析标注了@Resource注解的方法
-
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));
-
}
-
//8.判断方法上是否标注了@Resource注解
-
else
if (bridgedMethod.isAnnotationPresent(Resource.class)) {
-
//9.@Resource注解如果标注在static修饰的方法上，直接报错，
-
if (Modifier.isStatic(method.getModifiers())) {
-
throw
new IllegalStateException(
"@Resource annotation is not supported on static methods");
-
}
-
//10.获取其@Resource标注方法的形参列表
-
Class<?>[] paramTypes = method.getParameterTypes();
-
//11.如果不是1个就报错，这Spring对于@Resource要求的真实苛刻啊，两个为啥不行呢，我是不知道的
-
//有知道的可以告诉我一声，我猜是鼓励大家用SPring自家的注解
-
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);
-
//12.递归解析父类的@Resource注解
-
targetClass = targetClass.getSuperclass();
-
}
-
while (targetClass !=
null && targetClass != Object.class);
-
-
return
new InjectionMetadata(clazz, elements);
-
}
到这里我们已经知道了:
一：使用@Resource时，如果是static则直接报错，使用@Autowired则不会。
二：使用@Resource标注在方法上面时，方法的参数只能有一个，没有或多个参数则直接报错，使用@Autowired则没有限制。
在第6步，会判断是否是被忽略的类型，如果不是，则添加到集合中，我们看一下ResourceElement类是如何实现的，看代码块11
代码块11.CommonAnnotationBeanPostProcessor类的内部类ResourceElement
-
/**
-
* Class representing injection information about an annotated field
-
* or setter method, supporting the @Resource annotation.
-
*/
-
private
class ResourceElement extends LookupElement {
-
-
private
final
boolean lazyLookup;
-
-
public ResourceElement(Member member, AnnotatedElement ae, @Nullable PropertyDescriptor pd) {
-
super(member, pd);
-
//1.从属性中面获取@Resource注解
-
Resource resource = ae.getAnnotation(Resource.class);
-
//2.获取@Resource注解上面name属性的值
-
String resourceName = resource.name();
-
//3.获取@Resource注解上面type属性的值
-
Class<?> resourceType = resource.type();
-
//4.如果@Resource注解name属性值为空，则isDefaultName为ture，就会使用默认的名称
-
this.isDefaultName = !StringUtils.hasLength(resourceName);
-
if (
this.isDefaultName) {
-
//5.如果使用了默认名称的话，就会使用标注了@Resource注解属性的名称
-
resourceName =
this.member.getName();
-
//6.如果标注了@Resource注解的是方法，那么就是判断是否是以set开头的
-
if (
this.member
instanceof Method && resourceName.startsWith(
"set") && resourceName.length() >
3) {
-
//7.如果是以set开头长度大于3则将set去除，并把首字母变成小写
-
resourceName = Introspector.decapitalize(resourceName.substring(
3));
-
}
-
}
-
else
if (embeddedValueResolver !=
null) {
-
resourceName = embeddedValueResolver.resolveStringValue(resourceName);
-
}
-
//8.检查在@Resource注解中设置的属性和和标注了@Resource注解的属性类型是否是一致的
-
if (Object.class != resourceType) {
-
checkResourceType(resourceType);
-
}
-
else {
-
// No resource type specified... check field/method.
-
//9.没用设置的的话，使用@Resource注解的属性类型
-
resourceType = getResourceType();
-
}
-
this.name = (resourceName !=
null ? resourceName :
"");
-
this.lookupType = resourceType;
-
String lookupValue = resource.lookup();
-
this.mappedName = (StringUtils.hasLength(lookupValue) ? lookupValue : resource.mappedName());
-
//10.判断是否为懒加载的
-
Lazy lazy = ae.getAnnotation(Lazy.class);
-
this.lazyLookup = (lazy !=
null && lazy.value());
-
}
-
-
@Override
-
protected Object getResourceToInject(Object target, @Nullable String requestingBeanName) {
-
return (
this.lazyLookup ? buildLazyResourceProxy(
this, requestingBeanName) :
-
getResource(
this, requestingBeanName));
-
}
-
}
这个类主要是用来解析@Resource注解的，因为@Resource注解有很多属性，具体看代码块12
代码块12.@Resource注解
-
@Target({TYPE, FIELD, METHOD})
-
@Retention(RUNTIME)
-
public
@interface Resource {
-
-
String name() default "";
-
-
String lookup() default "";
-
-
Class<?> type()
default java.lang.Object.class;
-
-
enum AuthenticationType {
-
CONTAINER,
-
APPLICATION
-
}
-
-
AuthenticationType authenticationType() default AuthenticationType.CONTAINER;
-
-
boolean shareable() default true;
-
-
String mappedName() default "";
-
-
String description() default "";
-
}
代码块12是为了让你更好的理解代码块11，这两个要结合着看。
代码块13.InjectionMetadata#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);
-
//1.判断类中标注了@Resource注解的集合是否为空
-
if (!elementsToIterate.isEmpty()) {
-
for (InjectedElement element : elementsToIterate) {
-
//2.不为空，则进行处理
-
element.inject(target, beanName, pvs);
-
}
-
}
-
}
第2步会遍历类中所有加了@Resource注解的属性和方法，然后对每个完成依赖注入，具体看代码14
代码块14.InjectionMetadata类的内部类InjectedElement#inject方法
-
/**
-
* Either this or {@link #getResourceToInject} needs to be overridden.
-
*/
-
protected void inject(Object target, @Nullable String requestingBeanName, @Nullable PropertyValues pvs)
-
throws Throwable {
-
//1.判断是属性还是方法
-
if (
this.isField) {
-
Field field = (Field)
this.member;
-
ReflectionUtils.makeAccessible(field);
-
//2.getResourceToInject方法会依赖项的查找
-
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();
-
}
-
}
-
}
重点关注属性的依赖注入，对于方法的和属性的差不多，这里不做过多介绍，在第2步会查找并注入依赖项，具体看代码块15.
代码块15.CommonAnnotationBeanPostProcessor类的内部类ResourceElement#getResourceToInject方法
-
@Override
-
protected Object getResourceToInject(Object target, @Nullable String requestingBeanName) {
-
return (
this.lazyLookup ? buildLazyResourceProxy(
this, requestingBeanName) :
-
getResource(
this, requestingBeanName));
-
}
判断是否为懒加载，如果是则进行懒加载，懒加载会返回一个代理的类用来替代，只有在使用到这个属性的时候才回去加载，如果不是懒加载，则调用getResource方法获取依赖项，具体看代码块16.
代码块16.CommonAnnotationBeanPostProcessor#getResource方法
-
protected Object getResource(LookupElement element, @Nullable String requestingBeanName)
-
throws NoSuchBeanDefinitionException {
-
//这个mappedName没有研究
-
if (StringUtils.hasLength(element.mappedName)) {
-
return
this.jndiFactory.getBean(element.mappedName, element.lookupType);
-
}
-
if (
this.alwaysUseJndiLookup) {
-
return
this.jndiFactory.getBean(element.name, element.lookupType);
-
}
-
//1.完成依赖注入
-
return autowireResource(
this.resourceFactory, element, requestingBeanName);
-
}
在第1步中会完成依赖注入，看代码块17
代码块17.CommonAnnotationBeanPostProcessor#autowireResource方法
-
protected Object autowireResource(BeanFactory factory, LookupElement element, @Nullable String requestingBeanName)
-
throws NoSuchBeanDefinitionException {
-
-
Object resource;
-
Set<String> autowiredBeanNames;
-
//1.获取名称，如果在注解内部指定了name属性，则name就为执行的name
-
//如果没有指定，则会获取标注了@Resource注解中属性的名称
-
String name = element.name;
-
-
if (factory
instanceof AutowireCapableBeanFactory) {
-
AutowireCapableBeanFactory beanFactory = (AutowireCapableBeanFactory) factory;
-
DependencyDescriptor descriptor = element.getDependencyDescriptor();
-
//2.fallbackToDefaultTypeMatch：判断是否回退到默认类型匹配
-
//isDefaultName：代码块11中进行了说明，如果@Resource注解name属性有值，则isDefaultName为false，如果@Resource注解name属性没有值，则为true，
-
//isDefaultName为true，element.name是标注了@Resource注解中属性的名称
-
//查看工厂中是否包含该名称的bean
-
if (
this.fallbackToDefaultTypeMatch && element.isDefaultName && !factory.containsBean(name)) {
-
autowiredBeanNames =
new LinkedHashSet<>();
-
//3.resolveDependency方法在代码块7中介绍了，如果走这个，是和@Autowired注解一样
-
resource = beanFactory.resolveDependency(descriptor, requestingBeanName, autowiredBeanNames,
null);
-
if (resource ==
null) {
-
throw
new NoSuchBeanDefinitionException(element.getLookupType(),
"No resolvable resource object");
-
}
-
}
-
else {
-
//4.根据名称去查找bean
-
resource = beanFactory.resolveBeanByName(name, descriptor);
-
autowiredBeanNames = Collections.singleton(name);
-
}
-
}
-
else {
-
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;
-
}
在第二步中，比较绕，我们举例说明：
-
@Resource
-
private String student;
-
//因为此时@Resource注解中name属性为空，
-
//所以：element.isDefaultName = true
-
//element.name = student
-
-
@Resource(name =
"student1")
-
private String student2;
-
//因为此时@Resource注解中name属性有值，
-
//所以：element.isDefaultName = false
-
//element.name = student1，即@Resource内部指定的
根据第二步我们知道，如果@Resource想要像@Autowired一样，使用类型进行匹配，需要满足一下条件，是都需要满足的
1.@Resource注解中name属性没有进行设置
2.第一条满足之后，会查看标注了@Resource属性的名称在容器在容器中不存在，什么意思？比如
-
@Resource
-
private String student2;
id为student2的bean在容器中不存在。
只有上面两条同时存在，则会和@Autowired走一样的逻辑。
总结：
这里在总结一下@Autowired、@Resource注解的区别：
@Autowired注解：
1.Spring本身替换的注解（org.springframework.beans.factory.annotation.Autowired），需要导入Spring相应的jar包才能使用
2.可以标注的位置：构造器、方法、方法参数、变量域和注解上面
3.在Spring容器解析@Autowired注解时，使用的后置处理器为AutowiredAnnotationBeanPostProcessor
4. @Autowired注解有一个required属性，当指定required属性为false时，意味着在容器中找相应类型的bean，如果找不到则忽略，而不报错（这一条是两个注解所没有的功能）
5. 默认优先按照类型去容器中找对应的组件，找到就赋值，如果找到多个相同类型的组件，再将属性的名称作为组件的id去容器中查找，如果组件id对象的bean不存在，而且required属性为true，就报错
6.如果标注了@Autowired的是static静态的属性或方法，那么Spring会直接忽略，但不会报错。
@Resource注解：
1.JSR250规范提供的注解（javax.annotation.Resource），不需要导入格外的包，这个注解在JDK的rt.jar包中
2.可以标注的位置：TYPE(表示可以标注在接口、类、枚举)，FIELD(变量域)和METHOD(方法)上面。
3.在Spring容器解析@Resource注解时，使用的后置处理器为CommonAnnotationBeanPostProcessor
4. 默认是按照组件名称进行装配的，根据@Resource注解name属性的名称去容器中查找，如果name没有指定，则根据标注了@Resource的属性名称去判断容器中是否存在该名称的bean，如果不存在，则会走和@Autowired一样的逻辑，这个时候就会支持@Primary注解（有的博客说不支持，那么错误的，源码不会骗人）。
5.如果标注了@Resource的是static静态的属性或方法，那么会直接报错
6.标注了@Resource的是方法只能有一个参数，如果是没有或者是多个，那么Spring会直接报错，而@Autowired则没有限制。
转载：https://blog.csdn.net/qq_35634181/article/details/104802906
查看评论