Spring推断构造器源码分析
Spring中bean虽然可以通过多种方式（Supplier接口、FactoryMethod、构造器）创建bean的实例对象，但是使用最多的还是通过构造器创建对象实例，也是我们最熟悉的创建对象的方式。如果有多个构造器时，那Spring是如何推断使用哪个构造器来创建bean对象实例的？
一、Spring中创建对象实例的方式
（1） 通过构造器实例化对象
这是我们创建实例最常使用的方式，也是最常见的方式。
public class ObjectInstance {
private String createMode;
public ObjectInstance(String createMode) {
System.out.println("create by constructor");
this.createMode = createMode;
}
public ObjectInstance() {
}
public String getCreateMode() {
return createMode;
}
public void setCreateMode(String createMode) {
this.createMode = createMode;
}
@Override
public String toString() {
return "ObjectInstance{" +
"createMode='" + createMode + '\'' +
'}';
}
}
（2）通过工厂方法实例化对象
public class CrazyInstanceFactory {
//静态工厂方法
public static Object newInstanceForStatic(){
ObjectInstance objectInstance = new ObjectInstance();
objectInstance.setCreateMode("create by factory's static method");
return objectInstance;
}
//实例工厂方法
public Object newInstance(){
ObjectInstance objectInstance = new ObjectInstance();
objectInstance.setCreateMode("create by factory's instance method");
return objectInstance;
}
}（i）静态工厂方法
（ii）实例工厂方法
（3）通过实现FactoryBean接口实例化对象
public class CrazyFactoryBean implements FactoryBean {
@Override
public ObjectInstance getObject() throws Exception {
ObjectInstance objectInstance = new ObjectInstance();
objectInstance.setCreateMode("create by FactoryBean");
return objectInstance;
}
@Override
public Class getObjectType() {
return null;
}
@Override
public boolean isSingleton() {
return true;
}
}
（4）通过Supplier实例化对象
public class SupplierObj{
private String version;
private int num;
public SupplierObj() {
}
public String getVersion() {
return version;
}
public void setVersion(String version) {
this.version = version;
}
public int getNum() {
return num;
}
public void setNum(int num) {
this.num = num;
}
@Override
public String toString() {
return "SupplierObj{" +
"version='" + version + '\'' +
", num=" + num +
'}';
}
}使用BeanFactoryPostProcessor对beanDefinition信息进行修改，为其通过一个Supplier,用于实例化bean。
Supplier接口只有一个方法，我们可以用简化语法创建匿名接口实现类。
@FunctionalInterface
public interface Supplier {
/**
* Gets a result.
*
* @return a result
*/
T get();
} public class MyPostProcessor implements BeanFactoryPostProcessor {
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
GenericBeanDefinition beanDefinition = (GenericBeanDefinition)beanFactory.getBeanDefinition("supplierObj");
//beanDefinition.getConstructorArgumentValues().addIndexedArgumentValue();
beanDefinition.setInstanceSupplier(() -> {
SupplierObj supplierObj1 = new SupplierObj();
return supplierObj1;
});
}
}
二、推断构造器
（1）doCreateBean()，创建bean实例对象。
doCreateBean()方法是Spring进行Bean创建的核心方法，它包含三个参数：
- String beanName,就是bean的id或anme；
- RootBeanDefinition mbd，Spring Bean在没有被创建之前，bean的信息（xml配置bean及注解注入的信息）会被解析成BeanDefinition对象，我们知道Class是描述Java对象信息的,那么BeanDefinition就是描述Spring Bean信息的；
- Object[] args，构造器参数。这个值默认为null，除非程序员自己调用api传入参数。
这个方法中会调用多次后置处理器，用于推断构造器、完成BD合并、解决循环依赖、解析注解等。我们今天主要看关于自动装配相关的内容，所以给这个方法省略了一些内容。
首先是推断构造器，通过合适的构造器创建bean的实例，然后对实例进行属性填充。
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
// Instantiate the bean.
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
//第二次调用后置处理器的入口方法（推断构造方法）
//代码块一：创建实例bean
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
……
//填充属性
//调用第五次和第六次后置处理器的地方
populateBean(beanName, mbd, instanceWrapper);
return exposedObject;
}（2） createBeanInstance()，根据特定的bean及实例化策略创建一个bean实例。
实例化一个bean的方式包括Supplier接口、FactoryMethod、构造器等。
spring会缓存一些关于对象创建中比较复杂的操作，方便在原型下bean创建可以直接获取到对象创建的方式，而不是又进行复杂的推断。
resolved表示创建对象的构造方法有没有被解析过 。为什么要有这个标签？
方便spring快速的创建对象 ，因为创建对象时，推断构造方法是个很复杂的过程，在创建原型bean时，可以只推断一次，后续不用在执行这个复杂的操作 。
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);
//判断beanClass是否不符合要求
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());
}
//这段代码的含义是？spring提供了一个Supplier接口，用于实例化bean
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...
//resolved表示创建对象的构造方法有没有被解析过
/**
* 为什么要有这个标签？
* 方便spring快速的创建对象
* 因为创建对象时，推断构造方法是个很复杂的过程，在创建原型bean时，可以只推断一次，后续不用在执行这个复杂的操作
*/
boolean resolved = false;
//构造函数参数是否被解析过
boolean autowireNecessary = false;
//args是goGetBean(……,args,……)的入参，spring自身传入为null
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);
}
}
//推断构造方法，有多个构造方法是，推断出最合适的，如果只有一个构造方法，返回null（不用推断）
// Candidate constructors for autowiring?
//第二次调用后置处理器
//代码块二：推断构造方法
Constructor[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
//如果自动注入的方式为构造器注入，会再一次推断构造方法
if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
//代码三：确定构造方法参数的值
return autowireConstructor(beanName, mbd, ctors, args);
}
// Preferred constructors for default construction?
ctors = mbd.getPreferredConstructors();
if (ctors != null) {
return autowireConstructor(beanName, mbd, ctors, null);
}
// No special handling: simply use no-arg constructor.
return instantiateBean(beanName, mbd);
}（3）代码块二：determineCandidateConstructors()，推断构造器
推断构造器是通过一个后置处理器AutowiredAnnotationBeanPostProcessor来完成的，这个后置处理器是Spring启动时自添加的。
@Override
@Nullable
public Constructor[] determineCandidateConstructors(Class beanClass, final String beanName)
throws BeanCreationException {
// 省略lookup methods检查
//先从缓存中拿，拿不到再进行推断
// 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 {
//getDeclared拿到所有类型的（public、protected、private）,但不会拿父类的
//拿到所有的构造器
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> candidates = new ArrayList<>(rawCandidates.length);
Constructor requiredConstructor = null;
Constructor defaultConstructor = null;
//没有使用到kotlin时永远返回null
Constructor primaryConstructor = BeanUtils.findPrimaryConstructor(beanClass);
int nonSyntheticConstructors = 0;
for (Constructor candidate : rawCandidates) {
if (!candidate.isSynthetic()) {
nonSyntheticConstructors++;
}
else if (primaryConstructor != null) {
continue;
}
MergedAnnotation ann = findAutowiredAnnotation(candidate);
if (ann == null) {
//beanClass是个CGLIB代理类，找到父类
Class userClass = ClassUtils.getUserClass(beanClass);
if (userClass != beanClass) {
try {
Constructor superCtor =
userClass.getDeclaredConstructor(candidate.getParameterTypes());
ann = findAutowiredAnnotation(superCtor);
}
catch (NoSuchMethodException ex) {
// Simply proceed, no equivalent superclass constructor found...
}
}
}
if (ann != null) {
//已经有@Autowired(required=true)标记的构造器时，如果再出现@Autowired标记的构造器时会抛出异常
if (requiredConstructor != null) {
throw new BeanCreationException(beanName,
"Invalid autowire-marked constructor: " + candidate +
". Found constructor with 'required' Autowired annotation already: " +
requiredConstructor);
}
boolean required = determineRequiredStatus(ann);
if (required) {
//有多个加了构造器@Autowired或@Value注解
if (!candidates.isEmpty()) {
throw new BeanCreationException(beanName,
"Invalid autowire-marked constructors: " + candidates +
". Found constructor with 'required' Autowired annotation: " +
candidate);
}
//@Autowired(required=true)的构造器才会设置为requiredConstructor
requiredConstructor = candidate;
}
//只有添加了构造方法上加了@Autowired或@Value注解，该构造方法都会放入candidates
candidates.add(candidate);
}
else if (candidate.getParameterCount() == 0) {
//defaultConstructor设置为无参构造器
defaultConstructor = candidate;
}
}
if (!candidates.isEmpty()) {
// Add default constructor to list of optional constructors, as fallback.
if (requiredConstructor == null) {
if (defaultConstructor != null) {
//如果candidates不能空，且无确定的构造方法，添加默认的构造方法到可选列表中
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));
}
}
//将candidates转换为构造器数组
candidateConstructors = candidates.toArray(new Constructor[0]);
}
//仅当一个有参构造方法时，才会返回这个构造方法
else if (rawCandidates.length == 1 && rawCandidates[0].getParameterCount() > 0) {
candidateConstructors = new Constructor[] {rawCandidates[0]};
}
// primaryConstructor永远为null
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 {
//空构造器数组
candidateConstructors = new Constructor[0];
}
this.candidateConstructorsCache.put(beanClass, candidateConstructors);
}
}
}
return (candidateConstructors.length > 0 ? candidateConstructors : null);
} 这个方法大致总结为：
1）先从缓存中获取候选构造器数组， 如果能获取成功，判断数组长度是否大于0，大于0则返回这个构造器数组，否则返回null。不存在缓存则进行步骤2。
2）获取beanClass中的所有类型的构造器（public、protected、private），存放到rawCandidates数组。创建一个存放候选构造器的List集合candidates，长度为 rawCandidates数组的长度，创建三个构造器类型的变量requiredConstructor（存储@Autowired(required = true)标记的构造器）、defaultConstructor（存储默认的构造器）和primaryConstructor（没有使用到kotlin时永远返回null
），创建一个int类型的变量nonSyntheticConstructors，用于记录beanClass非合成构造器的个数。
3）遍历rawCandidates数组，如果当前的构造器对象为非合成构造器nonSyntheticConstructors计数器+1。定义一个MergedAnnotation类型变量ann,存放当前构造器的Autowired注解信息，如果当前beanClass的ann为null，判断beanClass是否为CGLIB代理类，如果是，将父类相同（参数类型相同）构造器上的Autowired注解信息赋值给ann。
（a）如果注解信息ann不为null
（i）判断requiredConstructor是否为null，如果不为null，说明beanClass中已经存在一个@Autowired(required=true)的构造器，抛出异常！
（ii）获取当前构造器上的注解信息ann的required属性值，如果为true，如果候选构造器的List集合candidates不为空，抛出异常。否则将当前构造器赋值给requiredConstructor变量。
（iii）将当前构造器加入到候选构造器的List集合candidates中。
（b) 如果注解信息ann为null
如果当前构造器为无参构造器，将当前构造器赋值给defaultConstructor变量。
4）完成遍历后，有如下几种情况
（a）candidates不为空的情况，如果requiredConstructor为null，defaultConstructor不为null，将defaultConstructor加入候选构造器集合candidates中。将candidates转换为构造器数组对象。
（b）rawCandidates数组长度为1且其中的构造器参数个数大于0（仅当一个有参构造方法时，才会返回这个构造方法），将这个构造器对象封装成构造器数组对象。
（c）nonSyntheticConstructors==2（beanClass只有两个非合成构造器）且primaryConstructor不为null(没有使用到kotlin时永远返回null)，将primaryConstructor和defaultConstructor封装成构造器数组对象。
（d）nonSyntheticConstructors==1且primaryConstructor不为null(没有使用到kotlin时永远返回null)，将primaryConstructorr封装成构造器数组对象。
（e）不是以上情况，返回空构造器数组对象。
5）将构造器数组对象缓存到spring容器中，并返回这个数组对象。
（3）代码块三：autowireConstructor()，确定构造器及构造器方法参数的值，完成对象实例化。
通过推断构造器方法只是推断出合适的构造器，但是可能存在多个候选构造器的情况，而且构造器的参数值也还没有确定，接下来就是确定构造方法参数的值，并完成对象的实例化。
{
……
Constructor[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
//如果自动注入的方式为构造器注入，会再一次推断构造方法
if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
//确定构造方法参数的值
return autowireConstructor(beanName, mbd, ctors, args);
}
……
}
protected BeanWrapper autowireConstructor(
String beanName, RootBeanDefinition mbd, @Nullable Constructor[] ctors, @Nullable Object[] explicitArgs) {
return new ConstructorResolver(this).autowireConstructor(beanName, mbd, ctors, explicitArgs);
}
//这里只是简单初始化
public ConstructorResolver(AbstractAutowireCapableBeanFactory beanFactory) {
this.beanFactory = beanFactory;
this.logger = beanFactory.getLogger();
}这里定义了很多中间变量，如：
//最终使用的构造方法 Constructor constructorToUse = null; //最终使用的参数持有者，维护了参数差异值比较的方法 ArgumentsHolder argsHolderToUse = null; //最终使用的构造方法参数 Object[] argsToUse = null; //这个值默认为null，除非程序员自己调用api传入参数 //createBean(beanName, mbd, args);中args即是explicitArgs Object[] explicitArgs; //解析出来的构造器参数值 //解析出来的参数不一定就是可以直接注入的属性，需要进行转换 //如或如 //需要转换成具体的Bean才能注入 Object[] argsToResolve = null; //最小参数个数,如果手动设置构造器参数，createBean(beanName, mbd, args)或 //xml配置了 //或设置了BeanDefinition.getConstructorArgumentValues().addArgumentValues(); //最小参数个数就是设置参数的个数 int minNrOfArgs;
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;
//构造器参数。这个值默认为null，除非程序员自己调用api传入参数
//createBean(beanName, mbd, args);中args即是explicitArgs
if (explicitArgs != null) {
argsToUse = explicitArgs;
}
else {
//解析出来的构造参数
Object[] argsToResolve = null;
synchronized (mbd.constructorArgumentLock) {
//尝试从缓存中获取
constructorToUse = (Constructor) mbd.resolvedConstructorOrFactoryMethod;
if (constructorToUse != null && mbd.constructorArgumentsResolved) {
// Found a cached constructor...
//从缓存中获取构造参数
argsToUse = mbd.resolvedConstructorArguments;
if (argsToUse == null) {
//构造器中没有缓存构造参数，就需要获取preparedConstructorArguments
//部分准备好的构造函数参数，不是最终使用的构造器参数，需要转换
argsToResolve = mbd.preparedConstructorArguments;
}
}
}
if (argsToResolve != null) {
//解析出来的参数不一定就是可以直接注入的属性，需要进行转换
//如> ambiguousConstructors = null;
Deque causes = null;
for (Constructor candidate : candidates) {
int parameterCount = candidate.getParameterCount();
//因为进行了排序，如果当前的parameterCount parameterCount) {
// Already found greedy constructor that can be satisfied ->
// do not look any further, there are only less greedy constructors left.
break;
}
//当前构造方法参数个数不满足要求，跳过本次循环
if (parameterCount < minNrOfArgs) {
continue;
}
// 参数持有者
ArgumentsHolder argsHolder;
//构造器参数类型数组
Class[] paramTypes = candidate.getParameterTypes();
if (resolvedValues != null) {
try {
//得到当前构造器的方法参数名字数组
String[] paramNames = ConstructorPropertiesChecker.evaluate(candidate, parameterCount);
if (paramNames == null) {
ParameterNameDiscoverer pnd = this.beanFactory.getParameterNameDiscoverer();
if (pnd != null) {
paramNames = pnd.getParameterNames(candidate);
}
}
//根据构造方法参数名数组和构造器参数值构建argsHolder
//这个方法是遍历构造器的参数名字和参数类型，找到与之匹配的resolvedValues中的ValueHolder值，并封装成ArgumentsHolder对象
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 ArrayDeque<>(1);
}
causes.add(ex);
continue;
}
}
else {
// Explicit arguments given -> arguments length must match exactly.
if (parameterCount != explicitArgs.length) {
continue;
}
argsHolder = new ArgumentsHolder(explicitArgs);
}
//计算差异值，当多个构造方法的参数个数相同时，通过差异值决定使用哪个构造方法
//mbd.isLenientConstructorResolution()是否为宽松模式，默认是宽松模式
int typeDiffWeight = (mbd.isLenientConstructorResolution() ?
argsHolder.getTypeDifferenceWeight(paramTypes) : argsHolder.getAssignabilityWeight(paramTypes));
// Choose this constructor if it represents the closest match.
//如果当前构造器的差异值比minTypeDiffWeight小，将当前构造器的差异值赋值给minTypeDiffWeight变量
if (typeDiffWeight < minTypeDiffWeight) {
//最终使用的构造器constructorToUse赋值为当前构造器
constructorToUse = candidate;
//最终使用的参数持有者argsHolderToUse赋值为当前的argsHolder
argsHolderToUse = argsHolder;
//最终使用的构造器参数argsToUse赋值为当前的argsHolder的arguments
argsToUse = argsHolder.arguments;
minTypeDiffWeight = typeDiffWeight;
ambiguousConstructors = null;
}
else if (constructorToUse != null && typeDiffWeight == minTypeDiffWeight) {
// 如果两个构造器的差异值相等，就会将它放入ambiguousConstructors中
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) {
//代码块五：将推断出来的构造方法信息缓存到BD中
argsHolderToUse.storeCache(mbd, constructorToUse);
}
}
Assert.state(argsToUse != null, "Unresolved constructor arguments");
//根据推断出来的构造器及其参数创建bean实例，并封装到bw对象中
bw.setBeanInstance(instantiate(beanName, mbd, constructorToUse, argsToUse));
return bw;
} 这个方法大致总结为：
1）先后bd缓存中获取构造函数的相关信息（构造器、构造参数），如果缓存是部分准备好的构造函数参数，需要转换成最终可使用的构造参数。
2）缓存中获取构造器或构造参数失败，有如下两种情况：
a.通过determineCandidateConstructors()推断出来的构造器不为null,直接将推断出来的构造器存放到构造器数组candidates。
b.通过determineCandidateConstructors()推断出来的构造器为null,拿到当前beanClass中的所有构造器，存放到构造器数组candidates。
3）如果candidates中只有一个构造器且为无参构造，将该构造器信息缓存到bd中，同时通过这个无参构造器创建bean实例对象，并封装到BeanWrapperImpl中返回。
4）设置构造器最小参数值minNrOfArgs。如果手动设置了构造器参数，最小参数值就为设置的参数的个数。（通过createBean(beanName, mbd, args)api设置args或者通过xml中
5）对candidates中的构造器进行排序。创建构造器差异值变量minTypeDiffWeight，并将其赋值为Integer.MAX_VALUE（构造器差异值最小的即为最优解）;创建 ambiguousConstructors 变量用于存放模棱两可的构造器。
6）遍历candidates，获取当前构造器的参数个数parameterCount，如果上一个回合已经推断出constructorToUse和argsToUse,且argsToUse的长度大于当前构造器的参数个数，直接退出遍历。（因为进行了排序，如果当前的parameterCount 7）如果当前构造器的个数parameterCount 小于最小构造器参数个数minNrOfArgs，跳过本次循环，进行下次循环（pubulic修饰的构造器不满足，可能protected或private修饰的构造器满足）。 8）构建参数持有者ArgumentsHolder argsHolder，获取当前构造器的构造器参数类型数组Class[] paramTypes。 （i）resolvedValues值不为空。获取当前构造器参数名字数组。遍历构造器的参数名字和参数类型数组，找到与之匹配的resolvedValues中的ValueHolder值，并封装成ArgumentsHolder对象。 （ii)explicitArgs不为空，直接通过explicitArgs构建ArgumentsHolder对象。 9）计算差异值，当多个构造方法的参数个数相同时，通过差异值决定使用哪个构造方法。 （i）如果当前构造器的差异值比minTypeDiffWeight小，将当前构造器的差异值赋值给minTypeDiffWeight变量，并把最终使用的构造器constructorToUse赋值为当前构造器 constructorToUse = candidate; 最终使用的参数持有者argsHolderToUse赋值为当前的argsHolder argsHolderToUse = argsHolder; 最终使用的构造器参数argsToUse赋值为当前的argsHolder的arguments。同时将ambiguousConstructors值设置为null. （ii） 如果当前构造器的差异值与minTypeDiffWeig相等，就会将它放入ambiguousConstructors（如果为null，先创建ambiguousConstructors）中。 10）如果存在模棱两可的构造器且不是宽松模式下，抛出异常。严格模式下，spring认为不能存在摸棱两可的构造器，而且宽松模式和严格模式下差异值计算的算法也不一样。spring默认为宽松模式。 11）将推断出来的构造方法信息缓存到BD中,并根据推断出来的构造器及其参数创建bean实例，并封装到bw对象中返回。 构造器的排序规则。public修饰的构造器排在前面，如果同为public类型，比较构造器的参数个数，参数个数多的排在前面。 spring推断构造方法分如下几种情况： （1）不使用自动装配时。 1）无构造方法或只有一个无参构造方法的情况下，返回null 2）有且只有一个有参构造方法时，返回这个有参构造方法 3）有多个构造方法时，返回null （2）使用@Autowired注入时. 1）如果只有一个构造方法添加了@Autowired(required=true),返回这个构造方法 2）如果有一个构造方法添加了@Autowired(required=true)，其他构造方法再添加@Autowired注解，抛出异常 3）如果有多个构造方法添加了@Autowired(required=false），除了返回所以加了@Autowired(required=false）的构造方法，如果提供了无参构造方法，也会返回无参构造方法，后续继续推断构造方法。 （3）使用自动注入时。 根据构造方法的参数类型或参数个数找到最优的构造方法，默认最优的为参数类型为spring中依赖最多，且参数个数最长的那个。（i）代码块四：构造器排序规则
public static final Comparator（ii）代码块五：storeCache()，将推断出来的构造方法信息缓存到BD中
//将推断出来的构造方法信息缓存到BD中
public void storeCache(RootBeanDefinition mbd, Executable constructorOrFactoryMethod) {
synchronized (mbd.constructorArgumentLock) {
mbd.resolvedConstructorOrFactoryMethod = constructorOrFactoryMethod;
mbd.constructorArgumentsResolved = true;
if (this.resolveNecessary) {
mbd.preparedConstructorArguments = this.preparedArguments;
}
else {
mbd.resolvedConstructorArguments = this.arguments;
}
}
}
}三、总结