Spring源码-BeanPostProcessor、SmartInstantiationAwareBeanPostProcessor

BeanPostProcessor类图

SmartInstantiationAwareBeanPostProcessor

/**
 * 继承自InstantiationAwareBeanPostProcessor接口，增加了三个额外处理的方法，由spring内部使用
 */
public interface SmartInstantiationAwareBeanPostProcessor extends InstantiationAwareBeanPostProcessor {

	/**
	 * 预测bean的类型，主要是在bean还没有创建前我们需要获取bean的类型
	 */
	@Nullable
	default Class<?> predictBeanType(Class<?> beanClass, String beanName) throws BeansException {
		return null;
	}

	/**
	 * 完成对构造函数的解析和推断
	 */
	@Nullable
	default Constructor<?>[] determineCandidateConstructors(Class<?> beanClass, String beanName)
			throws BeansException {

		return null;
	}

	/**
	 * 解决循环依赖问题，通过此方法提前暴露一个合格的对象
	 */
	default Object getEarlyBeanReference(Object bean, String beanName) throws BeansException {
		return bean;
	}

}

InstantiationAwareBeanPostProcessor

/**
 * 继承自BeanPostProcessor，添加了实例化前，实例化后，属性注入后的处理方法
 */
public interface InstantiationAwareBeanPostProcessor extends BeanPostProcessor {

	/**
	 * 在bean实例化之前调用
	 */
	@Nullable
	default Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
		return null;
	}

	/**
	 * 在bean实例化之后调用
	 */
	default boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
		return true;
	}

	/**
	 * 当使用注解的时候，通过这个方法来完成属性的注入
	 */
	@Nullable
	default PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName)
			throws BeansException {
		return null;
	}

	/**
	 * 属性注入后执行的方法，在5.1版本被废弃
	 */
	@Deprecated
	@Nullable
	default PropertyValues postProcessPropertyValues(
			PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {
		return pvs;
	}
}

AutowiredAnnotationBeanPostProcessor

