文档章节

Spring 源码(九)@Autowired注解实现原理(Spring Bean的自动装配)

x
?xiaolyuh
发布于 10/01 16:48
字数 2389
阅读 1333
收藏 18

@Autowired注解的实现过程,其实就是Spring Bean的自动装配过程。通过看@Autowired源码注释部分我们可以看到@Autowired的实现是通过AutowiredAnnotationBeanPostProcessor后置处理器中实现的。

AutowiredAnnotationBeanPostProcessor 类图

  • PriorityOrdered:确认 AutowiredAnnotationBeanPostProcessor 后置处理器的执行优先级
  • BeanFactoryAware:使得AutowiredAnnotationBeanPostProcessor 可以直接通过BeanFactory获取容器中的Bean
  • BeanPostProcessor:在 Bean 初始化前后执行的后置处理器
  • InstantiationAwareBeanPostProcessor:在 Bean 实例化前后和Bean设置属性值时执行的后置处理器
  • SmartInstantiationAwareBeanPostProcessor:智能实例化Bean的后处理器,如预测Bean的类型和确认Bean的构造函数等。
  • MergedBeanDefinitionPostProcessor:合并Bean的定义信息。

在分析自动装配前我们先来介绍一下上面的这些后置处理器。

后置处理器介绍

BeanPostProcessor

BeanPostProcessor有两个方法,postProcessBeforeInitializationpostProcessAfterInitialization。它们分别在任何bean初始化回调之前或之后执行(例如InitializingBean的afterPropertiesSet方法或自定义init-method方法之前或者之后), 在这个时候该bean的属性值已经填充完成了,并且我们返回的bean实例可能已经是原始实例的包装类型了。例如返回一个FactoryBean

InstantiationAwareBeanPostProcessor

InstantiationAwareBeanPostProcessor继承自BeanPostProcessor接口。主要多提供了以下三个方法。

postProcessBeforeInstantiation

该方法是在Bean实例化目标对象之前调用,返回的Bean对象可以代理目标,从而有效的阻止了目标Bean的默认实例化。

protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
	Object bean = null;
	if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
		// Make sure bean class is actually resolved at this point.
		if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
			Class targetType = determineTargetType(beanName, mbd);
			if (targetType != null) {
				bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
				if (bean != null) {
					// 如果此方法返回一个非null对象,则Bean创建过程将被短路。
					// 唯一应用的进一步处理是来自已配置BeanPostProcessors的postProcessAfterInitialization回调
					bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
				}
			}
		}
		mbd.beforeInstantiationResolved = (bean != null);
	}
	return bean;
}

protected Object applyBeanPostProcessorsBeforeInstantiation(Class beanClass, String beanName) {
	for (BeanPostProcessor bp : getBeanPostProcessors()) {
		if (bp instanceof InstantiationAwareBeanPostProcessor) {
			InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
			// 执行Bean实例化目标对象之前的后置处理方法
			Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
			if (result != null) {
				return result;
			}
		}
	}
	return null;
}

跟进源码我们可以看出,如果此方法返回一个非null对象,则Bean创建过程将被短路。唯一应用的进一步处理是来自已配置BeanPostProcessors的postProcessAfterInitialization回调。

postProcessAfterInstantiation

该方法执行在通过构造函数或工厂方法在实例化bean之后但在发生Spring属性填充(通过显式属性或自动装配)之前执行操作。这是在Spring的自动装配开始之前对给定的bean实例执行自定义字段注入的理想回调。如果该方法返回false,那么它会阻断后续InstantiationAwareBeanPostProcessor后置处理器的执行,并且会阻止后续属性填充的执行逻辑。

postProcessPropertyValues

在工厂将给定属性值应用于给定bean之前,对它们进行后处理。允许检查是否满足所有依赖关系,例如基于bean属性设置器上的“ Required”注解。还允许替换要应用的属性值,通常是通过基于原始PropertyValues创建新的MutablePropertyValues实例,添加或删除特定值来实现。

SmartInstantiationAwareBeanPostProcessor

智能实例化Bean的后处理器,主要提供了三个方法。

predictBeanType

预测从此处理器的postProcessBeforeInstantiation回调最终返回的bean的类型。

determineCandidateConstructors

确定使用实例化Bean的构造函数。

getEarlyBeanReference

获取提早暴露的Bean的引用,提早暴露的Bean就是只完成了实例化,还未完成属性赋值和初始化的Bean。

MergedBeanDefinitionPostProcessor

postProcessMergedBeanDefinition

合并Bean的定义信息的后处理方法,该方法是在Bean的实例化之后设置值之前调用。

自动装配的实现

找到需要自动装配的元素

