Spring源码解析-AutowiredAnnotationBeanPostProcessor依赖注入

原创
2019/01/10 11:01
阅读数 1.9K

Spring的bean创建流程

当我们对spring深入了解后,我们会发现spring对bean的创建和管理的流程是很清晰的明了的,通过这篇文章了解Spring加载applicationContext.xml,其实spring创建bean的整个流程可以简化成以下几个大流程:

首先,spring会先准备哪些bean是交由它创建的,这就是Spring加载applicationContext.xml这篇文章里面讲到的,加载applicationContext配置文件其实就是为了后续创建实例化bean而做的准备阶段,怎么让spring知道自己要加载和创建哪些bean呢?这是通过spring提供的各个注解来实现,通过Service、Component、Controller等注解以及配置文件里面定义的bean等等方式,spring可以扫描这些bean(当然你要做相应的配置,spring才会去扫描),并为他们准备了后续要创建bean所需要的信息,在spring里叫做definition

其次,当准备阶段做完后,Spring就会开启实例化bean的过程,就是遍历所有的需要初始化的BeanDefinition,然后实例化这些bean,但是实例化bean,实际上里面的属性和方法(注解了@Autowired等注解的)对象是未实例化的,所以当创建了bean之后我们就需要去为这些目标bean里面注入他所需要的实例对象,这就是我们在下面要讲的重点,spring的依赖注入。

最后,实例化完bean之后,就是遍历每个目标bean里面被注解Autowired、Value等注解标识的属性以及方法,然后实例化这些元素,然后依赖注入。

控制反转和依赖注入

在我看来,控制反转和依赖注入是同一种概念,两种的唯一区别就是,控制反转是在理论层面上提出来的,而依赖注入更偏向于实现层面上的,简单来说,依赖注入是控制反转的一种实现形式,并无差别。在Spring中bean的创建就是通过依赖注入的形式实现控制反转的。

Spring的依赖注入的整个流程,首先Spring会遍历所有需要实例化的bean definition,先根据这些definition实例化bean接下来就是为实例化好的bean,这时候我们称该bean为目标bean,为目标bean注入相应的实例对象,这些对象可以通过属性注入和方法注入两种方式来实现。

其次,Spring会找到目标bean里面的所有被Autowired、Value注解的属性和方法,然后执行创建实例化bean操作并返回值;

最后,通过返回的值反射注入到对应的对象,整个流程就结束了。整个流程如下:

AutowiredAnnotationBeanPostProcessor简介

AutowiredAnnotationBeanPostProcessor是BeanPostProcessor的实现类,能够自动装配被注解Autowired、Value注解的属性、setter方法以及配置方法,这些类成员能够被自动的检测到并注入。当然,AutowiredAnnotationBeanPostProcessor还支持JSR-330的Inject注解。简单来讲,AutowiredAnnotationBeanPostProcessor就是个依赖注入的后置处理器。

AutowiredAnnotationBeanPostProcessor只提供一个构造方法,该构造法设置了AutowiredAnnotationBeanPostProcessor处理器能够支持哪些注解,默认情况下支持3种Autowired、Value以及Inject,构造方法如下:

public AutowiredAnnotationBeanPostProcessor() {
		this.autowiredAnnotationTypes.add(Autowired.class);
		this.autowiredAnnotationTypes.add(Value.class);
		try {
			this.autowiredAnnotationTypes.add((Class<? extends Annotation>)
					ClassUtils.forName("javax.inject.Inject", AutowiredAnnotationBeanPostProcessor.class.getClassLoader()));
			logger.info("JSR-330 'javax.inject.Inject' annotation found and supported for autowiring");
		}
		catch (ClassNotFoundException ex) {
			// JSR-330 API not available - simply skip.
		}
	}

当然,AutowiredAnnotationBeanPostProcessor也支持自定义注解的发现,AutowiredAnnotationBeanPostProcessor类提供了两个方法来进行修改,如下:

