spring通过不同的方式创建bean

我会带着你远行 2022-11-11 13:04 216阅读 0赞

## 1：写在前面 ##

本文在[createBean方法分析][createBean]的基础上进行分析，作为补充，详细分析spring通过构造函数，[工厂方法][Link 1]等创建bean的过程。

## 2：createBeanInstance ##

源码：

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean
    protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
    			throws BeanCreationException { 
    	...snip...
    	if (instanceWrapper == null) { 
    		instanceWrapper = createBeanInstance(beanName, mbd, args);
    	}
    	...snip...
    }

继续：

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBeanInstance
    protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) { 
    	// 获取待实例化bean的类型，后续实例化bean的时候使用
    	Class<?> beanClass = resolveBeanClass(mbd, beanName);
    	// <2021-03-20 02:56>
    	// 以下条件同时满足则异常，因为此时无法创建实例对象
    	// 1: 没有解析到bean的class类型
    	// 2：类访问修饰符不是public的
    	// 3：不允许访问非public的构造函数和方法
    	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());
    	}
    	// <2021-03-20 04:36>
    	// 获取Supplier
    	Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
    	// 如果是有Supplier则使用Supplier创建对象，并return
    	if (instanceSupplier != null) { 
    		return obtainFromSupplier(instanceSupplier, beanName);
    	}
    	// <2021-03-20 05:21>
    	// 通过factory-method创建bean
    	if (mbd.getFactoryMethodName() != null) { 
    		return instantiateUsingFactoryMethod(beanName, mbd, args);
    	}
    	/*** 到这里的话，就是通过构造函数来创建对象了 ***/
    	
    	// 是否已经解析处使用哪个构造函数的标记
    	boolean resolved = false;
    	// false:使用默认构造函数 true：使用带有参数的构造函数
    	boolean autowireNecessary = false;
    	// 如果是getbean时传入的参数为null
    	// 这里是处理缓存有对应的构造函数的情况
    	// 缓存的原因是查找对应构造函数比较耗性能
    	// 对于scope为prototype的bean作用比较大
    	if (args == null) { 
    		synchronized (mbd.constructorArgumentLock) { 
    			// 如果是需要的解析的构造函数不为空
    			if (mbd.resolvedConstructorOrFactoryMethod != null) { 
    				// 标记为已经解析完毕
    				resolved = true;
    				// 设置构造函数参数是否已经解析
    				// 1：解析了，则autowireNecessary 为true，则使用带有参数的构造函数
    				// 2：没有解析，说明没有参数，即没有配置contructor-arg，为false，则使用默认的构造函数
    				autowireNecessary = mbd.constructorArgumentsResolved;
    			}
    		}
    	}
    	// 如果是构造函数已经在缓存中存在了
    	if (resolved) { 
    		// 如果是autowireNecessary为true，则说明需要使用非默认
    		// 构造函数，即带有参数的构造函数，否则使用默认的构造函数
    		if (autowireNecessary) { 
    			// <2021-03-22 16:46>
    			// 通过带有参数的构造函数创建bean
    			return autowireConstructor(beanName, mbd, null, null);
    		}
    		// 如果是构造函数参数还没有在缓存中，则说明
    		// 是默认构造函数
    		else { 
    			// <2021-03-22 16:47>
    			// 调用默认构造函数创建bean
    			return instantiateBean(beanName, mbd);
    		}
    	}
    
    	// 执行到这里的话，说明调用的构造函数还没有确定
    	// 这里需要确定要调用的目标构造函数
    	Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
    	if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
    			mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) { 
    		// 使用带有参数的构造函数创建bean
    		return autowireConstructor(beanName, mbd, ctors, args);
    	}
    
    	// 使用带有参数的构造函数创建bean
    	ctors = mbd.getPreferredConstructors();
    	if (ctors != null) { 
    		return autowireConstructor(beanName, mbd, ctors, null);
    	}
    
    	// 使用无参数，即默认的构造函数创建bean
    	return instantiateBean(beanName, mbd);
    }

`<2021-03-20 02:56>`处是保证`待实例化`的bean是能够实例化的，其中`Modifier.isPublic(beanClass.getModifiers())`是判断class是否为public类型，源码如下：

java.lang.reflect.Modifier#isPublic
    public static boolean isPublic(int mod) { 
    	// public static final int PUBLIC = 0x00000001;
        return (mod & PUBLIC) != 0;
    }

`mbd.isNonPublicAccessAllowed()`是返回`是否允许访问非public的构造函数和方法`,源码如下:

org.springframework.beans.factory.support.AbstractBeanDefinition#isNonPublicAccessAllowed
    public boolean isNonPublicAccessAllowed() { 
    	// private boolean nonPublicAccessAllowed = true;
    	// 该值默认为true，即允许访问
    	return this.nonPublicAccessAllowed;
    }

`<2021-03-20 04:36>`处尝试获取Supplier，通过Supplier获取对象，关于Supplier可以参考[这里  
][Link 2]，该处详细参考`2.1：通过Supplier创建bean`,`<2021-03-20 05:21>`处是通过factory-method来创建bean，关于factory-method可以参考[这里][Link 1]，可以通过实例方法和静态方法来返回一个对象，该处详细参考`2.2：通过factory-method创建bean`。`<2021-03-22 16:46>`处参考`2.2：通过带有参数的构造函数创建bean`。`<2021-03-22 16:47>`处参考`2.3：通过默认构造函数创建bean`。

