@Autowired的使用及源码分析

@Autowired使用

构造函数注入

publicClassOuter{
privateInnerinner;
@Autowired
publicOuter(Innerinner){
this.inner=inner;
}
}

属性注入

publicClassOuter{
@Autowired
privateInnerinner;
}

方法注入

publicClassOuter{
privateInnerinner;
publicInnergetInner(){
returninner;
}
@Autowired
publicvoidsetInner(Innerinner){
this.inner=inner;
}
}

目前绝大部分的代码都使用第2、第3种。第1种在bean实例化时完成，而第2、第3种的实现原理都是一样的，在属性填充时完成。本篇将介绍第二第三种的是实现原理

在开始之前，如果我们自己设计@Autowired，我们应该怎么实现？我想做法还是比较简单的

• 通过反射查找bean的class下所有注解了@Autowired的字段和方法
• 获取到字段，通过getBean(字段)获取到对应bean，然后再通过反射调用field的set将bean注入

@Autowired源码分析

AutowiredAnnotationBeanPostProcessor类

该类是@Autowired的具体实现类，先预览一下类方法

发现实际有机会介入bean的创建操作只有可能是后置处理器，用于后置处理的有3个方法，其中一个过时不用，分别是postProcessMergedBeanDefinition、postProcessProperties后置处理，我们再看一下这2个方法的具体代码

publicclassAutowiredAnnotationBeanPostProcessorextendsInstantiationAwareBeanPostProcessorAdapter
implementsMergedBeanDefinitionPostProcessor,PriorityOrdered,BeanFactoryAware{

...

@Override
publicvoidpostProcessMergedBeanDefinition(RootBeanDefinitionbeanDefinition,ClassbeanType,StringbeanName){
//1.寻找bean中所有被@Autowired注释的属性，并将属性封装成InjectedElement类型
InjectionMetadatametadata=findAutowiringMetadata(beanName,beanType,null);
metadata.checkConfigMembers(beanDefinition);
}

...

@Override
publicPropertyValuespostProcessProperties(PropertyValuespvs,Objectbean,StringbeanName){
//1.寻找通过@Autowired注解的属性或者方法
InjectionMetadatametadata=findAutowiringMetadata(beanName,bean.getClass(),pvs);
try{
//2.注入
metadata.inject(bean,beanName,pvs);
}
catch(BeanCreationExceptionex){
throwex;
}
catch(Throwableex){
thrownewBeanCreationException(beanName,"Injectionofautowireddependenciesfailed",ex);
}
returnpvs;
}

...
}

跟我们的猜想是一样的，首先先找出所有注解了@Autowired的属性或者方法，然后进行注入，当然postProcessMergedBeanDefinition后置处理器的调用肯定是在postProcessProperties之前的，这里我们回顾一下spring bean的创建过程。

2个处理器我已用黄色标出

1. 查找所有@Autowired

//寻找bean中所有被@Autowired注释的属性，并将属性封装成InjectedElement类型
InjectionMetadatametadata=findAutowiringMetadata(beanName,beanType,null);

privateInjectionMetadatafindAutowiringMetadata(StringbeanName,Classclazz,@NullablePropertyValuespvs){
//Fallbacktoclassnameascachekey,forbackwardscompatibilitywithcustomcallers.
//获取缓存的key值，一般以beanName做key
StringcacheKey=(StringUtils.hasLength(beanName)?beanName:clazz.getName());
//Quickcheckontheconcurrentmapfirst,withminimallocking.
//从缓存中获取metadata
InjectionMetadatametadata=this.injectionMetadataCache.get(cacheKey);
//检测metadata是否需要更新
if(InjectionMetadata.needsRefresh(metadata,clazz)){
synchronized(this.injectionMetadataCache){
metadata=this.injectionMetadataCache.get(cacheKey);
if(InjectionMetadata.needsRefresh(metadata,clazz)){
if(metadata!=null){
metadata.clear(pvs);
}
//通过clazz类，查找所有@Autowired的属性或者方法，并封装成InjectionMetadata类型
metadata=buildAutowiringMetadata(clazz);
//将metadata加入缓存
this.injectionMetadataCache.put(cacheKey,metadata);
}
}
}
returnmetadata;
}