AutowiredAnnotationBeanPostProcessor后置处理器主要负责对添加了@Autowired和@Value注解的元素实现自动装配。所以找到需要自动装配的元素,其实就是对@Autowired和@Value注解的解析。

AutowiredAnnotationBeanPostProcessor后置处理器,找出需要自动装配的元素是在MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition这个方法中实现的,调用链路如下:

doWith:445, AutowiredAnnotationBeanPostProcessor$2 (org.springframework.beans.factory.annotation)
doWithLocalFields:657, ReflectionUtils (org.springframework.util)
buildAutowiringMetadata:433, AutowiredAnnotationBeanPostProcessor (org.springframework.beans.factory.annotation)
findAutowiringMetadata:412, AutowiredAnnotationBeanPostProcessor (org.springframework.beans.factory.annotation)
postProcessMergedBeanDefinition:235, AutowiredAnnotationBeanPostProcessor (org.springframework.beans.factory.annotation)
applyMergedBeanDefinitionPostProcessors:1000, AbstractAutowireCapableBeanFactory (org.springframework.beans.factory.support)
doCreateBean:523, AbstractAutowireCapableBeanFactory (org.springframework.beans.factory.support)
createBean:483, AbstractAutowireCapableBeanFactory (org.springframework.beans.factory.support)
getObject:312, AbstractBeanFactory$1 (org.springframework.beans.factory.support)
getSingleton:230, DefaultSingletonBeanRegistry (org.springframework.beans.factory.support)
doGetBean:308, AbstractBeanFactory (org.springframework.beans.factory.support)
getBean:197, AbstractBeanFactory (org.springframework.beans.factory.support)
preInstantiateSingletons:761, DefaultListableBeanFactory (org.springframework.beans.factory.support)
finishBeanFactoryInitialization:867, AbstractApplicationContext (org.springframework.context.support)
refresh:543, AbstractApplicationContext (org.springframework.context.support)
:84, AnnotationConfigApplicationContext (org.springframework.context.annotation)

从链路上我们可以看到,找到需要自动装配的元素是在findAutowiringMetadata方法中实现的,该方法会去调用buildAutowiringMetadata方法构建元数据信息。如果注解被加载属性上将会被封装成AutowiredFieldElement对象;如果注解加在方法上,那么元素会被封装成AutowiredMethodElement对象。这里两个对象的inject方法将最后完成属性值的注入,主要区别就是使用反射注入值的方式不一样。源码如下:

private InjectionMetadata buildAutowiringMetadata(final Class clazz) {
	LinkedList elements = new LinkedList();
	Class targetClass = clazz;

	do {
		// 存放我们找到的元数据信息
		final LinkedList currElements =
				new LinkedList();
		
		// 通过反射找出对应Class对象的所有Field
		ReflectionUtils.doWithLocalFields(targetClass, new ReflectionUtils.FieldCallback() {
			@Override
			public void doWith(Field field) throws IllegalArgumentException, IllegalAccessException {
				// 通过反射找到该字段上所有的注解信息,并判断是否有@Autowired和@Value注解,如果有就将该字段封成AutowiredFieldElement对象
				AnnotationAttributes ann = findAutowiredAnnotation(field);
				if (ann != null) {
					if (Modifier.isStatic(field.getModifiers())) {
						if (logger.isWarnEnabled()) {
							logger.warn("Autowired annotation is not supported on static fields: " + field);
						}
						return;
					}
					boolean required = determineRequiredStatus(ann);、
					// 将该字段封成AutowiredFieldElement对象,并放到缓存中
					currElements.add(new AutowiredFieldElement(field, required));
				}
			}
		});

		// 通过反射找出对应Class对象的所有Method
		ReflectionUtils.doWithLocalMethods(targetClass, new ReflectionUtils.MethodCallback() {
			@Override
			public void doWith(Method method) throws IllegalArgumentException, IllegalAccessException {
				Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);
				if (!BridgeMethodResolver.isVisibilityBridgeMethodPair(method, bridgedMethod)) {
					return;
				}
				// 通过反射找到该字段上所有的注解信息,并判断是否有@Autowired和@Value注解,如果有就将该字段封成AutowiredMethodElement对象
				AnnotationAttributes ann = findAutowiredAnnotation(bridgedMethod);
				if (ann != null && method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) {
					if (Modifier.isStatic(method.getModifiers())) {
						if (logger.isWarnEnabled()) {
							logger.warn("Autowired annotation is not supported on static methods: " + method);
						}
						return;
					}
					if (method.getParameterTypes().length == 0) {
						if (logger.isWarnEnabled()) {
							logger.warn("Autowired annotation should only be used on methods with parameters: " +
									method);
						}
					}
					boolean required = determineRequiredStatus(ann);
					PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
					// 将该字段封成AutowiredMethodElement对象
					currElements.add(new AutowiredMethodElement(method, required, pd));
				}
			}
		});

		elements.addAll(0, currElements);
		targetClass = targetClass.getSuperclass();
	}
	// 循环处理父类需要自动装配的元素
	while (targetClass != null && targetClass != Object.class);
	// 将需要自动装配的元素封装成InjectionMetadata对象,最后合并到Bean定义中
	return new InjectionMetadata(clazz, elements);
}