### 2.1：通过Supplier创建bean ###

这里是在通过常规方式创建bean前尝试使用Supplier来创建对象，源码如下：

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBeanInstance
    protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) { 
    	...snip...
    	// 获取Supplier
    	Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
    	if (instanceSupplier != null) { 
    		// <2021-03-20 04:43>
    		return obtainFromSupplier(instanceSupplier, beanName);
    	}
    	...snip...
    }

`<2021-03-20 04:43>`处源码如下：

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#obtainFromSupplier
    protected BeanWrapper obtainFromSupplier(Supplier<?> instanceSupplier, String beanName) { 
    		Object instance;
    	// private final NamedThreadLocal<String> currentlyCreatedBean 
    	// = new NamedThreadLocal<>("Currently created bean");
    	// 保留当前正在记录创建的bean名称，后续重新设置回去
    	String outerBean = this.currentlyCreatedBean.get();
    	// 设置当前创建的bean名称
    	this.currentlyCreatedBean.set(beanName);
    	try { 
    		// 通过Supplier的get方法获取实例对象
    		instance = instanceSupplier.get();
    	}
    	finally { 
    		// 如果是原来的bean名称不为空，则重新设置回去，否则删除当前的
    		if (outerBean != null) { 
    			this.currentlyCreatedBean.set(outerBean);
    		}
    		else { 
    			this.currentlyCreatedBean.remove();
    		}
    	}
    	// 如果是返回的为null则使用NullBean
    	if (instance == null) { 
    		instance = new NullBean();
    	}
    	// 封装到BeanWrapper中
    	BeanWrapper bw = new BeanWrapperImpl(instance);
    	// 初始化BeanWrapper，详细略
    	initBeanWrapper(bw);
    	return bw;
    }

### 2.2：通过factory-method创建bean ###

源码：

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBeanInstance
    protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) { 
    	...snip...
    	if (mbd.getFactoryMethodName() != null) { 
    		return instantiateUsingFactoryMethod(beanName, mbd, args);
    	...snip...
    	}
    }

继续源码：

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#instantiateUsingFactoryMethod
    protected BeanWrapper instantiateUsingFactoryMethod(
    			String beanName, RootBeanDefinition mbd, @Nullable Object[] explicitArgs) { 
    
    	return new ConstructorResolver(this).instantiateUsingFactoryMethod(beanName, mbd, explicitArgs);
    }

创建了ConstructorResolver对象并调用器instantiateUsingFactoryMethod方法，源码如下：