可以看到spring依然在用缓存的方式提高性能，继续跟踪核心代码buildAutowiringMetadata(clazz)

privateInjectionMetadatabuildAutowiringMetadata(finalClassclazz){
//查看clazz是否有Autowired注解
if(!AnnotationUtils.isCandidateClass(clazz,this.autowiredAnnotationTypes)){
returnInjectionMetadata.EMPTY;
}
//这里需要注意AutowiredFieldElement，AutowiredMethodElement均继承了InjectionMetadata.InjectedElement
//因此这个列表是可以保存注解的属性和被注解的方法的
Listelements=newArrayList<>();
ClasstargetClass=clazz;

//1.通过dowhile循环，递归的往直接继承的父类寻找@Autowired
do{
finalListcurrElements=newArrayList<>();

//2.通过反射，获取所有属性，doWithLocalFields则是循环的对每个属性应用以下匿名方法
ReflectionUtils.doWithLocalFields(targetClass,field->{
//判断当前field属性是否含有@Autowired的注解
MergedAnnotationann=findAutowiredAnnotation(field);
if(ann!=null){
//返回该属性在类中的修饰符，如果等于static常量，则抛出异常，@Autowired不允许注解在静态属性上
if(Modifier.isStatic(field.getModifiers())){
if(logger.isInfoEnabled()){
logger.info("Autowiredannotationisnotsupportedonstaticfields:"+field);
}
return;
}
//@Autowired有required属性，获取required的值，默认为true
booleanrequired=determineRequiredStatus(ann);
//3.将field封装成InjectedElement，并添加到集合中，这里用的是AutowiredFieldElement
currElements.add(newAutowiredFieldElement(field,required));
}
});

//4.@Autowired可以注解在方法上
ReflectionUtils.doWithLocalMethods(targetClass,method->{
MethodbridgedMethod=BridgeMethodResolver.findBridgedMethod(method);
if(!BridgeMethodResolver.isVisibilityBridgeMethodPair(method,bridgedMethod)){
return;
}
MergedAnnotationann=findAutowiredAnnotation(bridgedMethod);
if(ann!=null&&method.equals(ClassUtils.getMostSpecificMethod(method,clazz))){
if(Modifier.isStatic(method.getModifiers())){
if(logger.isInfoEnabled()){
logger.info("Autowiredannotationisnotsupportedonstaticmethods:"+method);
}
return;
}
if(method.getParameterCount()==0){
if(logger.isInfoEnabled()){
logger.info("Autowiredannotationshouldonlybeusedonmethodswithparameters:"+
method);
}
}
booleanrequired=determineRequiredStatus(ann);
PropertyDescriptorpd=BeanUtils.findPropertyForMethod(bridgedMethod,clazz);
//5.将方法封装成InjectedElement，并添加到集合中，这里用的是AutowiredMethodElement
currElements.add(newAutowiredMethodElement(method,required,pd));
}
});

elements.addAll(0,currElements);
//返回直接继承的父类
targetClass=targetClass.getSuperclass();
}
//如果父类不为空则需要把父类的@Autowired属性或方法也找出
while(targetClass!=null&&targetClass!=Object.class);
//6.newInjectionMetadata(clazz,elements)，将找到的所有的待注入属性或方法生成metadata返回
returnInjectionMetadata.forElements(elements,clazz);
}

• 外层 do … while … 的循环被用于递归的查找父类的@Autowired属性或方法

• 通过反射的方式获取到所有属性并循环验证每一个属性是否被@Autowired注解

• 将查找到包含@Autowired注解的filed封装成AutowiredFieldElement，加入到列表中

• 循环查找在方法上的注解

• 将找到的方法封装成AutowiredMethodElement，并加入列表

