Spring源码-createBeanInstance和SmartInstantiationAwareBeanPostProcessor

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
// Make sure bean class is actually resolved at this point.
Class<?> beanClass = resolveBeanClass(mbd, beanName);

	if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
		throw new BeanCreationException(mbd.getResourceDescription(), beanName,
				"Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
	}

	Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
	if (instanceSupplier != null) {
		return obtainFromSupplier(instanceSupplier, beanName);
	}

	if (mbd.getFactoryMethodName() != null) {
		return instantiateUsingFactoryMethod(beanName, mbd, args);
	}

	// Shortcut when re-creating the same bean...
            // Spring会将解析好的构造函数放到缓存中，每次获取之前先到缓存中获取。
	boolean resolved = false; // 构造函数是否或工厂函数是否已解析
	boolean autowireNecessary = false; // 构造函数是否需要参数
	if (args == null) {
		synchronized (mbd.constructorArgumentLock) {
			if (mbd.resolvedConstructorOrFactoryMethod != null) {
				resolved = true;
				autowireNecessary = mbd.constructorArgumentsResolved;
			}
		}
	}
	if (resolved) {
		if (autowireNecessary) {
			return autowireConstructor(beanName, mbd, null, null);  // 调用构造函数有参数实例化
		}
		else {
			return instantiateBean(beanName, mbd); // 调用默认构造函数实例化
		}
	}

	// Candidate constructors for autowiring?
            // 调用SmartInstantiationAwareBeanPostProcessor的determineCandidateConstructors确定用于给定bean的候选构造函数。
	Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
            // 以下情况符合其一即可进入
	// 1、存在可选构造方法
	// 2、自动装配模型为构造函数自动装配
	// 3、给BeanDefinition中设置了构造参数值
	// 4、有参与构造函数参数列表的参数
	if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
			mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
		return autowireConstructor(beanName, mbd, ctors, args);
	}

	// 找出最合适的默认构造方法
	ctors = mbd.getPreferredConstructors();
	if (ctors != null) {
		return autowireConstructor(beanName, mbd, ctors, null);
	}

	//使用默认无参构造函数创建对象
	return instantiateBean(beanName, mbd);
}

determineConstructorsFromBeanPostProcessors：

	protected Constructor<?>[] determineConstructorsFromBeanPostProcessors(@Nullable Class<?> beanClass, String beanName)
		throws BeansException {

	if (beanClass != null && hasInstantiationAwareBeanPostProcessors()) {
		for (SmartInstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().smartInstantiationAware) {
			Constructor<?>[] ctors = bp.determineCandidateConstructors(beanClass, beanName);
			if (ctors != null) {
				return ctors;
			}
		}
	}
	return null;
}

调用SmartInstantiationAwareBeanPostProcessor的determineCandidateConstructors确定最合适的构造函数。

public interface SmartInstantiationAwareBeanPostProcessor extends InstantiationAwareBeanPostProcessor {

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

/**
      确定用于给定bean的候选构造函数。
 */
@Nullable
default Constructor<?>[] determineCandidateConstructors(Class<?> beanClass, String beanName)
		throws BeansException {

	return null;
}

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

}

SmartInstantiationAwareBeanPostProcessor继承自InstantiationAwareBeanPostProcessor接口，增加了三个额外处理的方法。