org.springframework.beans.factory.support.ConstructorResolver#instantiateUsingFactoryMethod
    public BeanWrapper instantiateUsingFactoryMethod(
    		String beanName, RootBeanDefinition mbd, @Nullable Object[] explicitArgs) { 
    	// 创建BeanWrapper对象
    	BeanWrapperImpl bw = new BeanWrapperImpl();
    	// 注册用于转换属性值的ConversionService和PropertyEditor
    	// 参考：https://blog.csdn.net/wang0907/article/details/115043257
    	// https://blog.csdn.net/wang0907/article/details/115046359
    	this.beanFactory.initBeanWrapper(bw);
    	
    	// 用于创建对象的工厂bean
    	Object factoryBean;
    	// 工厂bean的class类型
    	Class<?> factoryClass;
    	// 是否是通过静态方法获取bean，true为是，fasle为不是
    	boolean isStatic;
    	// 工厂bean获取bean的方法有两种，一种是通过工厂的静态方法
    	// 另外一种是通过工厂的实例方法，这里就是通过实例方法获取
    	// 时工厂bean的名称
    	String factoryBeanName = mbd.getFactoryBeanName();
    	// 如果是工厂bean的名称不为空，则是工厂bean的实例方法获取bean
    	if (factoryBeanName != null) {  // 实例方法
    		// 判断使用要创建的bean作为工厂bean的异常情况
    		if (factoryBeanName.equals(beanName)) { 
    			throw new BeanDefinitionStoreException(mbd.getResourceDescription(), beanName,
    					"factory-bean reference points back to the same bean definition");
    		}
    		// 从bean工厂IOC容器中获取工厂bean
    		factoryBean = this.beanFactory.getBean(factoryBeanName);
    		// 没搞清楚这里要判断什么到底？？？
    		if (mbd.isSingleton() && this.beanFactory.containsSingleton(beanName)) { 
    			throw new ImplicitlyAppearedSingletonException();
    		}
    		// 获取工厂bean的class类型
    		factoryClass = factoryBean.getClass();
    		// 标记为不是通过静态方法获取bean
    		isStatic = false;
    	}
    	// 否则就是通过实例工厂的静态方法获取bean，此时不需要工厂的实例
    	// 因为调用静态方法不需要实例对象
    	else {  // 静态方法
    		// 判断是否设置了工厂类的class属性，因为要通过class调用其
    		// 静态方法获取bean，所以这里必须指定，否则无法调用其静态方法
    		if (!mbd.hasBeanClass()) { 
    			throw new BeanDefinitionStoreException(mbd.getResourceDescription(), beanName,
    					"bean definition declares neither a bean class nor a factory-bean reference");
    		}
    		// 因为是静态方法获取，所以就不需要工厂bean了
    		factoryBean = null;
    		// 设置工厂bean的class类型
    		factoryClass = mbd.getBeanClass();
    		// 标记为是通过工厂bean的静态方法获取bean
    		isStatic = true;
    	}
    
    	Method factoryMethodToUse = null;
    	ArgumentsHolder argsHolderToUse = null;
    	Object[] argsToUse = null;
    	// 开始获取调用工厂方法需要的入参信息
    	// 如果是调用getBean时显示传入了参数，则直接使用作为
    	// 调用工厂方法的入参
    	if (explicitArgs != null) { 
    		argsToUse = explicitArgs;
    	}
    	// getBean没有显式指定的话，首先通过缓存获取
    	// 缓存没有的话尝试从配置文件中解析
    	else { 
    		Object[] argsToResolve = null;
    		synchronized (mbd.constructorArgumentLock) { 
    			// 从缓存中获取目标方法对应的Method对象
    			factoryMethodToUse = (Method) mbd.resolvedConstructorOrFactoryMethod;
    			if (factoryMethodToUse != null && mbd.constructorArgumentsResolved) { 
    				// 尝试从缓存中获取调用方法需要的参数数组信息
    				argsToUse = mbd.resolvedConstructorArguments;
    				if (argsToUse == null) { 
    					argsToResolve = mbd.preparedConstructorArguments;
    				}
    			}
    		}
    		if (argsToResolve != null) { 
    			argsToUse = resolvePreparedArguments(beanName, mbd, bw, factoryMethodToUse, argsToResolve, true);
    		}
    	}
    	// 过是
    	if (factoryMethodToUse == null || argsToUse == null) { 
    		// 因为这里可能存在如cglib代理的情况，此时factoryClass的值
    		// 是用户实际工厂类的子类，这里就是获取工厂类的实际类型
    		factoryClass = ClassUtils.getUserClass(factoryClass);
    		// 获取工厂类的所有的方法
    		Method[] rawCandidates = getCandidateMethods(factoryClass, mbd);
    		// 可能满足要求的工厂方法
    		List<Method> candidateList = new ArrayList<>();
    		for (Method candidate : rawCandidates) { 
    			// 从以下两个方面进行候选方法判断，注意包含了从父类继承而来的
    			// 1：静态非静态是否和isStatic相同
    			// 2：方法名称是否和工厂方法名称相同mbd.isFactoryMethod(candidate)
    			// 如果是两者都满足的话，则有可能是需要调用的目标方法
    			// 此时就差参数确定了
    			if (Modifier.isStatic(candidate.getModifiers()) == isStatic && mbd.isFactoryMethod(candidate)) { 
    				candidateList.add(candidate);
    			}
    		}
    		// 满足以下3个条件则为true
    		// 1：候选方法只有1个，即唯一确定
    		// 2：没有明确的传入参数，一定程度上说明方法不需要参数
    		// 3：bd信息中没有配置参数（并不确定是方法真的不需要参数），则不需要后续的参数解析工作了
    		// 此时就可以直接开始解析目标工厂方法，获取实例了
    		if (candidateList.size() == 1 && explicitArgs == null && !mbd.hasConstructorArgumentValues()) { 
    			// 获取唯一的方法
    			Method uniqueCandidate = candidateList.get(0);
    			// 如果是方法的参数个数为0，即方法确实不需要参数
    			if (uniqueCandidate.getParameterCount() == 0) { 
    				// 设置用于内省的工厂方法到bd中
    				mbd.factoryMethodToIntrospect = uniqueCandidate;
    				synchronized (mbd.constructorArgumentLock) { 
    					// 设置解析出的工厂方法
    					mbd.resolvedConstructorOrFactoryMethod = uniqueCandidate;
    					// 设置已经解析出工厂方法需要的参数
    					mbd.constructorArgumentsResolved = true;
    					// 设置解析出的工厂方法的参数为空参数
    					// private static final Object[] EMPTY_ARGS = new Object[0];
    					// 这里是为了和有参数的工厂方法的调用保持一致
    					mbd.resolvedConstructorArguments = EMPTY_ARGS;
    				}
    				// <2021-03-21 21:04>
    				// 通过instantiate方法创建bean并设置到bw中，然后返回
    				bw.setBeanInstance(instantiate(beanName, mbd, factoryBean, uniqueCandidate, EMPTY_ARGS));
    				return bw;
    			}
    		}
    		// 将候选工厂方法转换为Method数组
    		Method[] candidates = candidateList.toArray(new Method[0]);
    		// <2021-03:22 09:58>
    		// 先按照方法是否为public排序，然后按照参数个数排序
    		AutowireUtils.sortFactoryMethods(candidates);
    		// 承载解析出的方法参数值信息
    		ConstructorArgumentValues resolvedValues = null;
    		// 这里认为是false即可
    		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 { 
    			// 如果是在xml文件中设置了参数
    			if (mbd.hasConstructorArgumentValues()) { 
    				// 获取xml中设置的参数信息
    				ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();
    				// 定义封装最终解析出的参数值信息对象
    				resolvedValues = new ConstructorArgumentValues();
    				// 解析参数值信息，会涉及到其他bean，将结果
    				// 放到resolveValues中，然后返回参数的个数
    				// 作为最小的参数的个数
    				minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);
    			}
    			// 如果是没有则设置最小的参数的个数为0
    			else { 
    				minNrOfArgs = 0;
    			}
    		}
    		// 存储UnsatisfiedDependencyException异常的集合
    		LinkedList<UnsatisfiedDependencyException> causes = null;
    		// 遍历候选方法挨个处理
    		for (Method candidate : candidates) { 
    			// 获取方法的参数类型数组
    			Class<?>[] paramTypes = candidate.getParameterTypes();
    			// 因为前面已经按照参数个数排序，这里>=minNrOfArgs
    			// 的方法就是还没有进行处理的
    			if (paramTypes.length >= minNrOfArgs) { 
    				// 存储参数的对象
    				ArgumentsHolder argsHolder;
    				// 如果有明确传入参数，则使用
    				if (explicitArgs != null) { 
    					// 传入的参数个数必须和当前方法的参数个数完全一致
    					// 否则continue，认为该方法不适合
    					if (paramTypes.length != explicitArgs.length) { 
    						continue;
    					}
    					argsHolder = new ArgumentsHolder(explicitArgs);
    				}
    				else { 
    					// Resolved constructor arguments: type conversion and/or autowiring necessary.
    					try { 
    						// 参数名称数组
    						String[] paramNames = null;
    						// 从bean工厂中获取参数名称探测器
    						ParameterNameDiscoverer pnd = this.beanFactory.getParameterNameDiscoverer();
    						// 如果是方法名称探测器不为空则用其
    						// 从方法中提取参数名称数组信息
    						if (pnd != null) { 
    							paramNames = pnd.getParameterNames(candidate);
    						}
    						// 创建参数持有者对象
    						argsHolder = createArgumentArray(beanName, mbd, resolvedValues, bw,
    								paramTypes, paramNames, candidate, autowiring, candidates.length == 1);
    					}
    					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<>();
    						}
    						// 发生UnsatisfiedDependency异常则添加
    						causes.add(ex);
    						// 继续下一个方法
    						continue;
    					}
    				}
    				// mbd.isLenientConstructorResolution()是否为宽松模式
    				// 宽松模式：使用最接近的模式进行匹配
    				// 非宽松模式/严格模式：个数的类型必须完全匹配
    				// 最终获取一个当前方法参数和xml中配置的参数的
    				// 相差的权重值，值越小匹配度越高
    				int typeDiffWeight = (mbd.isLenientConstructorResolution() ?
    						argsHolder.getTypeDifferenceWeight(paramTypes) : argsHolder.getAssignabilityWeight(paramTypes));
    				// 如果是当前方法权重小于(优先级高于)当前的最小权重
    				if (typeDiffWeight < minTypeDiffWeight) { 
    					// 设置当前方法为要使用的工厂方法
    					factoryMethodToUse = candidate;
    					// 设置当前参数拥有者为要使用的
    					argsHolderToUse = argsHolder;
    					// 设置要使用的参数
    					argsToUse = argsHolder.arguments;
    					// 重新赋值当前最小权重
    					minTypeDiffWeight = typeDiffWeight;
    					// 设置模糊工厂方法set集合为空
    					ambiguousFactoryMethods = null;
    				}
    				// 满足以下条件：
    				// 1：当前要使用的工厂发不为空
    				// 2：当前放大权重和当前最小权重相同
    				// 3：是严格模式
    				// 4：真实参数个数和当前方法参数个数相同
    				// 5：参数类型不是完全相同
    				else if (factoryMethodToUse != null && typeDiffWeight == minTypeDiffWeight &&
    						!mbd.isLenientConstructorResolution() &&
    						paramTypes.length == factoryMethodToUse.getParameterCount() &&
    						!Arrays.equals(paramTypes, factoryMethodToUse.getParameterTypes())) { 
    					// 添加factoryMethodToUse即上一个(之前循环产生的)可能使用的工厂方法
    					// 和当前候选方法到模糊工厂方法集合中
    					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") + ".");
    		}
    		// 如果是方法的返回类型是void，则异常
    		// 因为要通过方法获取对象，所以不能为void
    		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);
    		}
    		// 缓存操作吧
    		if (explicitArgs == null && argsHolderToUse != null) { 
    			mbd.factoryMethodToIntrospect = factoryMethodToUse;
    			argsHolderToUse.storeCache(mbd, factoryMethodToUse);
    		}
    	}
    	// 断言工厂方法要使用的参数不为null
    	Assert.state(argsToUse != null, "Unresolved factory method arguments");
    	// <2021-03-22 14:44>
    	bw.setBeanInstance(instantiate(beanName, mbd, factoryBean, factoryMethodToUse, argsToUse));
    	return bw;
    }