这里需要特别强调一点，InjectedElement被AutowiredFieldElement、AutowiredMethodElement所继承，他们都有各自的inject函数，实现各自的注入。因此改ArrayList elements是拥有2种类型的属性

• 将找到的所有元素列表和clazz作为参数生成metadata数据返回

2. 注入

//注入
metadata.inject(bean,beanName,pvs);

publicvoidinject(Objecttarget,@NullableStringbeanName,@NullablePropertyValuespvs)throwsThrowable{
//获取所有需要被注入的元素
CollectioncheckedElements=this.checkedElements;
CollectionelementsToIterate=
(checkedElements!=null?checkedElements:this.injectedElements);
//迭代的元素不为空
if(!elementsToIterate.isEmpty()){
for(InjectedElementelement:elementsToIterate){
if(logger.isTraceEnabled()){
logger.trace("Processinginjectedelementofbean'"+beanName+"':"+element);
}
//循环注入，这里有可能是AutowiredFieldElement也可能AutowiredMethodElement，因此调用的inject是2个不同的方法
element.inject(target,beanName,pvs);
}
}
}

利用for循环，遍历刚刚我们查到到的elements列表，进行注入。

在上面有特别提醒，这里的element有可能是AutowiredFieldElement类型、或AutowiredMethodElement类型。各自代表@Autowired注解在属性上、以及注解在方法上的2种不同元素。因此他们调用的element.inject(target, beanName, pvs);也是不一样的

2.1 字段注入(AutowiredFieldElement)

privateclassAutowiredFieldElementextendsInjectionMetadata.InjectedElement{
@Override
protectedvoidinject(Objectbean,@NullableStringbeanName,@NullablePropertyValuespvs)throwsThrowable{
Fieldfield=(Field)this.member;
Objectvalue;
if(this.cached){
value=resolvedCachedArgument(beanName,this.cachedFieldValue);
}
else{
//专门用于注入的包装类，包装构造函数参数，方法参数或字段
DependencyDescriptordesc=newDependencyDescriptor(field,this.required);
//设置class
desc.setContainingClass(bean.getClass());
//需要被自动注入的beanNames，这里只有可能=1，方法注入时才有可能为多个
SetautowiredBeanNames=newLinkedHashSet<>(1);
Assert.state(beanFactory!=null,"NoBeanFactoryavailable");
TypeConvertertypeConverter=beanFactory.getTypeConverter();//获取类型转换器
try{
//通过beanFactory获取属性对应的值，比如需要调用getBean("b")获取依赖的属性单例，并且通过自动转型转为需要的类型
value=beanFactory.resolveDependency(desc,beanName,autowiredBeanNames,typeConverter);
}
catch(BeansExceptionex){
thrownewUnsatisfiedDependencyException(null,beanName,newInjectionPoint(field),ex);
}
synchronized(this){
if(!this.cached){
if(value!=null||this.required){
this.cachedFieldValue=desc;
//注册依赖，
registerDependentBeans(beanName,autowiredBeanNames);
//因为是属性注入，因此这里只有可能等于1
if(autowiredBeanNames.size()==1){
StringautowiredBeanName=autowiredBeanNames.iterator().next();
if(beanFactory.containsBean(autowiredBeanName)&&
beanFactory.isTypeMatch(autowiredBeanName,field.getType())){
//缓存当前value
this.cachedFieldValue=newShortcutDependencyDescriptor(
desc,autowiredBeanName,field.getType());
}
}
}
else{
this.cachedFieldValue=null;
}
this.cached=true;
}
}
}
if(value!=null){
//通过反射，将value值设置到bean中
ReflectionUtils.makeAccessible(field);
field.set(bean,value);
}
}
}

上方大部分的工作都在做待注入bean的获取以及类型的转换，如果深究下去可以再把spring Ioc讲一遍，但是核心还是getBean(字段)获取到对应bean…我们这里就关心核心的语句，就是这2句

if(value!=null){
//通过反射，将value值设置到bean中
ReflectionUtils.makeAccessible(field);
field.set(bean,value);
}

