概要
过度
我们上文介绍了创建 Bean 实例并进行依赖注入、初始化的整体逻辑，我们介绍的是doCreateBean方法。还画了一个流程图，如下图所示：
1.png
获得实例会先走Factory的缓存，但是这个我们后面统一介绍。本节我们主要看一下具体的创建实例操作。但是创建实例是委托给外部函数做的。本文介绍调用的创建实例的外部函数详细逻辑。
内容简介
介绍如果根据入参锁定实例的创建方法，并创建出 bean 的实例。
所属环节
创建实例。【也就是createBeanInstance方法】
上下环节
上文：进入创造 Bean 实例的工厂方法，且没有在 Factory中获得缓存的实例
下文：获得实例，开始进行 BD 修饰以及属性填充、初始化
源码解析
入口
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
// TODO 此处存疑，需要专门看一下 factoryBeanInstanceCache 的作用及存取
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
// 1. 创建【通过工厂方法、根据参数指定构造器、默认构造器】
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
这是最开始调用的外部的创建 Bean 实例的方法，直接将 Id，RBD,args穿进去了。createBeanInstance也是同一个类中的方法。
选择创建实例方法的逻辑
/**
* 使用合适的策略创建指定的 Bean 的一个实例
* 有限次序：
* 1. 指定的 Supplier 工厂方法
* 2. 配置指向的工厂的具体方法
* 3. 匹配合适构造函数
* 4. 默认构造函数【无参那种】
*
* @param beanName the name of the bean
* @param mbd the bean definition for the bean
* @param args explicit arguments to use for constructor or factory method invocation
* @return a BeanWrapper for the new instance
*/
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
// 再次尝试加载 Bean 的 Class ，这个已经重复检测好几次了，可能是怕不规范调用吧。
Class<?> beanClass = resolveBeanClass(mbd, beanName);
// 判断 class 的作用域【public private】【不清楚是不是叫这个，姑且这么叫吧】是否符合标准
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(); // 应该是一个 factory method 吧
if (instanceSupplier != null) {
// 直接从生产者方法调用
return obtainFromSupplier(instanceSupplier, beanName);
}
if (mbd.getFactoryMethodName() != null) { // 通过工厂方法创建实例，在这里面有走缓存，所以在本函数没有体现缓存
return instantiateUsingFactoryMethod(beanName, mbd, args);
}
// 没有生产者方法、没有指定工厂方法
// Shortcut when re-creating the same bean...
// 已知：
// 这些便捷路径在我们第一次通过默认参数构建时就会缓存上
// 注意：
// 缓存仅对默认参数有效，也只能应用于默认参数
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 的方法看能否获得构造函数，能获得
// 就和上面一样走 autowireConstructor
// 否则使用默认构造函数
Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
return autowireConstructor(beanName, mbd, ctors, args);
}
// No special handling: simply use no-arg constructor.
return instantiateBean(beanName, mbd);
}
此处整体思路很明确，就是根据先后顺序依次找合适的创建实例的方法：
- 先看有没有现成的工厂方法可以调
- 如果
mbd指定了工厂和对应的方法，就去用对应的工厂方法 - 如果入参为空就根据
mbd缓存找一些可以用的构造函数和入参来创建 - 如果入参不空就根据入参按照自己的规则找合适的构造函数
2.png
接下来依次介绍四种情况的处理逻辑。
直接调用工厂方法
入口
Supplier<?> instanceSupplier = mbd.getInstanceSupplier(); // 应该是一个 factory method 吧
if (instanceSupplier != null) {
// 直接从生产者方法调用
return obtainFromSupplier(instanceSupplier, beanName);
}
具体逻辑
protected BeanWrapper obtainFromSupplier(Supplier<?> instanceSupplier, String beanName) {
// 调用方法获得实例，并保存在 BeanWrapper 中
String outerBean = this.currentlyCreatedBean.get();
this.currentlyCreatedBean.set(beanName);
Object instance;
try {
instance = instanceSupplier.get();
} finally {
if (outerBean != null) {
this.currentlyCreatedBean.set(outerBean);
} else {
this.currentlyCreatedBean.remove();
}
}
BeanWrapper bw = new BeanWrapperImpl(instance);
initBeanWrapper(bw);
return bw;
}
思路与之前的调用外部方法一样：
- 存一下，标记正在调用/创建
- 调用
- 调用完成，删除逻辑
这样做的原因猜测：
- 方便监控创建进度
- 留下钩子，后续可用来避免死循环
调用配置的工厂方法
入口
if (mbd.getFactoryMethodName() != null) {
// 通过工厂方法创建实例，在这里面有走缓存，所以在本函数没有体现缓存
return instantiateUsingFactoryMethod(beanName, mbd, args);
}
具体逻辑
protected BeanWrapper instantiateUsingFactoryMethod(
String beanName, RootBeanDefinition mbd, @Nullable Object[] explicitArgs) {
return new ConstructorResolver(this).instantiateUsingFactoryMethod(beanName, mbd, explicitArgs);
}
将具体的确定构造实例的函数以及调用创建实例委托给了ConstructorResolver类，我们跟进去看一下：
/*
* 此接口使用 `mbd.getFactoryMethodName`指定的方法来进行指定 Bean 的实例化操作。约定如下：
* * 如果 mbd 指定了`mbd.getFactoryBeanName`，则以获得的 String 为别名，创建对应的实例并
* 找到实例方法
* * 如果没有指定`mbd.getFactoryBeanName`，则认为采用的是 `mbd` 对应的 bean 的 class 的
* 静态方法来构建实例
*
* 我们确定从那个类找什么样的方法之后开始根据参数一个一个试就行了。
*/
public BeanWrapper instantiateUsingFactoryMethod(
String beanName, RootBeanDefinition mbd, @Nullable Object[] explicitArgs) {
BeanWrapperImpl bw = new BeanWrapperImpl();
this.beanFactory.initBeanWrapper(bw);
Object factoryBean;
Class<?> factoryClass;
boolean isStatic;
String factoryBeanName = mbd.getFactoryBeanName();
if (factoryBeanName != null) { // 根据约定走就行了
// 注意了：
// 1. 他是能生产 bean 的一个类，所以我们也叫他 factory
// 2. 他也是一个 bean
// 所以，他是一个 factoryBean ，不一定是 FactoryBean 类型的。
if (factoryBeanName.equals(beanName)) {
throw new BeanDefinitionStoreException(mbd.getResourceDescription(), beanName,
"factory-bean reference points back to the same bean definition");
}
factoryBean = this.beanFactory.getBean(factoryBeanName);
// 如果要通过工厂创建的 bean 是单例，且已经创建，直接报错，这说明前面的单例缓存被击穿。
// 如果是日常业务，最多也就是数据库压力变大，但是在这里，单例的重复创建会引起很大的问题，
// 例如之前为了解决循环依赖提前暴露的引用，可能就失效了。
if (mbd.isSingleton() && this.beanFactory.containsSingleton(beanName)) {
throw new ImplicitlyAppearedSingletonException();
}
factoryClass = factoryBean.getClass();
isStatic = false;
} else { // 不是引用的 bean 实例，是静态的
// It's a static factory method on the bean class.
if (!mbd.hasBeanClass()) {
throw new BeanDefinitionStoreException(mbd.getResourceDescription(), beanName,
"bean definition declares neither a bean class nor a factory-bean reference");
}
factoryBean = null;
factoryClass = mbd.getBeanClass();
isStatic = true;
}
Method factoryMethodToUse = null;
ArgumentsHolder argsHolderToUse = null;
Object[] argsToUse = null;
if (explicitArgs != null) {
argsToUse = explicitArgs;
} else {
Object[] argsToResolve = null;
synchronized (mbd.constructorArgumentLock) {
factoryMethodToUse = (Method) mbd.resolvedConstructorOrFactoryMethod;
if (factoryMethodToUse != null && mbd.constructorArgumentsResolved) {
// Found a cached factory method...
argsToUse = mbd.resolvedConstructorArguments;
if (argsToUse == null) {
argsToResolve = mbd.preparedConstructorArguments;
}
}
}
if (argsToResolve != null) {
argsToUse = resolvePreparedArguments(beanName, mbd, bw, factoryMethodToUse, argsToResolve);
}
}
// 第一个条件的意思：虽然我们拿到了要用方法的 String 的名称，但是没通过缓存拿到对应的方法，
// 需要自行根据入参筛选一下
//
// TODO 第二个条件情况不清楚
if (factoryMethodToUse == null || argsToUse == null) {
// Need to determine the factory method...
// Try all methods with this name to see if they match the given arguments.
factoryClass = ClassUtils.getUserClass(factoryClass);
// 获得这个类下面所有的方法，包括父类的
Method[] rawCandidates = getCandidateMethods(factoryClass, mbd);
List<Method> candidateList = new ArrayList<>();
// 根据方法名和是否为静态，筛选
for (Method candidate : rawCandidates) {
if (Modifier.isStatic(candidate.getModifiers()) == isStatic && mbd.isFactoryMethod(candidate)) {
candidateList.add(candidate);
}
}
Method[] candidates = candidateList.toArray(new Method[0]);
// 先根据函数作用域从大向小的排【public->protected->private】
// 同等作用域，根据入参数量从大到小排列
AutowireUtils.sortFactoryMethods(candidates);
ConstructorArgumentValues resolvedValues = null;
boolean autowiring = (mbd.getResolvedAutowireMode() == AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR);
int minTypeDiffWeight = Integer.MAX_VALUE;
Set<Method> ambiguousFactoryMethods = null;
int minNrOfArgs;
if (explicitArgs != null) {
minNrOfArgs = explicitArgs.length;
} else {//没有入参来确定数量，就根据BD中定下的构造函数入参数量来看
// TODO 具体情况未知
// We don't have arguments passed in programmatically, so we need to resolve the
// arguments specified in the constructor arguments held in the bean definition.
if (mbd.hasConstructorArgumentValues()) {
ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();
resolvedValues = new ConstructorArgumentValues();
minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);
} else {
minNrOfArgs = 0;
}
}
LinkedList<UnsatisfiedDependencyException> causes = null;
// 根据入参数量筛选
for (Method candidate : candidates) {
Class<?>[] paramTypes = candidate.getParameterTypes();
if (paramTypes.length >= minNrOfArgs) {
ArgumentsHolder argsHolder;
if (explicitArgs != null) {
// 指定入参的话，工厂方法的入参数量必须和指定的入参数量完全一致
if (paramTypes.length != explicitArgs.length) {
continue;
}
argsHolder = new ArgumentsHolder(explicitArgs);
} else { // 不是指定的入参
// Resolved constructor arguments: type conversion and/or autowiring necessary.
try {
String[] paramNames = null;
ParameterNameDiscoverer pnd = this.beanFactory.getParameterNameDiscoverer();
if (pnd != null) {
paramNames = pnd.getParameterNames(candidate);
}
// TODO 看一下
argsHolder = createArgumentArray(
beanName, mbd, resolvedValues, bw, paramTypes, paramNames, candidate, autowiring);
} catch (UnsatisfiedDependencyException ex) {
if (logger.isTraceEnabled()) {
logger.trace("Ignoring factory method [" + candidate + "] of bean '" + beanName + "': " + ex);
}
// Swallow and try next overloaded factory method.
if (causes == null) {
causes = new LinkedList<>();
}
causes.add(ex);
continue;
}
}
// 根据是否是严格匹配模式
// 并此方法入参参算一下匹配程度
int typeDiffWeight = (mbd.isLenientConstructorResolution() ?
argsHolder.getTypeDifferenceWeight(paramTypes) : argsHolder.getAssignabilityWeight(paramTypes));
// Choose this factory method if it represents the closest match.
// 这个方法的入参匹配程度比上一个匹配的还好，就把这个方法记录一下，冲掉上一个方法
if (typeDiffWeight < minTypeDiffWeight) {
factoryMethodToUse = candidate;
argsHolderToUse = argsHolder;
argsToUse = argsHolder.arguments;
minTypeDiffWeight = typeDiffWeight;
ambiguousFactoryMethods = null;
}
// Find out about ambiguity: In case of the same type difference weight
// for methods with the same number of parameters, collect such candidates
// and eventually raise an ambiguity exception.
// However, only perform that check in non-lenient constructor resolution mode,
// and explicitly ignore overridden methods (with the same parameter signature).
// 这个方法算出来的匹配程度和上一个一样。。。。
// 如果是严格模式的话就把这些方法都记录下来，后面该报错报错
else if (factoryMethodToUse != null && typeDiffWeight == minTypeDiffWeight &&
!mbd.isLenientConstructorResolution() &&
paramTypes.length == factoryMethodToUse.getParameterCount() &&
!Arrays.equals(paramTypes, factoryMethodToUse.getParameterTypes())) {
if (ambiguousFactoryMethods == null) {
ambiguousFactoryMethods = new LinkedHashSet<>();
ambiguousFactoryMethods.add(factoryMethodToUse);
}
ambiguousFactoryMethods.add(candidate);
}
}
}
// 对筛选结果进行分类报错
if (factoryMethodToUse == null) {// 没有合适的
if (causes != null) {
UnsatisfiedDependencyException ex = causes.removeLast();
for (Exception cause : causes) {
this.beanFactory.onSuppressedException(cause);
}
throw ex;
}
List<String> argTypes = new ArrayList<>(minNrOfArgs);
if (explicitArgs != null) {
for (Object arg : explicitArgs) {
argTypes.add(arg != null ? arg.getClass().getSimpleName() : "null");
}
} else if (resolvedValues != null) {
Set<ValueHolder> valueHolders = new LinkedHashSet<>(resolvedValues.getArgumentCount());
valueHolders.addAll(resolvedValues.getIndexedArgumentValues().values());
valueHolders.addAll(resolvedValues.getGenericArgumentValues());
for (ValueHolder value : valueHolders) {
String argType = (value.getType() != null ? ClassUtils.getShortName(value.getType()) :
(value.getValue() != null ? value.getValue().getClass().getSimpleName() : "null"));
argTypes.add(argType);
}
}
String argDesc = StringUtils.collectionToCommaDelimitedString(argTypes);
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"No matching factory method found: " +
(mbd.getFactoryBeanName() != null ?
"factory bean '" + mbd.getFactoryBeanName() + "'; " : "") +
"factory method '" + mbd.getFactoryMethodName() + "(" + argDesc + ")'. " +
"Check that a method with the specified name " +
(minNrOfArgs > 0 ? "and arguments " : "") +
"exists and that it is " +
(isStatic ? "static" : "non-static") + ".");
} else if (void.class == factoryMethodToUse.getReturnType()) { // 没有返回值，没法构建
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Invalid factory method '" + mbd.getFactoryMethodName() +
"': needs to have a non-void return type!");
} else if (ambiguousFactoryMethods != null) { // 无法精确定位方法
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Ambiguous factory method matches found in bean '" + beanName + "' " +
"(hint: specify index/type/name arguments for simple parameters to avoid type ambiguities): " +
ambiguousFactoryMethods);
}
// 保存结果
// TODO : 注意了，因为我们通过各种对比确定实例化函数还是很耗费性能的，所以我们采用缓存机制，将我们计算出的结果缓存值 mbd ，下次就直接用了
// TODO : 注意啦，这里只有使用默认构建参数时才会走缓存防止你在getBean（）时瞎玩
if (explicitArgs == null && argsHolderToUse != null) {
argsHolderToUse.storeCache(mbd, factoryMethodToUse);
}
}
// 至此，已确定了：
// 1. 构建工厂
// 2. 构建函数
// 3. 构建入参
// 接下来正常创建实例即可
try {
Object beanInstance;
if (System.getSecurityManager() != null) {
final Object fb = factoryBean;
final Method factoryMethod = factoryMethodToUse;
final Object[] args = argsToUse;
beanInstance = AccessController.doPrivileged((PrivilegedAction<Object>) () ->
beanFactory.getInstantiationStrategy().instantiate(mbd, beanName, beanFactory, fb, factoryMethod, args),
beanFactory.getAccessControlContext());
} else {
beanInstance = this.beanFactory.getInstantiationStrategy().instantiate(
mbd, beanName, this.beanFactory, factoryBean, factoryMethodToUse, argsToUse);
}
bw.setBeanInstance(beanInstance);
return bw;
} catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Bean instantiation via factory method failed", ex);
}
}
这个函数有些复杂了，我们先捋一下思路：
3.png
注意点
- 上面的流程图标成粉红的部分缓存是互相呼应的，结合在一起看，挺简单的。
- 绿框部分逻辑漏洞，"问题遗留"模块会介绍
候选方法的罗列、排序
不再粘贴代码，该有的注释在上面都有了，此处只画一下流程图：
4.png
同名重载的方法筛选
老样子，代码上面有，直接上流程图：
5.png
真的不太会画循环的流程图。。。。。画的实在是丑了点
调用确定的方法，创建实例
有的用就用，没得用、不知道用哪个就报错。
使用构造函数
我们统一成一个小标题来说了，在上面的分析"调用配置的工厂方法"中，我们看到了在没有确定入参的情况下是先走mbd的缓存，缓存不能解决才走的扫描所有方法匹配。
使用构造函数这里我们直接在createBeanInstance的主逻辑中做了尝试走缓存操作：
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 的方法看能否获得构造函数，能获得
// 就和上面一样走 autowireConstructor
// 否则使用默认构造函数
Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
return autowireConstructor(beanName, mbd, ctors, args);
}
// No special handling: simply use no-arg constructor.
return instantiateBean(beanName, mbd);
思路很简单：
- 如果没有通过入参指定参数就看能不能从缓存读到配置的构造函数和入参，如果都能读到，直接调用
autowireConstructor，猜测里面也是走的先缓存。如果没读全，肯定没法调用高级的构造函数，用默认的无入参构造函数即可- 如果指定了入参或者说是要求必须通过构造函数入一些东西或者通过配置确定了入参，直接委托
autowireConstructor构造- 最后，默认构造函数兜底。
感觉比较拗口，总体来说还是能确定某个构造函数就确定。不能确定就用默认入参兜底。
autowireConstructor
大概猜猜，和上面的调用配置的工厂方法的流程基本一致。只不过上面是通过mbd.getFactoryMethodName()获得的方法名，这里使用的构造函数。。。。。。。
不再赘述了，感觉很啰嗦。
扩展
RootBeanDefinition中的那些缓存
resolvedConstructorOrFactoryMethod
之前用默认构造函数、默认入参实现构建实例后将用的构造的方法缓存至此。
constructorArgumentsResolved
之前用默认构造函数、默认入参实现构建实例后将用的构造的默认入参缓存至此。
ConstructorResolver类介绍
就是一大堆筛选符合条件的方法的集合。
感觉里面的函数写的还是挺乱的。逻辑及其复杂。大概熟悉工作思路即可。
这块的代码看着不像 Spring 的风格。。。。。
问题遗留
调用配置的工厂方法，有逻辑漏洞
看调用配置的工厂方法的那个总的流程图，里面用绿色框起来的那部分。他是先判断是否静态，再走的缓存。如果有缓存的话，第一步就是白费力气，完全没有帮助。
所以两步进行颠倒，可以提高代码执行效率。
网友评论