`<2021-03-21 21:04>`处是通过工厂bean方法创建bean，详细参考`2.2.1：instantiate创建bean`。`<2021-03:22 09:58>`处是对方法进行排序，源码如下：

org.springframework.beans.factory.support.AutowireUtils#sortFactoryMethods
    public static void sortFactoryMethods(Method[] factoryMethods) { 
    	Arrays.sort(factoryMethods, EXECUTABLE_COMPARATOR);
    }

看下`EXECUTABLE_COMPARATOR`，源码如下：

org.springframework.beans.factory.support.AutowireUtils#EXECUTABLE_COMPARATOR
    private static final Comparator<Executable> EXECUTABLE_COMPARATOR = (e1, e2) -> { 
    	boolean p1 = Modifier.isPublic(e1.getModifiers());
    	boolean p2 = Modifier.isPublic(e2.getModifiers());
    	// 如果一个是public，一个不是public则是public
    	// 的把public的排在前面
    	if (p1 != p2) { 
    		return (p1 ? -1 : 1);
    	}
    	// 如果方法访问权限修饰符相同，则根据方法的参数的个数排序，多的排在前面
    	int c1pl = e1.getParameterCount();
    	int c2pl = e2.getParameterCount();
    	return Integer.compare(c2pl, c1pl);
    };

