@Autowired注解实现原理

什么是@Autowired注解？

        是spring的一个注释，可以对方法，构造函数，方法进行注释，让Spring做bean的自动装配

        含义：自动装配 JavaBean ,按照类型装配，通过set方法进行装配，set方法可以省略

       1 默认是按照类去装配，如果容器中没有与其匹配的类，则会报异常：

                NoSuchBeanDefinitionException

        2 按照类型装配，容器中如果有多个类型与之匹配，则会自动切换为名称装配，如果还未匹配则会报异常:

                NoUniqueBeanDefinitionException

@Autowired实现原理：

        首先找到@Autowired的具体实现类

AutowiredAnnotationBeanPostProcessor

         通过观察分析后发现，真正对bean有操作的方法貌似就只有三个，其中一个还被弃用了

 我们详细看一下第一个和第二个

1，查找所有@Autowired注入的方法和属性

public class AutowiredAnnotationBeanPostProcessor implements SmartInstantiationAwareBeanPostProcessor, MergedBeanDefinitionPostProcessor, PriorityOrdered, BeanFactoryAware {
    
    public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
        //查找所有被@Autowired注释的属性，并封装成InjectionMetadata
        InjectionMetadata metadata = this.findAutowiringMetadata(beanName, beanType, (PropertyValues)null);
        metadata.checkConfigMembers(beanDefinition);
    }
    
    
    public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
        //查找所有被@Autowired注释的方法或者属性，并封装成InjectionMetadata
        InjectionMetadata metadata = this.findAutowiringMetadata(beanName, bean.getClass(), pvs);
		//注入
        try {
            
            metadata.inject(bean, beanName, pvs);
            return pvs;
        } catch (BeanCreationException var6) {
            throw var6;
        } catch (Throwable var7) {
            throw new BeanCreationException(beanName, "Injection of autowired dependencies failed", var7);
        }
    }
}

这里的两个方法的意思应该是，查所有被@Autowired的属性和方法，然后全部注入；

更深层的代码就不去看了，感兴趣可以自己深究一下，这几个核心的实现方法

findAutowiringMetadata(beanName, beanType, (PropertyValues)null);

buildAutowiringMetadata(clazz);

 

2,注入

metadata.inject(bean, beanName, pvs);

public void inject(Object target, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
        //获取所有要被注入的方法，属性
        Collection<InjectionMetadata.InjectedElement> checkedElements = this.checkedElements;
        Collection<InjectionMetadata.InjectedElement> elementsToIterate = checkedElements != null ? checkedElements : this.injectedElements;
        if (!((Collection)elementsToIterate).isEmpty()) {
            Iterator var6 = ((Collection)elementsToIterate).iterator();

            while(var6.hasNext()) {
                InjectionMetadata.InjectedElement element = (InjectionMetadata.InjectedElement)var6.next();
                //注入
                element.inject(target, beanName, pvs);
            }
        }

    }

  protected void inject(Object target, @Nullable String requestingBeanName, @Nullable PropertyValues pvs) throws Throwable {
            if (this.isField) {
                Field field = (Field)this.member;
                ReflectionUtils.makeAccessible(field);
                field.set(target, this.getResourceToInject(target, requestingBeanName));
            } else {
                if (this.checkPropertySkipping(pvs)) {
                    return;
                }

                try {
                    Method method = (Method)this.member;
                    //反射调用注入方法，将获取到的所有bean作为参数
                    ReflectionUtils.makeAccessible(method);
                    //注入
                    method.invoke(target, this.getResourceToInject(target, requestingBeanName));
                } catch (InvocationTargetException var5) {
                    throw var5.getTargetException();
                }
            }

        }

       核心代码：

                    ReflectionUtils.makeAccessible(method);
                    method.invoke(target, this.getResourceToInject(target,