public void setAutowiredAnnotationType(Class<? extends Annotation> autowiredAnnotationType) {
		Assert.notNull(autowiredAnnotationType, "'autowiredAnnotationType' must not be null");
		this.autowiredAnnotationTypes.clear();
		this.autowiredAnnotationTypes.add(autowiredAnnotationType);
	}

	
	public void setAutowiredAnnotationTypes(Set<Class<? extends Annotation>> autowiredAnnotationTypes) {
		Assert.notEmpty(autowiredAnnotationTypes, "'autowiredAnnotationTypes' must not be empty");
		this.autowiredAnnotationTypes.clear();
		this.autowiredAnnotationTypes.addAll(autowiredAnnotationTypes);
	}

所以,我们还能自定义Spring没有的注解,让AutowiredAnnotationBeanPostProcessor处理器也能自动的装配我们自定义的注解成员变量。

AutowiredAnnotationBeanPostProcessor依赖注入的入口函数

依赖注入是在什么时候执行的?依赖注入的时机是在bean被实例化之后,就会马上执行依赖注入,所以AutowiredAnnotationBeanPostProcessor是在创建bean之后被调用,而调用的入口就是AutowiredAnnotationBeanPostProcessor的一个函数,函数如下:

public PropertyValues postProcessPropertyValues(
		PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeanCreationException {

	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;
}

当bean创建完后就会触发这个后置处理器的方法来执行bean里面的属性和方法的注入流程。参数bean其实就是创建好的要为其注入属性的目标bean,所以注入是在bean创建完后才执行的。但是在该方法被调用之前,还有一个方法会先被调用,这个方法就是postProcessMergedBeanDefinition,该方法的作用其实比较简单,就是为了缓存下后续需要用到数据,其实他的代码和上面的代码很像,如下:

@Override
public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
	if (beanType != null) {
		InjectionMetadata metadata = findAutowiringMetadata(beanName, beanType, null);
		metadata.checkConfigMembers(beanDefinition);
	}
}

是不是很像,都调用了findAutowiringMetadata方法,但是并为执行依赖注入的操作。而findAutowiringMetadata这个方法是有缓存的处理的,所以重复调用的话是直接从缓存获取数据,加快注入的效率。

查找目标类的注入属性及方法

接下来我们继续讨论findAutowiringMetadata这个方法,这个方法其实就是去查找被Autowired、Value注解的所有属性和方法,当然包括了目标类的所有父类都会去查找,所以查找的过程其实是个递归的过程。找到所有的成员后,会执行注入元数据对象的创建即实例化InjectionMetadata对象并返回。我们来看下它的代码:

private InjectionMetadata findAutowiringMetadata(String beanName, Class<?> clazz, PropertyValues pvs) {
	// 获取bean的缓存key.
	String cacheKey = (StringUtils.hasLength(beanName) ? beanName : clazz.getName());
	// 根据key获取缓存里面的依赖元数据
	InjectionMetadata metadata = this.injectionMetadataCache.get(cacheKey);
	if (InjectionMetadata.needsRefresh(metadata, clazz)) {
		synchronized (this.injectionMetadataCache) {
			metadata = this.injectionMetadataCache.get(cacheKey);
			if (InjectionMetadata.needsRefresh(metadata, clazz)) {
				if (metadata != null) {
					metadata.clear(pvs);
				}
				try {
					//创建依赖对象的元数据
					metadata = buildAutowiringMetadata(clazz);
					//放到缓存里面
					this.injectionMetadataCache.put(cacheKey, metadata);
				}
				catch (NoClassDefFoundError err) {
					throw new IllegalStateException("Failed to introspect bean class [" + clazz.getName() +
							"] for autowiring metadata: could not find class that it depends on", err);
				}
			}
		}
	}
	return metadata;
}