`<2021-03-22 14:44>`处是调用工厂方法创建bean，详细参考`2.2.1：instantiate创建bean`。

#### 2.2.1：instantiate创建bean ####

到这里的话，通过工厂方法所需要的工厂bean，工厂bean的工厂方法，调用工厂方法所需要的参数都已经确定完毕了，剩下的就是调用factory-bean的factory-method方法获取bean了。  
源码如下：

org.springframework.beans.factory.support.ConstructorResolver#instantiate(java.lang.String, org.springframework.beans.factory.support.RootBeanDefinition, java.lang.Object, java.lang.reflect.Method, java.lang.Object[])
    private Object instantiate(String beanName, RootBeanDefinition mbd,
    			@Nullable Object factoryBean, Method factoryMethod, Object[] args) { 
    
    	try{ 
    		// <2021-03-22 09:05>
    		if (System.getSecurityManager() != null) { 
    			return AccessController.doPrivileged((PrivilegedAction<Object>) () ->
    					this.beanFactory.getInstantiationStrategy().instantiate(
    							mbd, beanName, this.beanFactory, factoryBean, factoryMethod, args),
    					this.beanFactory.getAccessControlContext());
    		}
    		else { 
    			return this.beanFactory.getInstantiationStrategy().instantiate(
    					mbd, beanName, this.beanFactory, factoryBean, factoryMethod, args);
    		}
    	}
    	catch (Throwable ex) { 
    		throw new BeanCreationException(mbd.getResourceDescription(), beanName,
    				"Bean instantiation via factory method failed", ex);
    	}
    }

`<2021-03-22 09:05>`处不管是否需要安全认证，最终都是执行代码`this.beanFactory.getInstantiationStrategy().instantiate`，因此我们只需要看下这里的代码就可以了，源码如下：

org.springframework.beans.factory.support.SimpleInstantiationStrategy#instantiate(org.springframework.beans.factory.support.RootBeanDefinition, java.lang.String, org.springframework.beans.factory.BeanFactory, java.lang.Object, java.lang.reflect.Method, java.lang.Object...)
    public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner,
    			@Nullable Object factoryBean, final Method factoryMethod, Object... args) { 
    
    	try { 
    		// 设置factory-method对应的method对象可访问
    		if (System.getSecurityManager() != null) { 
    			AccessController.doPrivileged((PrivilegedAction<Object>) () -> { 
    				ReflectionUtils.makeAccessible(factoryMethod);
    				return null;
    			});
    		}
    		else { 
    			ReflectionUtils.makeAccessible(factoryMethod);
    		}
    		// 从threadlocal中获取当前正在执行的工厂方法
    		Method priorInvokedFactoryMethod = currentlyInvokedFactoryMethod.get();
    		try { 
    			// 设置正在执行的工厂方法为当前方法
    			currentlyInvokedFactoryMethod.set(factoryMethod);
    			// 反射执行返回，获取对象
    			Object result = factoryMethod.invoke(factoryBean, args);
    			// 如果是返回的对象为null，则使用NullBean
    			if (result == null) { 
    				result = new NullBean();
    			}
    			// 返回结果
    			return result;
    		}
    		finally { 
    			// 如果是之前正在执行的工厂方法不为null，
    			// 则重新设置回去，否则直接删除当前的
    			if (priorInvokedFactoryMethod != null) { 
    				currentlyInvokedFactoryMethod.set(priorInvokedFactoryMethod);
    			}
    			else { 
    				currentlyInvokedFactoryMethod.remove();
    			}
    		}
    	}
    	catch (IllegalArgumentException ex) {  // 参数错误异常
    		throw new BeanInstantiationException(factoryMethod,
    				"Illegal arguments to factory method '" + factoryMethod.getName() + "'; " +
    				"args: " + StringUtils.arrayToCommaDelimitedString(args), ex);
    	}
    	catch (IllegalAccessException ex) {  // 方法访问异常
    		throw new BeanInstantiationException(factoryMethod,
    				"Cannot access factory method '" + factoryMethod.getName() + "'; is it public?", ex);
    	}
    	catch (InvocationTargetException ex) { 
    		String msg = "Factory method '" + factoryMethod.getName() + "' threw exception";
    		if (bd.getFactoryBeanName() != null && owner instanceof ConfigurableBeanFactory &&
    				((ConfigurableBeanFactory) owner).isCurrentlyInCreation(bd.getFactoryBeanName())) { 
    			msg = "Circular reference involving containing bean '" + bd.getFactoryBeanName() + "' - consider " +
    					"declaring the factory method as static for independence from its containing instance. " + msg;
    		}
    		throw new BeanInstantiationException(factoryMethod, msg, ex.getTargetException());
    	}
    }

### 2.2：通过带有参数构造函数创建bean ###

此处是通过带有参数的构造函数来创建bean，源码如下：

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#autowireConstructor
    protected BeanWrapper autowireConstructor(
    			String beanName, RootBeanDefinition mbd, @Nullable Constructor<?>[] ctors, @Nullable Object[] explicitArgs) { 
    
    	return new ConstructorResolver(this).autowireConstructor(beanName, mbd, ctors, explicitArgs);
    }