寻找需要自动装配过程:

  1. 根据Class对象,通过反射获取所有的Field和```Method````对象
  2. 通过反射获取FieldMethod上的注解,并判断是否有@Autowired和@Value注解
  3. 将注解了@Autowired和@Value的FieldMethod封装成AutowiredFieldElementAutowiredMethodElement对象,等待下一步的自动装配。
  4. 循环处理父类需要自动装配的元素
  5. 将需要自动装配的元素封装成InjectionMetadata对象,最后合并到Bean定义的externallyManagedConfigMembers属性中

注入属性值

AutowiredAnnotationBeanPostProcessor后置处理器注入属性值是在postProcessPropertyValues方法中实现的。源码如下:

public void inject(Object target, String beanName, PropertyValues pvs) throws Throwable {
	// 获取需要自动装配的元数据信息(这里实在缓存中取)
	Collection elementsToIterate =
			(this.checkedElements != null ? this.checkedElements : this.injectedElements);
	if (!elementsToIterate.isEmpty()) {
		boolean debug = logger.isDebugEnabled();
		for (InjectedElement element : elementsToIterate) {
			if (debug) {
				logger.debug("Processing injected element of bean '" + beanName + "': " + element);
			}
			// 调用AutowiredFieldElement或AutowiredMethodElement对象的inject方法注入属性值
			element.inject(target, beanName, pvs);
		}
	}
}

AutowiredFieldElement#inject

@Override
protected void inject(Object bean, String beanName, PropertyValues pvs) throws Throwable {
	Field field = (Field) this.member;
	Object value;
	if (this.cached) {
		value = resolvedCachedArgument(beanName, this.cachedFieldValue);
	}
	else {
		DependencyDescriptor desc = new DependencyDescriptor(field, this.required);
		desc.setContainingClass(bean.getClass());
		Set autowiredBeanNames = new LinkedHashSet(1);
		TypeConverter typeConverter = beanFactory.getTypeConverter();
		try {
			// 在容器中获取需要装配的Bean
			value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);
		}
		...
	}
	if (value != null) {
		// 通过反射设置属性值
		ReflectionUtils.makeAccessible(field);
		field.set(bean, value);
	}
}

AutowiredMethodElement#inject

@Override
protected void inject(Object bean, String beanName, PropertyValues pvs) throws Throwable {
	if (checkPropertySkipping(pvs)) {
		return;
	}
	Method method = (Method) this.member;
	Object[] arguments;
	if (this.cached) {
		// Shortcut for avoiding synchronization...
		arguments = resolveCachedArguments(beanName);
	}
	else {
		Class[] paramTypes = method.getParameterTypes();
		arguments = new Object[paramTypes.length];
		DependencyDescriptor[] descriptors = new DependencyDescriptor[paramTypes.length];
		Set autowiredBeans = new LinkedHashSet(paramTypes.length);
		TypeConverter typeConverter = beanFactory.getTypeConverter();
		for (int i = 0; i < arguments.length; i++) {
			MethodParameter methodParam = new MethodParameter(method, i);
			DependencyDescriptor currDesc = new DependencyDescriptor(methodParam, this.required);
			currDesc.setContainingClass(bean.getClass());
			descriptors[i] = currDesc;
			try {
				// 在容器中获取需要装配的Bean
				Object arg = beanFactory.resolveDependency(currDesc, beanName, autowiredBeans, typeConverter);
				if (arg == null && !this.required) {
					arguments = null;
					break;
				}
				arguments[i] = arg;
			}
			catch (BeansException ex) {
				throw new UnsatisfiedDependencyException(null, beanName, new InjectionPoint(methodParam), ex);
			}
		}
		...
	}
	if (arguments != null) {
		try {
			// 通过反射调用方法设置元素值
			ReflectionUtils.makeAccessible(method);
			method.invoke(bean, arguments);
		}
		...
	}
}

从这里的源码我们可以看出AutowiredFieldElementAutowiredMethodElement完成自动装配都是先去容器中找对应的Bean,然后通过反射将获取到的Bean设置到目标对象中,来完成Bean的自动装配。

总结

我们可以看出Spring Bean的自动装配过程就是:

  1. 根据Class对象,通过反射获取所有的FieldMethod信息
  2. 通反射获取FieldMethod的注解信息,并根据注解类型,判断是否需要自动装配
  3. 将需要自动装配的元素,封装成AutowiredFieldElementAutowiredMethodElement对象
  4. 调用AutowiredFieldElementAutowiredMethodElementinject方法,唤起后续步骤
  5. 通过调用容器的getBean()方法找到需要注入的源数据Bean
  6. 通过反射将找到的源数据Bean注入到目标Bean中

在自动装配过程中还涉及循环依赖的问题,有兴趣的可以看下这篇文章Spring 源码(八)循环依赖

注意:注解注入将在XML注入之前执行;因此,对于通过这两种方法注入的属性,XML注入将覆盖注解注入。

? 着作权归作者所有

x

xiaolyuh

粉丝 60
博文 124
码字总数 198522
作品 1
成都
高级程序员
私信 提问
加载中

评论(2)

x
xiaolyuh 博主
??
朱文波
朱文波
package net.helpsd.cg;

import android.os.Bundle;
import android.preference.PreferenceActivity;
import android.preference.PreferenceFragment;
import java.util.List;

public class SettingsActivity extends PreferenceActivity {
public static class GeneralFragment extends PreferenceFragment {
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
addPreferencesFromResource(R.xml.pref_header_general);
}
}

@Override
public void onBuildHeaders(List
target) {
loadHeadersFromResource(R.xml.pref_settings, target);
}
@Override
protected boolean isValidFragment(String fragmentName) {
boolean ret = PreferenceFragment.class.getName().equals(fragmentName);
ret = ret || GeneralFragment.class.getName().equals(fragmentName);
return ret;
}
}
《Spring5学习》 01 装配Bean之自动化装配

Spring的自动化装配就便利性方面远远优于其他装配方法,这也是业界目前主要采用的Bean装配机制。Spring基于组建扫描和自动装配实现自动化装配,能将用户的显示配置降到最低。以下通过一段代码...

老韭菜
2018/08/05
118
0
【Spring】Autowiredd原理及与Resource注解区别

Autowired注解 Autowired顾名思义,表示自动注入,如下是Autowired注解的源代码: 从Autowired的实现可以看到,Autowired可以用于类的构造方法,类的字段,类的方法以及注解类型上,但是Aut...

weknow
2018/03/06
657
0
Spring_总结_03_装配Bean之自动装配

一、前言 本文承接上一节:Spring总结02_依赖注入 在上一节我们了解到依赖注入的实质就是装配。 这一节我们来学习下装配Bean的相关知识。 二、Bean的装配机制 1.三种装配机制 Spring提供了三...

shirayner
2018/07/27
0
0
详解Java的Spring框架中的注解的用法

使用Spring注解来注入属性 1.1. 使用注解以前我们是怎样注入属性的 类的实现: 配置文件: 1.2. 引入@Autowired注解(不推荐使用,建议使用@Resource) 类的实现(对成员变量进行标注) 或者...

Airship
2018/04/22
85
1
spring自动装配优先级处理

spring版本5.0.4 spring的自动装配 我们一般通过加注解的方式来实现,@Resource 或者@Autowired。处理自动装配的类为DefaultListableBeanFactory,部分源码如下: @Nullablepublic Object doR...

额去看看
2018/10/11
217
0

没有更多内容

加载失败,请刷新页面

加载更多

快速排序例子

package helloclean.basetest;import java.util.Scanner;public class QuickSortTest { int[] a = new int[101]; int n; public void quickSort(int left, int righ......

clean123
30分钟前
6
0
小程序的一个tab切换

tab-hd01

前端老手
38分钟前
7
0

十二句你应该掌握的英语口语表达,让你不再和老外尬聊,建议收藏

英语中的"俚语"就如同我们日常生活中常用的"非正式口语"一样,虽然光看单词你可以了解他的字面意思,但是如果套用到日常用语中,就很难让人理解。所以要想和老外流畅的交流,你必须要掌握这些...

翻译君
今天
6
0
Android 自定义scheme及多端唤起使用方法

前言 DeepLink,深度链接技术,类似于web开发领域不仅仅是通过链接打开一个界面,而是打开界面的某个具体内容。常用于web端唤起app时,传递参数直接打开确定的界面,如通过京东的分享出去的商...

所谓向日葵族
今天
5
0
云南如今的人证核验访客多用在商业,为什么?

如今的人证核验多用于商业,这是为何?因为它的场合应用不可思议—— 伴随技术的发展,又一个新的名词与人脸识别在了一起,那就是“检测”,随着人脸识别技术的广泛商用,逐渐形成了自动识别...

非思丸智能
今天
3
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部