Spring 源码阅读 :AutowiredAnnotationBeanPostProcessor 分析(上)

概述

在 AnnotationConfigApplicationContext 上下文初始化的时候,会初始化一个 AnnotatedBeanDefinitionReader 类型的成员变量,在此期间,会通过 AnnotationConfigUtils 类中的​​registerAnnotationConfigProcessors​​方法,注册一些与注解配置相关的处理器。ConfigurationClassPostProcessor 就是其中之一。

本文通过阅读源码的方式,分析在这里注册的另外一个重要的处理器 AutowiredAnnotationBeanPostProcessor。

AutowiredAnnotationBeanPostProcessor 分析

先看 AutowiredAnnotationBeanPostProcessor 类的继承关系。

Spring 源码阅读 :AutowiredAnnotationBeanPostProcessor 分析(上)

可以看出,它是一个 BeanPostProcessor,也就是 Bean 的后处理器。它还实现了一些 BeanPostProcessor 的字接口,BeanPostProcessor 和它的字接口中的方法,会在 Bean 实例初始化的过程中某些特定的时机被调用。所以,我们顺便了解一下这几个接口中包含的方法。

Spring 源码阅读 :AutowiredAnnotationBeanPostProcessor 分析(上)

这里大概介绍一下其中一些关键方法的调用时机。

  • BeanPostProcessor
  • ​postProcessBeforeInitialization​​ 在 Bean 实例的初始化方法执行前被调用。
  • ​postProcessAfterInitialization​​ 在 Bean 实例的初始化方法执行后被调用。
  • MergedBeanDefinitionPostProcessor
  • ​postProcessMergedBeanDefinition​​ 在通过​​doCreateBean​​使用反射机制创建 Bean 实例之后调用。
  • InstantiationAwareBeanPostProcessor
  • ​postProcessBeforeInstantiation​​ 在​​doCreateBean​​执行前自定义 Bean 实例创建的扩展点。
  • ​postProcessAfterInstantiation​​ 在​​postProcessBeforeInstantiation​​创建 Bean 实例不为空的情况下对 Bean 实例进行处理。
  • ​postProcessProperties​​ 在装配 Bean 实例的属性前对属性进行处理。
  • SmartInstantiationAwareBeanPostProcessor
  • ​getEarlyBeanReference​​ 用于在早期 Bean 实例被获取之前对其进行处理。
  • ​determineCandidateConstructors​​ 用于在通过反射创建 Bean 实例是获取候选的构造函数。

再结合前面的类关系图,可以知道 AutowiredAnnotationBeanPostProcessor 对这些方法的实现,都可以从它本身和它的父类 InstantiationAwareBeanPostProcessorAdapter 中找到。在这两个类中,大部分的方法都继承了接口的默认实现,除了​​determineCandidateConstructors、postProcessMergedBeanDefinition​​、​​postProcessProperties​​三个方法。下面以这三个方法被调用的时机为顺序,分析这三个方法都做了什么。

​determineCandidateConstructors​​方法分析

首先我们来分析​​determineCandidateConstructors​​方法,这个方法被调用的时机,是 Spring 通过反射创建 Bean 实例对象的时候,会通过这个方法来获取候选的构造方法。我们查看方法的源码。

Spring 源码阅读 :AutowiredAnnotationBeanPostProcessor 分析(上)

代码量相当可观,我们接下来会挑重点分析。

在第一个​​if​​语句块中,处理了​​@``Lookup​​注解相关的逻辑,这一部分不太重要,也很少会用到,因此不过介绍,我们重点看后面的部分。

// Quick check on the concurrent map first, with minimal locking.
Constructor<?>[] candidateConstructors = this.candidateConstructorsCache.get(beanClass);
if (candidateConstructors == null) {
// Fully synchronized resolution now...
synchronized (this.candidateConstructorsCache) {
candidateConstructors = this.candidateConstructorsCache.get(beanClass);
if (candidateConstructors == null) {
// 省略语句块中的代码
}
}
}
return (candidateConstructors.length > 0 ? candidateConstructors : null);