继续：

org.springframework.beans.factory.support.ConstructorResolver#autowireConstructor
    public BeanWrapper autowireConstructor(String beanName, RootBeanDefinition mbd,
    			@Nullable Constructor<?>[] chosenCtors, @Nullable Object[] explicitArgs) { 
    	// 定义wrapper
    	BeanWrapperImpl bw = new BeanWrapperImpl();
    	// 设置用于数据类型转换的ConversionService和
    	this.beanFactory.initBeanWrapper(bw);
    	
    	// 要使用的构造函数
    	Constructor<?> constructorToUse = null;
    	// 要使用的构造函数参数封装对象
    	ArgumentsHolder argsHolderToUse = null;
    	// 最终用来调用构造函数的参数数组
    	Object[] argsToUse = null;
    	// 如果是现实传入的参数不为空，则使用传入的参数
    	if (explicitArgs != null) { 
    		argsToUse = explicitArgs;
    	}
    	// 解析
    	else { 
    		// 解析出的参数
    		Object[] argsToResolve = null;
    		synchronized (mbd.constructorArgumentLock) { 
    			// 尝试获取缓存的构造函数方法
    			constructorToUse = (Constructor<?>) mbd.resolvedConstructorOrFactoryMethod;
    			// 如果是缓存中有，并且构造函数函数参数也解析出来了
    			if (constructorToUse != null && mbd.constructorArgumentsResolved) { 
    				// 尝试从缓存中获取构造函数需要的参数
    				argsToUse = mbd.resolvedConstructorArguments;
    				// 如果是缓存中不存在构造函数使用的参数
    				if (argsToUse == null) { 
    					// 如果是缓存为空，则使用在db中准备的参数（此时的参数一般都是字符串，还不可以直接用来调用构造函数）
    					argsToResolve = mbd.preparedConstructorArguments;
    				}
    			}
    		}
    		// argsToResolve值可能是("1","1")，但是构造函数需要的是(1,1)
    		// 这里就是进行转换为构造函数可用的参数，然后赋值到argsToUse的Object数组对象
    		if (argsToResolve != null) { 
    			argsToUse = resolvePreparedArguments(beanName, mbd, bw, constructorToUse, argsToResolve, true);
    		}
    	}
    	// 如果是构造函数和构造函数要使用的参数都没有解析出来
    	if (constructorToUse == null || argsToUse == null) { 
    		// 先将传入的待选择的构造函数作为候选构造函数
    		Constructor<?>[] candidates = chosenCtors;
    		// 如果是候选构造函数为null
    		if (candidates == null) { 
    			// 获取bean的class类型
    			Class<?> beanClass = mbd.getBeanClass();
    			try { 
    				// 获取所有的构造函数作为候选构造函数
    				candidates = (mbd.isNonPublicAccessAllowed() ?
    						beanClass.getDeclaredConstructors() : beanClass.getConstructors());
    			}
    			catch (Throwable ex) { 
    				throw new BeanCreationException(mbd.getResourceDescription(), beanName,
    						"Resolution of declared constructors on bean Class [" + beanClass.getName() +
    						"] from ClassLoader [" + beanClass.getClassLoader() + "] failed", ex);
    			}
    		}
    		// 处理只有一个构造函数且构造函数没有参数情况的初始化
    		if (candidates.length == 1 && explicitArgs == null && !mbd.hasConstructorArgumentValues()) { 
    			Constructor<?> uniqueCandidate = candidates[0];
    			if (uniqueCandidate.getParameterCount() == 0) { 
    				synchronized (mbd.constructorArgumentLock) { 
    					mbd.resolvedConstructorOrFactoryMethod = uniqueCandidate;
    					mbd.constructorArgumentsResolved = true;
    					mbd.resolvedConstructorArguments = EMPTY_ARGS;
    				}
    				// 初始化，参考2.2.1：instantiate创建bean
    				bw.setBeanInstance(instantiate(beanName, mbd, uniqueCandidate, EMPTY_ARGS));
    				return bw;
    			}
    		}
    
    		// 是否需要解析构造函数
    		boolean autowiring = (chosenCtors != null ||
    				mbd.getResolvedAutowireMode() == AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR);
    		ConstructorArgumentValues resolvedValues = null;
    		// 构造函数参数的最小个数
    		int minNrOfArgs;
    		// 传入参数不为空，使用传入参数的个数作为当前最小个数
    		if (explicitArgs != null) { 
    			minNrOfArgs = explicitArgs.length;
    		}
    		else { 
    			// 从bd中解析参数
    			ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();
    			// 存储参数的对象
    			resolvedValues = new ConstructorArgumentValues();
    			// 存储参数到resolvedValues并返回参数的个数作为当掐你最小参数个数
    			minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);
    		}
    		// 按照public，非public，参数个数排序
    		AutowireUtils.sortConstructors(candidates);
    		// 权重，值越小优先级越大
    		int minTypeDiffWeight = Integer.MAX_VALUE;
    		Set<Constructor<?>> ambiguousConstructors = null;
    		LinkedList<UnsatisfiedDependencyException> causes = null;
    		// 循环候选构造函数，找到权重最大的作为目标构造函数
    		for (Constructor<?> candidate : candidates) { 
    			// 获取参数类型
    			Class<?>[] paramTypes = candidate.getParameterTypes();
    			// 期望的参数个数大于当前参数个数的直接break，这里break的原因
    			// 是已经按照参数从大到小排序了，后面的参数个数不会变多
    			if (constructorToUse != null && argsToUse != null && argsToUse.length > paramTypes.length) { 
    				break;
    			}
    			if (paramTypes.length < minNrOfArgs) { 
    				continue;
    			}
    			// 存储参数的对象
    			ArgumentsHolder argsHolder;
    			if (resolvedValues != null) { 
    				try { 
    					// 解析参数的名称
    					String[] paramNames = ConstructorPropertiesChecker.evaluate(candidate, paramTypes.length);
    					// 为空则从bd中获取
    					if (paramNames == null) { 
    						ParameterNameDiscoverer pnd = this.beanFactory.getParameterNameDiscoverer();
    						if (pnd != null) { 
    							paramNames = pnd.getParameterNames(candidate);
    						}
    					}
    					argsHolder = createArgumentArray(beanName, mbd, resolvedValues, bw, paramTypes, paramNames,
    							getUserDeclaredConstructor(candidate), autowiring, candidates.length == 1);
    				}
    				catch (UnsatisfiedDependencyException ex) { 
    					if (logger.isTraceEnabled()) { 
    						logger.trace("Ignoring constructor [" + candidate + "] of bean '" + beanName + "': " + ex);
    					}
    					// Swallow and try next constructor.
    					if (causes == null) { 
    						causes = new LinkedList<>();
    					}
    					causes.add(ex);
    					continue;
    				}
    			}
    			else { 
    				// Explicit arguments given -> arguments length must match exactly.
    				if (paramTypes.length != explicitArgs.length) { 
    					continue;
    				}
    				argsHolder = new ArgumentsHolder(explicitArgs);
    			}
    
    			int typeDiffWeight = (mbd.isLenientConstructorResolution() ?
    					argsHolder.getTypeDifferenceWeight(paramTypes) : argsHolder.getAssignabilityWeight(paramTypes));
    			// Choose this constructor if it represents the closest match.
    			if (typeDiffWeight < minTypeDiffWeight) { 
    				constructorToUse = candidate;
    				argsHolderToUse = argsHolder;
    				argsToUse = argsHolder.arguments;
    				minTypeDiffWeight = typeDiffWeight;
    				ambiguousConstructors = null;
    			}
    			else if (constructorToUse != null && typeDiffWeight == minTypeDiffWeight) { 
    				if (ambiguousConstructors == null) { 
    					ambiguousConstructors = new LinkedHashSet<>();
    					ambiguousConstructors.add(constructorToUse);
    				}
    				ambiguousConstructors.add(candidate);
    			}
    		}
    		// 如果是没有找到可用的构造函数，则异常
    		if (constructorToUse == null) { 
    			if (causes != null) { 
    				UnsatisfiedDependencyException ex = causes.removeLast();
    				for (Exception cause : causes) { 
    					this.beanFactory.onSuppressedException(cause);
    				}
    				throw ex;
    			}
    			throw new BeanCreationException(mbd.getResourceDescription(), beanName,
    					"Could not resolve matching constructor " +
    					"(hint: specify index/type/name arguments for simple parameters to avoid type ambiguities)");
    		}
    		// 存在模糊构造函数，此时无法确定具体是哪个，异常
    		else if (ambiguousConstructors != null && !mbd.isLenientConstructorResolution()) { 
    			throw new BeanCreationException(mbd.getResourceDescription(), beanName,
    					"Ambiguous constructor matches found in bean '" + beanName + "' " +
    					"(hint: specify index/type/name arguments for simple parameters to avoid type ambiguities): " +
    					ambiguousConstructors);
    		}
    		// 将构造函数和构造函数的擦书放到缓存中
    		if (explicitArgs == null && argsHolderToUse != null) { 
    			argsHolderToUse.storeCache(mbd, constructorToUse);
    		}
    	}
    
    	Assert.state(argsToUse != null, "Unresolved constructor arguments");
    	// <2021-03-24 17:15>
    	bw.setBeanInstance(instantiate(beanName, mbd, constructorToUse, argsToUse));
    	return bw;
    }

