在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);
.....
// BeanDefinition中添加了Supplier，则调用Supplier来得到对象
Supplier instanceSupplier = mbd.getInstanceSupplier();
if (instanceSupplier != null) {
return obtainFromSupplier(instanceSupplier, beanName);
}
// @Bean对应的BeanDefinition
if (mbd.getFactoryMethodName() != null) {
return instantiateUsingFactoryMethod(beanName, mbd, args);
}
// Shortcut when re-creating the same bean...
// 一个原型BeanDefinition，会多次来创建Bean，那么就可以把该BeanDefinition所要使用的构造方法缓存起来，避免每次都进行构造方法推断
boolean resolved = false;
boolean autowireNecessary = false;
if (args == null) {
synchronized (mbd.constructorArgumentLock) {
if (mbd.resolvedConstructorOrFactoryMethod != null) {
resolved = true;
// autowireNecessary表示有没有必要要进行注入，比如当前BeanDefinition用的是无参构造方法，那么autowireNecessary为false，否则为true，表示需要给构造方法参数注入值
autowireNecessary = mbd.constructorArgumentsResolved;
}
}
}
if (resolved) {
// 如果确定了当前BeanDefinition的构造方法，那么看是否需要进行对构造方法进行参数的依赖注入（构造方法注入）
if (autowireNecessary) {
// 方法内会拿到缓存好的构造方法的入参
return autowireConstructor(beanName, mbd, null, null);
}
else {
// 构造方法已经找到了，但是没有参数，那就表示是无参，直接进行实例化
return instantiateBean(beanName, mbd);
}
}
// 如果没有找过构造方法，那么就开始找了
// Candidate constructors for autowiring?
// 提供一个扩展点，可以利用SmartInstantiationAwareBeanPostProcessor来控制用beanClass中的哪些构造方法
// 比如AutowiredAnnotationBeanPostProcessor会把加了@Autowired注解的构造方法找出来，具体看代码实现会更复杂一点
Constructor[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
// 如果推断出来了构造方法，则需要给构造方法赋值，也就是给构造方法参数赋值，也就是构造方法注入
// 如果没有推断出来构造方法，但是autowiremode为AUTOWIRE_CONSTRUCTOR，则也可能需要给构造方法赋值，因为不确定是用无参的还是有参的构造方法
// 如果通过BeanDefinition指定了构造方法参数值，那肯定就是要进行构造方法注入了
// 如果调用getBean的时候传入了构造方法参数值，那肯定就是要进行构造方法注入了
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);
}
在Spring框架中的AbstractAutowireCapableBeanFactory类中的createBeanInstance()方法是用来执行实例化Bean对象的操作，该方法会根据Bean定义信息和配置选项，经过一系列步骤和逻辑判断，最终创建一个全新的Bean实例。大致步骤如下：
- 根据BeanDefinition加载类并获取对应的Class对象
- 如果BeanDefinition绑定了一个Supplier，那么应调用Supplier的get方法以获取一个对象，并将其直接返回。
- 如果在BeanDefinition中存在factoryMethodName属性，则调用该工厂方法以获取一个bean对象，并将其返回。
- 如果BeanDefinition已经自动构造过了，那么就调用autowireConstructor()方法来自动构造一个对象。
- 调用SmartInstantiationAwareBeanPostProcessor接口的determineCandidateConstructors()方法，以确定哪些构造方法是可用的。
- 如果存在可用的构造方法，或者当前BeanDefinition的autowired属性设置为AUTOWIRE_CONSTRUCTOR，或者BeanDefinition中指定了构造方法参数值，或者在创建Bean时指定了构造方法参数值，那么将调用autowireConstructor()方法来自动构造一个对象。
- 最后，如果不符合前述情况，那么将根据不带参数的构造方法来实例化一个对象。
推断构造方法
我们看下源码：
public Constructor[] determineCandidateConstructors(Class beanClass, final String beanName)
throws BeanCreationException {
//前面跟@Lookup相关，我们不看
.....
// 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 {
// 拿到所有的构造方法
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);
// 用来记录required为true的构造方法，一个类中只能有一个required为true的构造方法
Constructor requiredConstructor = null;
// 用来记录默认无参的构造方法
Constructor defaultConstructor = null;
......
int nonSyntheticConstructors = 0;
// 遍历每个构造方法
for (Constructor candidate : rawCandidates) {
if (!candidate.isSynthetic()) {
// 记录一下普通的构造方法
nonSyntheticConstructors++;
}
else if (primaryConstructor != null) {
continue;
}
// 当前遍历的构造方法是否写了@Autowired
MergedAnnotation ann = findAutowiredAnnotation(candidate);
if (ann == null) {
// 如果beanClass是代理类，则得到被代理的类的类型,我们不看这种情况
.......
}
// 当前构造方法上加了@Autowired
if (ann != null) {
// 整个类中如果有一个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) {
if (!candidates.isEmpty()) {
throw new BeanCreationException(beanName,
"Invalid autowire-marked constructors: " + candidates +
". Found constructor with 'required' Autowired annotation: " +
candidate);
}
// 记录唯一一个required为true的构造方法
requiredConstructor = candidate;
}
// 记录所有加了@Autowired的构造方法，不管required是true还是false
// 如果默认无参的构造方法上也加了@Autowired，那么也会加到candidates中
candidates.add(candidate);
// 从上面代码可以得到一个结论，在一个类中，要么只能有一个required为true的构造方法，要么只能有一个或多个required为false的方法
}
else if (candidate.getParameterCount() == 0) {
// 记录唯一一个无参的构造方法
defaultConstructor = candidate;
}
// 有可能存在有参、并且没有添加@Autowired的构造方法
}
if (!candidates.isEmpty()) {
// Add default constructor to list of optional constructors, as fallback.
// 如果不存在一个required为true的构造方法，则所有required为false的构造方法和无参构造方法都是合格的
if (requiredConstructor == null) {
if (defaultConstructor != null) {
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));
}
}
// 如果只存在一个required为true的构造方法，那就只有这一个是合格的
candidateConstructors = candidates.toArray(new Constructor[0]);
}
// 没有添加了@Autowired注解的构造方法，并且类中只有一个构造方法，并且是有参的
else if (rawCandidates.length == 1 && rawCandidates[0].getParameterCount() > 0) {
candidateConstructors = new Constructor[] {rawCandidates[0]};
}
......
else {
// 如果有多个有参、并且没有添加@Autowired的构造方法，是会返回空的
candidateConstructors = new Constructor[0];
}
this.candidateConstructorsCache.put(beanClass, candidateConstructors);
}
}
}
return (candidateConstructors.length > 0 ? candidateConstructors : null);
}
接下来，让我们更深入地探讨推断构造方法，并且我还简单绘制了一张图示。
通常情况下，一个类通常只包含一个构造方法：
要么是无参的构造方法，要么是有参的构造方法。
如果一个类只有一个无参构造方法，那么在实例化时只能使用这个构造方法；而如果一个类只有一个有参构造方法，实例化时是否可以使用这个构造方法则取决于具体情况：
- 使用AnnotationConfigApplicationContext进行实例化时，Spring会根据构造方法的参数信息去寻找对应的bean，并将找到的bean传递给构造方法。这样可以实现依赖注入，确保实例化的对象具有所需的依赖项。
- 当使用ClassPathXmlApplicationContext时，表明使用XML配置文件的方式来定义bean。在XML中，可以手动指定构造方法的参数值来实例化对象，也可以通过配置autowire=constructor属性，让Spring自动根据构造方法的参数类型去寻找对应的bean作为参数值，实现自动装配。
上面是只有一个构造方法的情况，那么如果一个类存在多个构造方法，那么Spring进行实例化之前，该如何去确定到底用哪个构造方法呢？
- 如果开发者明确定义了他们想要使用的构造方法，那么程序将会优先使用这个构造方法。
- 如果开发者没有明确指定他们想要使用的构造方法，系统会自动检查开发者是否已经配置了让Spring框架自动选择构造方法的选项。
- 如果开发者没有显式地指定让Spring框架自动选择构造方法的情况下，Spring将会默认尝试使用无参构造方法。如果目标类中没有无参构造方法，则系统将会抛出错误提示。
针对第一点，开发者可以通过什么方式来指定使用哪个构造方法呢？
- 在XML中，
标签用于表示构造方法的参数。开发者可以根据这个标签确定所需使用的构造方法的参数个数，从而精确指定想要使用的构造方法。 - 通过@Autowired注解，我们可以在构造方法上使用@Autowired注解。因此，当我们在特定构造方法上使用@Autowired注解时，表示开发者希望使用该构造方法。与通过xml方式直接指定构造方法参数值的方式不同，@Autowired注解方式需要Spring通过byType+byName的方式来查找符合条件的bean作为构造方法的参数值。
- 当然，还有一种情况需要考虑，即当多个构造方法上都标注了@Autowired注解时，此时Spring会抛出错误。然而，由于@Autowired注解具有一个required属性，默认值为true，因此在一个类中只能有一个构造方法标注了@Autowired或者@Autowired(required=true)，否则会导致错误。不过，可以有多个构造方法标注@Autowired(required=false)。在这种情况下，Spring会自动从这些构造方法中选择一个进行注入。
在第二种情况下，如果开发者没有明确指定要使用的构造方法，Spring将尝试自动选择一个合适的构造方法进行注入。这种情况下，只能通过ClassPathXmlApplicationContext实现，因为使用AnnotationConfigApplicationContext无法指定让Spring自动选择构造方法。通过ClassPathXmlApplicationContext，可以在XML配置文件中指定某个bean的autowire属性为constructor，从而告诉Spring可以自动选择构造方法。
总结
在Spring中，实例化Bean对象涉及构造方法的调用。通过分析源码，我们了解到实例化的步骤和推断构造方法的过程。当一个类只有一个构造方法时，Spring会根据具体情况决定是否使用该构造方法。如果一个类存在多个构造方法，就需要根据具体情况具体分析。本文简单判断了哪些构造方法是符合实例化的，但在存在多个符合条件的构造方法时，具体使用哪个构造方法尚未讨论。因此，我计划单独写一篇文章来详细讨论这个问题。毕竟是太复杂了。