首先,会从缓存集合candidateConstructorsCache中查询候选构造方法数组,如果缓存中获取的值不为空,则返回数组(数组中有元素)或者空(数组中没有元素)。另外,在​​if​​语句块中,还会在​​synchronized​​语句块中再次判断一遍。

确保缓存中确实没有内容的情况下,进入之后的流程。也就是上述代码中被省略的部分。

Constructor<?>[] rawCandidates;
try {
rawCandidates = beanClass.getDeclaredConstructors();
}
catch (Throwable ex) {
throw new BeanCreationException(beanName,
"Resolution of declared constructors on bean Class [" + beanClass.getName() +
"] from ClassLoader [" + beanClass.getClassLoader() + "] failed", ex);
}

首先,会从当前 Bean 的类型中,获取到所有的构造方法,放到提前声明好的​​rawCandidates​​数组中。

List<Constructor<?>> candidates = new ArrayList<>(rawCandidates.length);
Constructor<?> requiredConstructor = null;
Constructor<?> defaultConstructor = null;
Constructor<?> primaryConstructor = BeanUtils.findPrimaryConstructor(beanClass);
int nonSyntheticConstructors = 0;

然后声明了一系列的变量,供后续的流程使用。这里的​​primaryConstructor​​主要是针对 Kotlin 的,如果是 Kotlin 类型,则会返回其主构造方法对应的 Java 构造方法,如果是 Java 类型,则为空。这里可以通过​​findPrimaryConstructor​​方法来看一下。

@Nullable
public static <T> Constructor<T> findPrimaryConstructor(Class<T> clazz) {
Assert.notNull(clazz, "Class must not be null");
if (KotlinDetector.isKotlinReflectPresent() && KotlinDetector.isKotlinType(clazz)) {
Constructor<T> kotlinPrimaryConstructor = KotlinDelegate.findPrimaryConstructor(clazz);
if (kotlinPrimaryConstructor != null) {
return kotlinPrimaryConstructor;
}
}
return null;
}

回到之前的方法中,之后开始对​​rawCandidates​​中的构造方法进行遍历。

for (Constructor<?> candidate : rawCandidates) {
// ...
}

接下来看​​for​​循环语句块中的内容。

if (!candidate.isSynthetic()) {
nonSyntheticConstructors++;
}
else if (primaryConstructor != null) {
continue;
}

首先判断了当前的构造方法是不是「合成」的构造方法,不是的话​​nonSyntheticConstructors​​变量自增,如果是,且​​primaryConstructor​​不是空,则跳过档次循环。

MergedAnnotation<?> ann = findAutowiredAnnotation(candidate);
if (ann == null) {
Class<?> userClass = ClassUtils.getUserClass(beanClass);
if (userClass != beanClass) {
try {
Constructor<?> superCtor =
userClass.getDeclaredConstructor(candidate.getParameterTypes());
ann = findAutowiredAnnotation(superCtor);
}
catch (NoSuchMethodException ex) {
// Simply proceed, no equivalent superclass constructor found...
}
}
}

这一步是为了获取构造方法上的​​@``Autowired​​注解,不仅会从当前的构造方法上查找,如果当前的类是CGLIB代理类型,还会从其​​userClass​​,也就是用户声明的类中查找。

如果当前的构造方法没有被标记​​@``Autowired​​注解,则​​ann​​变量为空,反之则不为空。获取完成之后,会进入一个​​if-else​​语句,针对​​ann​​是否为空的情况,执行不同的流程。

if (ann != null) {
if (requiredConstructor != null) {
throw new BeanCreationException(beanName,
"Invalid autowire-marked constructor: " + candidate +
". Found constructor with 'required' Autowired annotation already: " +
requiredConstructor);
}
boolean required = determineRequiredStatus(ann);
if (required) {
if (!candidates.isEmpty()) {
throw new BeanCreationException(beanName,
"Invalid autowire-marked constructors: " + candidates +
". Found constructor with 'required' Autowired annotation: " +
candidate);
}
requiredConstructor = candidate;
}
candidates.add(candidate);
}