`<2021-03-24 17:15>`处是通过构造函数的方法创建bean，具体参考`2.2.1：通过带有参数构造函数创建bean`。

#### 2.2.1：通过带有参数构造函数创建bean ####

这里是通过带有参数的构造函数，以及其构造函数参数来创建bean，源码如下：

org.springframework.beans.factory.support.ConstructorResolver#instantiate(java.lang.String, org.springframework.beans.factory.support.RootBeanDefinition, java.lang.reflect.Constructor<?>, java.lang.Object[])
    private Object instantiate(
    			String beanName, RootBeanDefinition mbd, Constructor<?> constructorToUse, Object[] argsToUse) { 
    	try { 
    		// 获取初始化策略器
    		InstantiationStrategy strategy = this.beanFactory.getInstantiationStrategy();
    		if (System.getSecurityManager() != null) { 
    			return AccessController.doPrivileged((PrivilegedAction<Object>) () ->
    					strategy.instantiate(mbd, beanName, this.beanFactory, constructorToUse, argsToUse),
    					this.beanFactory.getAccessControlContext());
    		}
    		else { 
    			// <2021-03-24 17:26>
    			return strategy.instantiate(mbd, beanName, this.beanFactory, constructorToUse, argsToUse);
    		}
    	}
    	catch (Throwable ex) { 
    		throw new BeanCreationException(mbd.getResourceDescription(), beanName,
    				"Bean instantiation via constructor failed", ex);
    	}
    }

