位置
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
// 实例化bean
BeanWrapper instanceWrapper = createBeanInstance(beanName, mbd, args);
// 属性填充
populateBean(beanName, mbd, instanceWrapper);
// 调用初始化方法
return initializeBean(beanName, instanceWrapper.getWrappedInstance(), mbd);
}
创建实例-createBeanInstance
/**
* 使用适当的实例化策略为指定的 bean 创建一个新实例：
* 工厂方法、构造函数自动装配或简单实例化。
* @param beanName bean 的名称
* @param mbd bean 的 bean 定义
* @param args 用于构造函数或工厂方法调用的显式参数
* @return 新实例的 BeanWrapper
* @see #obtainFromSupplier
* @see #instantiateUsingFactoryMethod
* @see #autowireConstructor
* @see #instantiateBean
*/
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
// 确保此时真正解析了 bean 类。
Class<?> beanClass = resolveBeanClass(mbd, beanName);
// 校验这个instanceSupplier是否有值，有的话，调用这个字段获取对象。
// 工厂方法创建对象使用反射调用目标方法，不如直接调用目标方法效率高
Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
if (instanceSupplier != null) {
return obtainFromSupplier(instanceSupplier, beanName);
}
// 如果工厂方法不为空则使用工厂方法初始化策略
if (mbd.getFactoryMethodName() != null) {
// 1、RootBeanDefinition 中存在 factoryMethodName属性，或配置文件中配置了factory-method，根据配置生成实例
return instantiateUsingFactoryMethod(beanName, mbd, args);
}
// 重新创建同一个 bean 时的快捷方式...
boolean resolved = false;
boolean autowireNecessary = false;
if (args == null) {
synchronized (mbd.constructorArgumentLock) {
// 2、判断过程很耗性能，采用缓存机制，RootBeanDefinition中的属性resolvedConstructorOrFactoryMethod缓存中去取
// 根据参数及类型锁定对应的构造函数或工厂方法
if (mbd.resolvedConstructorOrFactoryMethod != null) {
resolved = true;
autowireNecessary = mbd.constructorArgumentsResolved;
}
}
}
// 如果已经解析过则使用解析好的构造函数不需要再次锁定
if (resolved) {
if (autowireNecessary) {
// 构造函数自动注入
return autowireConstructor(beanName, mbd, null, null);
} else {
// 默认构造函数构造
return instantiateBean(beanName, mbd);
}
}
// 根据参数解析构造函数
// 自动装配的候选构造函数？
Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
// 构造函数自动注入
return autowireConstructor(beanName, mbd, ctors, args);
}
// 没有特殊处理：只需使用无参数构造函数。
return instantiateBean(beanName, mbd);
}
有参构造-autowireConstructor
1、构造函数参数的确定
1)根据explicitArgs参数判断
2)缓存中获取
3)配置文件获取
2、构造函数的确定
3、根据确定的构造函数转换对应的参数类型
4、构造函数不确定性的验证
因为不同构造函数的参数为父子关系
5、根据实例化策略以及得到的构造函数及其参数实例化Bean
/**
* “自动装配构造函数”（按类型使用构造函数参数）行为。
* 如果指定了显式构造函数参数值，也适用，将所有剩余参数与来自 bean 工厂的 bean 匹配。
* 这对应于构造函数注入：在这种模式下，Spring bean 工厂能够承载期望基于构造函数的依赖项解析的组件。
* @param beanName bean 的名称
* @param mbd bean 的 bean 定义
* @param chosenCtors 选择的候选构造函数
* @param explicitArgs 参数值通过 getBean 方法以编程方式传入，或者 {@code null} 如果没有（-> 使用 bean 定义中的构造函数参数值）
* @return 新实例的 BeanWrapper
*/
public BeanWrapper autowireConstructor(String beanName, RootBeanDefinition mbd,
@Nullable Constructor<?>[] chosenCtors, @Nullable Object[] explicitArgs) {
BeanWrapperImpl bw = new BeanWrapperImpl();
this.beanFactory.initBeanWrapper(bw);
Constructor<?> constructorToUse = null;
ArgumentsHolder argsHolderToUse = null;
Object[] argsToUse = null;
// explicitArgs 通过getBean()传入
if (explicitArgs != null) {
// 如果 getBean() 调用的时候指定方法参数那么直接使用
argsToUse = explicitArgs;
} else {
// 如果 getBean() 调用的时候没有指定方法参数，则尝试从配置文件中解析
Object[] argsToResolve = null;
// 尝试从缓存中获取
synchronized (mbd.constructorArgumentLock) {
constructorToUse = (Constructor<?>) mbd.resolvedConstructorOrFactoryMethod;
if (constructorToUse != null && mbd.constructorArgumentsResolved) {
// 从缓存中取
// 找到一个缓存的构造函数...
argsToUse = mbd.resolvedConstructorArguments;
if (argsToUse == null) {
// 配置的构造函数参数
argsToResolve = mbd.preparedConstructorArguments;
}
}
}
// 如果缓存中存在
if (argsToResolve != null) {
// 解析参数类型，如给定方法的构造函数A(int,int)通过此方法后就会把配置中的("1","1")转换为(1,1)
// 缓存中的值可能是原始值或者最终值
argsToUse = resolvePreparedArguments(beanName, mbd, bw, constructorToUse, argsToResolve);
}
}
// 没有被缓存
if (constructorToUse == null) {
// 需要解析构造函数.
boolean autowiring = (chosenCtors != null ||
mbd.getResolvedAutowireMode() == AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR);
ConstructorArgumentValues resolvedValues = null;
int minNrOfArgs;
if (explicitArgs != null) {
minNrOfArgs = explicitArgs.length;
} else {
// 提取配置文件中的配置的构造函数参数
ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();
// 用于承载解析后的构造函数参数的值
resolvedValues = new ConstructorArgumentValues();
// 能解析到的参数个数
minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);
}
// 使用指定的构造函数，如果有的话。
Constructor<?>[] candidates = chosenCtors;
if (candidates == null) {
Class<?> beanClass = mbd.getBeanClass();
candidates = (mbd.isNonPublicAccessAllowed() ?
beanClass.getDeclaredConstructors() : beanClass.getConstructors());
}
// 排序给定的构造函数，public构造函数优先参数数量降序、非public构造函数参数数量降序
AutowireUtils.sortConstructors(candidates);
int minTypeDiffWeight = Integer.MAX_VALUE;
Set<Constructor<?>> ambiguousConstructors = null;
LinkedList<UnsatisfiedDependencyException> causes =