从源代码可以看出,查找的过程经过了缓存的处理,依赖注入的元数据创建完后都会put进去injectionMetadataCache这个map里面管理,下次进来的key如果是一样的话并存在于map里面就不会执行创建而是直接取缓存里面获取。那Spring到底是怎么样创建InjectionMetadata对象的,还有InjectionMetadata里面有什么内容,让我们继续来看,首先我们看下InjectionMetadata这个类具体如下:

InjectionMetadata的结构图

这里面我们关注几个属性:

  1. injectedElements属性;

    所有的注入对象,包括属性、setter方法以及配置方法都会被扫描到并保存到这个集合中。InjectedElement有两种实现分别是:AutowiredFieldElement和AutowiredMethodElement,从名字可以看出一种是对field的包装一种是对method的包装。

  2. inject(Object target, String beanName, PropertyValues pvs)方法;

    遍历上面的injectedElements集合调用元素的注入方法其实是调用各自的具体的实现类的inject方法执行注入操作,代码如下:

    public void inject(Object target, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
	//需要执行依赖的filed和method元素
	Collection<InjectedElement> checkedElements = this.checkedElements;
	Collection<InjectedElement> elementsToIterate =
			(checkedElements != null ? checkedElements : this.injectedElements);
	if (!elementsToIterate.isEmpty()) {
		for (InjectedElement element : elementsToIterate) {
			if (logger.isTraceEnabled()) {
				logger.trace("Processing injected element of bean '" + beanName + "': " + element);
			}
			//注入到目标bean中
			element.inject(target, beanName, pvs);
		}
	}
}

所以,buildAutowiringMetadata这个方法其实是完成了metadata的创建工作。

实例化需要注入的对象

我们以InjectedElement的一个实现类来解析依赖注入的操作,这个类就是上面提到的AutowiredFieldElement,这个类主要是非方法的属性的注入操作,我们直接看它重载了inject方法如下:

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<String> autowiredBeanNames = new LinkedHashSet<String>(1);
		TypeConverter typeConverter = beanFactory.getTypeConverter();
		try {
			//解析依赖对象并返回value对象
			value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);
		}
		catch (BeansException ex) {
			throw new UnsatisfiedDependencyException(null, beanName, new InjectionPoint(field), ex);
		}
		synchronized (this) {
			if (!this.cached) {
				if (value != null || this.required) {
					this.cachedFieldValue = desc;
					registerDependentBeans(beanName, autowiredBeanNames);
					if (autowiredBeanNames.size() == 1) {
						String autowiredBeanName = autowiredBeanNames.iterator().next();
						if (beanFactory.containsBean(autowiredBeanName)) {
							if (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);
	}
}

这个方法做了3个流程,第一个流程是去创建依赖对象,通过value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);这句实现,第二个就是将返回的值做缓存处理;第三个就是反射set值。很明显依赖bean的实例化是在resolveDependency里面去完成的,接下来我们继续看这个方法到底是怎么完成bean的创建的,在resolveDependency里面会去调用doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter)这个方法,而这个方法就是依赖bean的主流程,这里面会去创建bean的操作,代码如下,我们来看下这里面的具体实现:

public Object doResolveDependency(DependencyDescriptor descriptor, String beanName,
		Set<String> autowiredBeanNames, TypeConverter typeConverter) throws BeansException {

	InjectionPoint previousInjectionPoint = ConstructorResolver.setCurrentInjectionPoint(descriptor);
	try {
		//捷径方式获取对象实例
		Object shortcut = descriptor.resolveShortcut(this);
		if (shortcut != null) {
			return shortcut;
		}

		Class<?> type = descriptor.getDependencyType();
		//获取@Value注解的field
		Object value = getAutowireCandidateResolver().getSuggestedValue(descriptor);
		if (value != null) {
			if (value instanceof String) {
				String strVal = resolveEmbeddedValue((String) value);
				BeanDefinition bd = (beanName != null && containsBean(beanName) ? getMergedBeanDefinition(beanName) : null);
				value = evaluateBeanDefinitionString(strVal, bd);
			}
			TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
			return (descriptor.getField() != null ?
					converter.convertIfNecessary(value, type, descriptor.getField()) :
					converter.convertIfNecessary(value, type, descriptor.getMethodParameter()));
		}
		//其他非value,依赖注入集合实例等
		Object multipleBeans = resolveMultipleBeans(descriptor, beanName, autowiredBeanNames, typeConverter);
		//不为空则返回
		if (multipleBeans != null) {
			return multipleBeans;
		}
		//找到候选的依赖注入实例对象
		Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);
		if (matchingBeans.isEmpty()) {
			if (isRequired(descriptor)) {
				raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
			}
			return null;
		}

		String autowiredBeanName;
		Object instanceCandidate;
		//匹配到多个,则会决策哪个会被依赖注入进来,优先级高或者被注解@primary注解的类优先注入
		if (matchingBeans.size() > 1) {
			autowiredBeanName = determineAutowireCandidate(matchingBeans, descriptor);
			if (autowiredBeanName == null) {
				if (isRequired(descriptor) || !indicatesMultipleBeans(type)) {
					return descriptor.resolveNotUnique(type, 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).
					return null;
				}
			}
			instanceCandidate = matchingBeans.get(autowiredBeanName);
		}
		else {
			// We have exactly one match.
			Map.Entry<String, Object> entry = matchingBeans.entrySet().iterator().next();
			autowiredBeanName = entry.getKey();
			instanceCandidate = entry.getValue();
		}

		if (autowiredBeanNames != null) {
			autowiredBeanNames.add(autowiredBeanName);
		}
		return (instanceCandidate instanceof Class ?
				descriptor.resolveCandidate(autowiredBeanName, type, this) : instanceCandidate);
	}
	finally {
		ConstructorResolver.setCurrentInjectionPoint(previousInjectionPoint);
	}
}