spring通过反射的方式，调用field的set进行属性的注入

2.2 方法注入(AutowiredMethodElement)

privateclassAutowiredMethodElementextendsInjectionMetadata.InjectedElement{


@Override
protectedvoidinject(Objectbean,@NullableStringbeanName,@NullablePropertyValuespvs)throwsThrowable{
if(checkPropertySkipping(pvs)){
return;
}
//@Autowired标注在方法上
Methodmethod=(Method)this.member;
Object[]arguments;
if(this.cached){
//Shortcutforavoidingsynchronization...
//有缓存
arguments=resolveCachedArguments(beanName);
}
else{
//没缓存，直接获取方法上所有的参数
intargumentCount=method.getParameterCount();
arguments=newObject[argumentCount];
DependencyDescriptor[]descriptors=newDependencyDescriptor[argumentCount];
SetautowiredBeans=newLinkedHashSet<>(argumentCount);
Assert.state(beanFactory!=null,"NoBeanFactoryavailable");
TypeConvertertypeConverter=beanFactory.getTypeConverter();
//循环所有参数
for(inti=0;i< arguments.length; i++) {
     MethodParameter methodParam = newMethodParameter(method,i);
DependencyDescriptorcurrDesc=newDependencyDescriptor(methodParam,this.required);
currDesc.setContainingClass(bean.getClass());
descriptors[i]=currDesc;
try{
//通过beanFactory，获取代注入的bean，并进行类型转换
Objectarg=beanFactory.resolveDependency(currDesc,beanName,autowiredBeans,typeConverter);
if(arg==null&&!this.required){
arguments=null;
break;
}
arguments[i]=arg;
}
catch(BeansExceptionex){
thrownewUnsatisfiedDependencyException(null,beanName,newInjectionPoint(methodParam),ex);
}
}
synchronized(this){
if(!this.cached){
if(arguments!=null){
DependencyDescriptor[]cachedMethodArguments=Arrays.copyOf(descriptors,arguments.length);
//注册依赖
registerDependentBeans(beanName,autowiredBeans);
//如果自动注入的个数=参数个数，则缓存
if(autowiredBeans.size()==argumentCount){
Iteratorit=autowiredBeans.iterator();
Class[]paramTypes=method.getParameterTypes();
for(inti=0;i< paramTypes.length; i++) {
         String autowiredBeanName = it.next();
         if(beanFactory.containsBean(autowiredBeanName)&&
beanFactory.isTypeMatch(autowiredBeanName,paramTypes[i])){
//缓存
cachedMethodArguments[i]=newShortcutDependencyDescriptor(
descriptors[i],autowiredBeanName,paramTypes[i]);
}
}
}
//缓存方法
this.cachedMethodArguments=cachedMethodArguments;
}
else{
this.cachedMethodArguments=null;
}
this.cached=true;
}
}
}
if(arguments!=null){
try{
//反射调用注入方法，将获取到的所有bean作为参数
ReflectionUtils.makeAccessible(method);
method.invoke(bean,arguments);
}
catch(InvocationTargetExceptionex){
throwex.getTargetException();
}
}
}

}

这里与属性注入最大的区别在于，@Autowired注解在方法上，方法可以拥有多个参数，因此这里需要通过循环将一个个获取，而获取bean的方式于上面一样，本质都是通过getBean获取。

而核心语句还是2句

//反射调用注入方法，将获取到的所有bean作为参数
ReflectionUtils.makeAccessible(method);
method.invoke(bean,arguments);

与属性注入不同的是，当@Autowired注解在方法上，例如我们注解在setter方法上，则只需要直接调用该setter方法将参数数组传入即可以，即使用invoke触发方法，具体属性赋值的过程在setter方法中由用户自行编写

原文标题：谈谈 @Autowired 的实现原理

文章出处：【微信公众号：Android编程精选】欢迎添加关注！文章转载请注明出处。

审核编辑：汤梓红