`<2021-03-24 17:26>`处源码如下：

`<2021-03-24 17:39>`处参考`2.2.2：通过CGLIB生成代理bean`。

#### 2.2.2：通过CGLIB生成代理bean ####

该处是通过CGLIB生成代理bean，源码如下：

org.springframework.beans.factory.support.CglibSubclassingInstantiationStrategy#instantiateWithMethodInjection(org.springframework.beans.factory.support.RootBeanDefinition, java.lang.String, org.springframework.beans.factory.BeanFactory, java.lang.reflect.Constructor<?>, java.lang.Object...)
    protected Object instantiateWithMethodInjection(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner,
    			@Nullable Constructor<?> ctor, Object... args) { 
    
    	// Must generate CGLIB subclass...
    	return new CglibSubclassCreator(bd, owner).instantiate(ctor, args);
    }

继续：

org.springframework.beans.factory.support.CglibSubclassingInstantiationStrategy.CglibSubclassCreator#instantiate
    public Object instantiate(@Nullable Constructor<?> ctor, Object... args) { 
    	// 通过bd生成子类的class对象
    	Class<?> subclass = createEnhancedSubclass(this.beanDefinition);
    	Object instance;
    	// 没有构造器则使用默认构造器创建
    	if (ctor == null) { 
    		instance = BeanUtils.instantiateClass(subclass);
    	}
    	// 存在构造器
    	else { 
    		try { 
    			// 通过参数类型，获取cglib动态生成的子类的对应的构造函数
    			Constructor<?> enhancedSubclassConstructor = subclass.getConstructor(ctor.getParameterTypes());
    			// 通过构造函数创建实例
    			instance = enhancedSubclassConstructor.newInstance(args);
    		}
    		catch (Exception ex) { 
    			throw new BeanInstantiationException(this.beanDefinition.getBeanClass(),
    					"Failed to invoke constructor for CGLIB enhanced subclass [" + subclass.getName() + "]", ex);
    		}
    	}
    	// 设置回调？？？
    	Factory factory = (Factory) instance;
    	factory.setCallbacks(new Callback[] { NoOp.INSTANCE,
    			new LookupOverrideMethodInterceptor(this.beanDefinition, this.owner),
    			new ReplaceOverrideMethodInterceptor(this.beanDefinition, this.owner)});
    	return instance;
    }

### 2.3：通过默认构造函数创建bean ###

此处是通过默认构造函数来创建bean，源码如下：

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#instantiateBean
    protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) { 
    	try { 
    		Object beanInstance;
    		final BeanFactory parent = this;
    		// 是否需要安全校验
    		if (System.getSecurityManager() != null) { 
    			beanInstance = AccessController.doPrivileged((PrivilegedAction<Object>) () ->
    					getInstantiationStrategy().instantiate(mbd, beanName, parent),
    					getAccessControlContext());
    		}
    		else { 
    			// <2021-03-24 17:57>
    			beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
    		}
    		// 封装到wrapper中
    		BeanWrapper bw = new BeanWrapperImpl(beanInstance);
    		initBeanWrapper(bw);
    		return bw;
    	}
    	catch (Throwable ex) { 
    		throw new BeanCreationException(
    				mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
    	}
    }

`<2021-03-24 17:57>`处是通过默认构造函数创建bean，源码如下：

org.springframework.beans.factory.support.SimpleInstantiationStrategy#instantiate(org.springframework.beans.factory.support.RootBeanDefinition, java.lang.String, org.springframework.beans.factory.BeanFactory)
    public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) { 
    	// 如果没有设置lookup-method，replaced-method
    	// 则直接创建，不需要生成代理
    	if (!bd.hasMethodOverrides()) { 
    		Constructor<?> constructorToUse;
    		synchronized (bd.constructorArgumentLock) { 
    			constructorToUse = (Constructor<?>) bd.resolvedConstructorOrFactoryMethod;
    			if (constructorToUse == null) { 
    				final Class<?> clazz = bd.getBeanClass();
    				if (clazz.isInterface()) { 
    					throw new BeanInstantiationException(clazz, "Specified class is an interface");
    				}
    				try { 
    					if (System.getSecurityManager() != null) { 
    						constructorToUse = AccessController.doPrivileged(
    								(PrivilegedExceptionAction<Constructor<?>>) clazz::getDeclaredConstructor);
    					}
    					else { 
    						// 获取没有参数的构造函数
    						constructorToUse = clazz.getDeclaredConstructor();
    					}
    					// 将构造函数赋值都bd中
    					bd.resolvedConstructorOrFactoryMethod = constructorToUse;
    				}
    				catch (Throwable ex) { 
    					throw new BeanInstantiationException(clazz, "No default constructor found", ex);
    				}
    			}
    		}
    		// 反射创建bean
    		return BeanUtils.instantiateClass(constructorToUse);
    	}
    	else { 
    		// 使用CGLIB生成子类，即代理类
    		return instantiateWithMethodInjection(bd, beanName, owner);
    	}
    }

[createBean]: https://blog.csdn.net/wang0907/article/details/114982913
[Link 1]: https://blog.csdn.net/wang0907/article/details/114980333
[Link 2]: https://blog.csdn.net/wang0907/article/details/115029827