首先,会先判断这个对象是不是@Value注解的,如果是就是去执行value解析,解析出value的值直接返回,如下就是value的处理:

Object value = getAutowireCandidateResolver().getSuggestedValue(descriptor);
if (value != null) {
	if (value instanceof String) {
		String strVal = resolveEmbeddedValue((String) value);
		BeanDefinition bd = (beanName != null && containsBean(beanName) ? getMergedBeanDefinition(beanName) : null);
		value = evaluateBeanDefinitionString(strVal, bd);
	}
	TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
	return (descriptor.getField() != null ?
			converter.convertIfNecessary(value, type, descriptor.getField()) :
			converter.convertIfNecessary(value, type, descriptor.getMethodParameter()));
}

如果不是@Value的话,那么就进入到解析bean的过程,下面这个是解析多重bean的,即依赖注入的是个集合

Object multipleBeans = resolveMultipleBeans(descriptor, beanName, autowiredBeanNames, typeConverter);
if (multipleBeans != null) {
	return multipleBeans;
}

接着如果不是多重bean对象,则会去匹配单个的bean:

Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);

如果匹配到多个的话就会通过一种策略(如优先级或者注解primary)去决策哪个bean来注入。找到了bean definition后,如果是个Class的话就会去执行创建bean的操作,又重新来一次bean创建流程不停的递归直到所有对象都创建完毕了就直接返回该实例对象。创建bean其实是下面这句代码做的:

descriptor.resolveCandidate(autowiredBeanName, type, this)

其实这里面的实现很简单就是调用beanFactory的getbean方法去实例化bean,如下:

public Object resolveCandidate(String beanName, Class<?> requiredType, BeanFactory beanFactory)
		throws BeansException {

	return beanFactory.getBean(beanName, requiredType);
}

getBean里面又会执行bean的实例化,bean实例化后又会执行依赖注入流程,这样递归直到所有的依赖bean都创建实例完后,才返回最外层的bean并执行最外层的依赖注入,通过反射注入到目标bean里面。至此整个依赖注入流程就完成了。

展开阅读全文
打赏
1
0 收藏
分享
加载中
更多评论
打赏
0 评论
0 收藏
1
分享
在线直播报名
返回顶部
顶部