如果​​ann​​不为空,则进入以上的代码块中。首先会通过其中的第一个​​if​​语句判断​​requiredConstructor​​是否为空,如果不是空的话会抛出异常。当循环第一次走到这里的时候,它一定是空的,我们接着往下看。

接下来会判断当前构造方法的​​@``Autowired​​注解的​​required​​属性是否为​​true​​。如果是true的话,则会进入下一个​​if​​语句块。因为如果有构造方法的​​@``Autowired​​注解的​​required​​属性是否为​​true​​的时候,被注解标记的构造方法只能有一个,所以,如果当前的构造方法如果符合条件,但是​​candidates​​不为空,则会抛出异常。确保没有异常之后,会将当前的构造方法赋值给​​requiredConstructor​​变量。

最后,只要当前的构造方法被标记了​​@``Autowired​​注解,都会被添加到​​candidates​​集合中。

如果当前的构造方法没有被标记​​@``Autowired​​注解,且构造方法是无参构造方法,则将其赋值给​​defaultConstructor​​变量。

else if (candidate.getParameterCount() == 0) {
defaultConstructor = candidate;
}

至此,遍历所有构造方法的​​for​​循环就执行完了。接下来会进入一系列的条件判断语句,它们的主要作用是对之前遍历过程中得到的结果进行处理。

if (!candidates.isEmpty()) {
// Add default constructor to list of optional constructors, as fallback.
if (requiredConstructor == null) {
if (defaultConstructor != null) {
candidates.add(defaultConstructor);
}
else if (candidates.size() == 1 && logger.isInfoEnabled()) {
logger.info("Inconsistent constructor declaration on bean with name '" + beanName +
"': single autowire-marked constructor flagged as optional - " +
"this constructor is effectively required since there is no " +
"default constructor to fall back to: " + candidates.get(0));
}
}
candidateConstructors = candidates.toArray(new Constructor<?>[0]);
}

如果​​candidates​​不为空,也就是存在被标记​​@``Autowired​​注解的构造方法,则进入当前的语句块。

再次判断,如果​​requiredConstructor​​为空,也就是不存在​​@``Autowired​​注解的​​required​​属性是否为​​true​​的构造方法,则将默认构造方法(也就是空参的构造发方法)​​defaultConstructor​​添加到​​candidates​​中。

当前if语句块的最后,将​​candidates​​转换为数组赋值给​​candidateConstructors​​作为候选的构造方法数组。

如果​​candidates​​为空,则进入后续的条件判断语句块。

else if (rawCandidates.length == 1 && rawCandidates[0].getParameterCount() > 0) {
candidateConstructors = new Constructor<?>[] {rawCandidates[0]};
}
else if (nonSyntheticConstructors == 2 && primaryConstructor != null &&
defaultConstructor != null && !primaryConstructor.equals(defaultConstructor)) {
candidateConstructors = new Constructor<?>[] {primaryConstructor, defaultConstructor};
}
else if (nonSyntheticConstructors == 1 && primaryConstructor != null) {
candidateConstructors = new Constructor<?>[] {primaryConstructor};
}
else {
candidateConstructors = new Constructor<?>[0];
}

后续的几个条件连起来看。

  1. 如果当前类型只有一个构造方法,且是有参数的构造方法,则​​candidateConstructors​​为之包含这个构造方法的数组。
  2. 如果只有两个非合成的构造方法,其中一个是默认构造方法​​defaultConstructor​​,另一个是​​primaryConstructor​​,且两者不是同一个构造方法,则​​candidateConstructors​​为包含这两者的数组,​​primaryConstructor​​在​​defaultConstructor​​之前。
  3. 如果只有一个​​primaryConstructor​​,则​​candidateConstructors​​是之包含它的数组。
  4. 如果之前的条件都不符合,则​​candidateConstructors​​为空数组。

处理完之后,会将结果放到缓存中。

this.candidateConstructorsCache.put(beanClass, candidateConstructors);

在方法的最后,会判断​​candidateConstructors​​是否有元素,如果有则返回,没有就返回空。

return (candidateConstructors.length > 0 ? candidateConstructors : null);

总结

发表评论

相关文章