/**
	 * 获取构造器集合
	 * 		如果有多个Autowired，required为true，不管有没有默认构造方法，会报异常
	 * 		如果只有一个Autowired，required为false，没有默认构造方法，会报警告
	 * 		如果没有Autowired注解，定义了两个及以上有参数的构造方法，没有无参构造方法，就会报错 ???
	 * 		其他情况都可以，但是以有Autowired的构造方法优先，然后才是默认构造方法
	 * @param beanClass
	 * @param beanName
	 * @return
	 * @throws BeanCreationException
	 */
	@Override
	@Nullable
	public Constructor<?>[] determineCandidateConstructors(Class<?> beanClass, final String beanName)
			throws BeanCreationException {

		// Let's check for lookup methods here...
		// 处理包含@Loopup注解的方法，如果集合中没有beanName，则走一遍bean中的所有方法，过滤是否含有lookup方法
		if (!this.lookupMethodsChecked.contains(beanName)) {
			if (AnnotationUtils.isCandidateClass(beanClass, Lookup.class)) {
				try {
					Class<?> targetClass = beanClass;
					do {
						// 遍历当前类以及所有父类，找出lookup注解的方法进行处理
						ReflectionUtils.doWithLocalMethods(targetClass, method -> {
							// 获取method上的Lookup注解
							Lookup lookup = method.getAnnotation(Lookup.class);
							// 存在此注解的话，就将方法和注解中的内容构建LookupOverride对象，设置进BeanDefinition中
							if (lookup != null) {
								Assert.state(this.beanFactory != null, "No BeanFactory available");
								LookupOverride override = new LookupOverride(method, lookup.value());
								try {
									RootBeanDefinition mbd = (RootBeanDefinition)
											this.beanFactory.getMergedBeanDefinition(beanName);
									mbd.getMethodOverrides().addOverride(override);
								}
								catch (NoSuchBeanDefinitionException ex) {
									throw new BeanCreationException(beanName,
											"Cannot apply @Lookup to beans without corresponding bean definition");
								}
							}
						});
						targetClass = targetClass.getSuperclass();
					}
					//遍历父类，直到Object
					while (targetClass != null && targetClass != Object.class);

				}
				catch (IllegalStateException ex) {
					throw new BeanCreationException(beanName, "Lookup method resolution failed", ex);
				}
			}
			// 无论对象中是否含有@Lookup方法，过滤完成后都会放到集合中，证明此bean已经检查完@Lookup注解
			this.lookupMethodsChecked.add(beanName);
		}

		// 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) {
					Constructor<?>[] rawCandidates;
					try {
						//获取bean中所有的构造函数
						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);
					}
					// 暂时候选构造函数集合，
					List<Constructor<?>> candidates = new ArrayList<>(rawCandidates.length);
					// 带有依赖项的构造函数
					Constructor<?> requiredConstructor = null;
					// 默认使用的构造函数
					Constructor<?> defaultConstructor = null;
					// 获取主构造函数
					Constructor<?> primaryConstructor = BeanUtils.findPrimaryConstructor(beanClass);
					// 标识，表示不是合成构造函数的数量
					// 合成构造函数->有方法参数并对实例进行赋值的构造函数
					int nonSyntheticConstructors = 0;
					// 遍历所有的构造函数
					for (Constructor<?> candidate : rawCandidates) {
						// 构造函数不是合成构造函数，标识累加
						if (!candidate.isSynthetic()) {
							nonSyntheticConstructors++;
						}
						else if (primaryConstructor != null) {
							continue;
						}
						// 查找构造函数上@Autowired注解的属性，
						MergedAnnotation<?> ann = findAutowiredAnnotation(candidate);
						// 注解不存在，则再通过方法获取用户类，如果是用户类则返回用户类，还判断了cglib的情况，cglib情况则返回目标类
						// 然后获取参数一致的构造函数再获取注解
						if (ann == null) {
							Class<?> userClass = ClassUtils.getUserClass(beanClass);
							// 如果是有代理的，找到被代理
							if (userClass != beanClass) {
								try {
									// 获取构造方法
									Constructor<?> superCtor =
											userClass.getDeclaredConstructor(candidate.getParameterTypes());
									//继续寻找Autowired和value的注解
									ann = findAutowiredAnnotation(superCtor);
								}
								catch (NoSuchMethodException ex) {
									// Simply proceed, no equivalent superclass constructor found...
								}
							}
						}
						// 构造函数上存在注解
						if (ann != null) {
							//有两个Autowired注解，冲突了
							if (requiredConstructor != null) {
								throw new BeanCreationException(beanName,
										"Invalid autowire-marked constructor: " + candidate +
										". Found constructor with 'required' Autowired annotation already: " +
										requiredConstructor);
							}
							// 获取@Autowired注解中required属性的值
							boolean required = determineRequiredStatus(ann);
							// 为true则将这个构造函数设置为带有依赖项的构造函数并进行判断，不可存在多个带有依赖项的构造函数
							if (required) {
								//如果已经有required=false了，又来了一个required=true的方法就报异常了，这样两个可能就不知道用哪个了
								if (!candidates.isEmpty()) {
									throw new BeanCreationException(beanName,
											"Invalid autowire-marked constructors: " + candidates +
											". Found constructor with 'required' Autowired annotation: " +
											candidate);
								}
								requiredConstructor = candidate;
							}
							// 加入集合
							candidates.add(candidate);
						}
						// 如果构造函数的参数为零，则是默认构造函数
						else if (candidate.getParameterCount() == 0) {
							defaultConstructor = candidate;
						}
					}
					// 存在@Autowired注解的函数，并且required值为false，则此注解不起作用，但是存在默认构造函数
					// 则将默认构造函数添加到集合中，并将集合变为数组使用
					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]);
					}
					// 如果只存在一个构造函数，且这个构造函数有参数列表，则使用这个构造函数
					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 {
						//大于2个没注解的构造方法就不知道要用什么了，所以就返回null
						candidateConstructors = new Constructor<?>[0];
					}
					this.candidateConstructorsCache.put(beanClass, candidateConstructors);
				}
			}
		}
		// 使用构造列表中没有值，则返回null
		return (candidateConstructors.length > 0 ? candidateConstructors : null);
	}