// AbstractAutowireCapableBeanFactory
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
		throws BeanCreationException {
	// Instantiate the bean.
	BeanWrapper instanceWrapper = null;
	if (mbd.isSingleton()) {
		instanceWrapper = this.factoryBeanInstanceCache.remove(beanName); // 从FactoryBean缓存列表中移除
	}
	/*
	 * 第一步：实例化Bean。
	 * 使用合适的实例化策略来实例化新的Bean：回调函数、工厂方法、带参的构造函数、无参构造函数。默认调用无参构造器实例化Bean。
	 * 构造参数注入发生在这一步
	 */
	if (instanceWrapper == null) { // 为null，说明不是FactoryBean，那么调用工厂或者构造函数实例化Bean
		instanceWrapper = createBeanInstance(beanName, mbd, args);
	}
	// 省略掉大量代码，这些代码用于初始化Bean、属性赋值、循环依赖处理等
	return exposedObject;
}

实例化入口：createBeanInstance()

这个方法中的代码，是Spring实例化Bean的核心代码

// AbstractAutowireCapableBeanFactory
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
	// Make sure bean class is actually resolved at this point.
	// 从bean定义中解析出当前bean的class对象
	Class<?> beanClass = resolveBeanClass(mbd, beanName);

	// 检测类的访问权限。对于非public类，默认是允许访问的；若被设置为禁止访问非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());
	}

	/*
	 * 这是Spring5开始提供的实例化方式，提供一个回调函数实例化Bean
	 * 需要自己创建BeanDefinition对象，并指定回调函数，然后注册到IoC容器中
	 * 后文有一个如何使用的简单例子
	 */
	Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
	if (instanceSupplier != null) {
	    // 这里的代码很简单，就是执行回调函数获取Bean的实例
		return obtainFromSupplier(instanceSupplier, beanName);
	}

	/*
	 * 判断是不是使用工厂实例化Bean，工厂方法名称不为空，即表示使用工厂方法进行实例化。
	 * 无论是静态工厂还是实例工厂，都是走这一步
	 * 通过Java配置类配置的Bean，实例化方式采用的是实例工厂方法，工厂实例就是Java配置类的代理对象
	 */
	if (mbd.getFactoryMethodName() != null) {
		return instantiateUsingFactoryMethod(beanName, mbd, args);
	}

	// Shortcut when re-creating the same bean...
	// Spring的注释说，这是重复实例化相同Bean时的快捷方式
	boolean resolved = false; // 判断Bean定义中的构造函数或者工厂方法是否已被解析过
	boolean autowireNecessary = false; // 有没有必要进行依赖注入
	if (args == null) { // getBean方法传入的参数为null
		synchronized (mbd.constructorArgumentLock) {
			/*
			 * 判断bean定义中的resolvedConstructorOrFactoryMethod属性是否有值
			 * 该属性用来缓存构造函数或者工厂方法，Bean在第一次被实例化的时候，会将解析得到的构造函数或者工厂方法赋值给这个属性
			 * 对于非单例模式的Bean来说，只需要解析一次Bean定义中的构造函数或工厂方法即可，后续可以直接从Bean定义中拿来使用
			 */
			if (mbd.resolvedConstructorOrFactoryMethod != null) {
				resolved = true; // 标记构造函数已被解析过了，原型等非单例模式的Bean，从第二次实例化开始就会进入这里
				// 构造函数参数是否被解析过？当使用有参构造函数或者工厂方法实例化Bean时，该属性会被设置为true
				autowireNecessary = mbd.constructorArgumentsResolved;
			}
		}
	}
	if (resolved) { // 已经解析过了，直接实例化Bean即可
		if (autowireNecessary) {
			// 使用有参构造函数实例化对象
			return autowireConstructor(beanName, mbd, null, null);
		}
		else {
			// 使用无参构造函数实例化对象
			return instantiateBean(beanName, mbd);
		}
	}

	// Candidate constructors for autowiring?
	// 调用Bean后置处理器，获取用于实例化Bean的构造函数，这里的返回值一般都是null
	Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
	/*
	 * 1. 上一行后置处理器解析出构造器对象不为null
	 * 2. bean定义中指定注入模式是构造器注入 autowire="constructor"
	 * 3. bean定义中指定了构造函数，无论是名称、类型、下标都是走这一步
	 * 4. 在外层，调用getBean方法传入的构造器函数参数类型不为null
	 * 四个条件有一个满足，就使用指定的构造函数进行实例化Bean
	 */
	if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
			mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
		// 使用指定的构造函数实例化对象
		return autowireConstructor(beanName, mbd, ctors, args);
	}

	// Preferred constructors for default construction?
	/*
	 * bean定义中的首选构造器
	 * 目前只有 GenericApplicationContext#ClassDerivedBeanDefinition类的这个方法有返回值，其它都是返回null
	 * 所以，Bean的实例化，基本不会走这一步
	 */
	ctors = mbd.getPreferredConstructors();
	if (ctors != null) {
		// 实例化Bean
		return autowireConstructor(beanName, mbd, ctors, null);
	}

	// No special handling: simply use no-arg constructor.
	// 如果前面的条件都不匹配，则使用无参构造函数实例化对象
	return instantiateBean(beanName, mbd);
}

实例化Bean的方式

回调函数实例化Bean

// AbstractAutowireCapableBeanFactory
protected BeanWrapper obtainFromSupplier(Supplier<?> instanceSupplier, String beanName) {
	Object instance;

	// 设置当前正在实例化的Bean的名称到ThreadLocal
	String outerBean = this.currentlyCreatedBean.get();
	this.currentlyCreatedBean.set(beanName);
	try {
		instance = instanceSupplier.get(); // 调用函数，拿到Bean实例
	}
	finally {
		// 重置ThreadLocal
		if (outerBean != null) {
			this.currentlyCreatedBean.set(outerBean);
		}
		else {
			this.currentlyCreatedBean.remove();
		}
	}

	if (instance == null) {
		instance = new NullBean();
	}

	// BeanWrapper接口提供了一些操作目标对象属性值的方法
	BeanWrapper bw = new BeanWrapperImpl(instance);
	initBeanWrapper(bw);
	return bw;
}

配置回调函数的示例

提供一个简单的回调函数配置示例

public class MemberRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor {

	@Override
	public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
		RootBeanDefinition bd = new RootBeanDefinition();
		bd.setBeanClass(Member.class);
		bd.setInstanceSupplier(Member::new); // 这里注册一个回调函数
		registry.registerBeanDefinition("member", bd);
	}

	@Override
	public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {

	}
}

工厂方法实例化Bean

// AbstractAutowireCapableBeanFactory
protected BeanWrapper instantiateUsingFactoryMethod(
	String beanName, RootBeanDefinition mbd, @Nullable Object[] explicitArgs) {

return new ConstructorResolver(this).instantiateUsingFactoryMethod(beanName, mbd, explicitArgs);
}

// ConstructorResolver
public BeanWrapper instantiateUsingFactoryMethod(
		String beanName, RootBeanDefinition mbd, @Nullable Object[] explicitArgs) {

	BeanWrapperImpl bw = new BeanWrapperImpl();
	this.beanFactory.initBeanWrapper(bw);

	// 实例工厂Bean对象，如果是静态工厂，值为null
	Object factoryBean;
	// 工厂的类型
	Class<?> factoryClass;
	// 是否静态工厂
	boolean isStatic;

	// 实例工厂的BeanName，如果是静态工厂，则值为null
	String factoryBeanName = mbd.getFactoryBeanName();
	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");
		}
		// 从IoC容器中获取实例工厂对象
		factoryBean = this.beanFactory.getBean(factoryBeanName);
		// 单例Bean，并且在IoC容器的一级缓存中已存在，说明这个Bean已经被创建过了，不能再次创建，抛出异常
		if (mbd.isSingleton() && this.beanFactory.containsSingleton(beanName)) {
			throw new ImplicitlyAppearedSingletonException();
		}
		factoryClass = factoryBean.getClass(); // 实例工厂的类名，这里可能得到CGLIB生成的子类名称
		isStatic = false;
	}
	else {
		// 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; // 用于实例化Bean的工厂方法
	ArgumentsHolder argsHolderToUse = null; // 持有 用于实例化Bean的参数 对象
	Object[] argsToUse = null; // 用于实例化Bean的参数

	if (explicitArgs != null) {
		argsToUse = explicitArgs;
	}
	else {
		Object[] argsToResolve = null;
		synchronized (mbd.constructorArgumentLock) {
			/*
			 * 工厂方法是否已经被解析过
			 * 第一次实例化Bean时，解析Bean定义，找到实例化Bean的工厂方法，
			 * 然后会将工厂方法回写到Bean定义中的resolvedConstructorOrFactoryMethod属性，并且constructorArgumentsResolved属性也会本设置为true。
			 * 当下次再需要实例化这个Bean时，就无须再次解析，直接从Bean定义中获取即可，这是对非单例作用域的Bean实例化过程的性能优化
			 */
			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, true);
		}
	}

	if (factoryMethodToUse == null || argsToUse == null) {
		// 获取工厂的实际类型，如果是CGLIB生成的子类，则返回原始类；否则返回的就是参数值
		factoryClass = ClassUtils.getUserClass(factoryClass);

		List<Method> candidates = null; // 可用于实例化Bean的工厂方法
		if (mbd.isFactoryMethodUnique) { // 如果是通过Java配置类配置的Bean，会走这块代码
			if (factoryMethodToUse == null) {
				factoryMethodToUse = mbd.getResolvedFactoryMethod();
			}
			if (factoryMethodToUse != null) {
				candidates = Collections.singletonList(factoryMethodToUse);
			}
		}
		if (candidates == null) { // 如果是静态工厂或者实例工厂，会走块代码
			candidates = new ArrayList<>();
			Method[] rawCandidates = getCandidateMethods(factoryClass, mbd); // 获取工厂类的所有方法
			/*
			 * 遍历工厂的所有方法，找出实例化Bean的方法，
			 * 如果是静态工厂，则方法必须是静态的，且方法名称与Bean定义中的相同；
			 * 如果是实例工厂，则方法不能是静态的，且方法名称与Bean定义中的相同。
			 */
			for (Method candidate : rawCandidates) {
				if (Modifier.isStatic(candidate.getModifiers()) == isStatic && mbd.isFactoryMethod(candidate)) {
					candidates.add(candidate);
				}
			}
		}

		// 只有一个符合条件的工厂方法，并且方法没有参数，则走这一块代码
		if (candidates.size() == 1 && explicitArgs == null && !mbd.hasConstructorArgumentValues()) {
			Method uniqueCandidate = candidates.get(0); // 唯一可以用来实例化Bean的工厂方法
			if (uniqueCandidate.getParameterCount() == 0) { // 方法的参数个数为0
				mbd.factoryMethodToIntrospect = uniqueCandidate;
				synchronized (mbd.constructorArgumentLock) {
					/*
					 * 将用于实例化Bean的工厂方法回写到Bean定义的resolvedConstructorOrFactoryMethod属性
					 * 设置构造函数参数(方法参数)已解析标识为true
					 * 回写构造函数或工厂方法参数
					 * 后续如果需要再次实例化Bean，则无需解析。
					 * 这是对非单例模式Bean实例化的优化手段，只需要第一次实例化时解析，后续实例化Bean就可以直接从Bean定义中拿来用
					 */
					mbd.resolvedConstructorOrFactoryMethod = uniqueCandidate;
					mbd.constructorArgumentsResolved = true;
					mbd.resolvedConstructorArguments = EMPTY_ARGS;
				}

				// instantiate：通过反射的方式执行工厂方法实例化Bean，Method.invoke()
				bw.setBeanInstance(instantiate(beanName, mbd, factoryBean, uniqueCandidate, EMPTY_ARGS));
				return bw;
			}
		}

		// 有多个工厂方法，则根据方法参数的个数进行排序，参数多的在前面
		if (candidates.size() > 1) {  // explicitly skip immutable singletonList
			candidates.sort(AutowireUtils.EXECUTABLE_COMPARATOR);
		}

		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 {
			if (mbd.hasConstructorArgumentValues()) { // 是否需要参数
			    // 获取Bean定义中的参数信息，例如 有多少个参数，参数是什么类型、名称等，就是Bean定义的参数信息
				ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();
				resolvedValues = new ConstructorArgumentValues();
				// 根据Bean定义时使用的索引、类型、名称等方式解析参数，如果引用了其它Bean，在这里会被创建
				minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);
			}
			else {
				minNrOfArgs = 0;
			}
		}

        // 该变量用于缓存解析方法参数过程中出现的异常，方法可能被重载，当被解析的方法与Bean定义中的方法无法匹配时，就会抛出异常
		LinkedList<UnsatisfiedDependencyException> causes = null;
		for (Method candidate : candidates) {
			int parameterCount = candidate.getParameterCount(); // 方法的参数个数
			if (parameterCount >= minNrOfArgs) {
				ArgumentsHolder argsHolder;
                // 方法的参数类型
				Class<?>[] paramTypes = candidate.getParameterTypes();
				if (explicitArgs != null) {
					// Explicit arguments given -> arguments length must match exactly.
					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);
						}
						// 解析方法的参数值
						argsHolder = createArgumentArray(beanName, mbd, resolvedValues, bw,
								paramTypes, paramNames, candidate, autowiring, candidates.size() == 1);
					}
					catch (UnsatisfiedDependencyException ex) {
						// 省略了异常处理的代码，这里并不会直接抛出异常，只是将异常缓存到 causes 变量
						// 如果所有方法都无法匹配Bean定义中的方法，在后面的代码中才抛出异常
						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; // 实例化Bean的工厂方法
					argsHolderToUse = argsHolder; // 持有工厂方法参数的对象
					argsToUse = argsHolder.arguments; // 工厂方法需要的参数
					minTypeDiffWeight = typeDiffWeight;
					ambiguousFactoryMethods = null;
				} 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);
				}
			}
		}
        // ......
		// 这里省略了一块代码，这些主要用来处理由于Bean定义错误，导致无法实例化Bean的异常情况
        // ......
		if (explicitArgs == null && argsHolderToUse != null) {
			mbd.factoryMethodToIntrospect = factoryMethodToUse; // 回写工厂方法到Bean定义的属性
			argsHolderToUse.storeCache(mbd, factoryMethodToUse); // 回写相关信息到Bean定义中，例如上面提到的resolvedConstructorOrFactoryMethod、constructorArgumentsResolved等属性
		}
	}

	// 通过反射实例化Bean
	bw.setBeanInstance(instantiate(beanName, mbd, factoryBean, factoryMethodToUse, argsToUse));
	return bw;
}

方法参数解析

// ConstructorResolver
private int resolveConstructorArguments(String beanName, RootBeanDefinition mbd, BeanWrapper bw,
		ConstructorArgumentValues cargs, ConstructorArgumentValues resolvedValues) {
    // 自定义的参数类型解析器，一般都没有指定，所以返回值是null
	TypeConverter customConverter = this.beanFactory.getCustomTypeConverter();
	// 如果没有自定义解析器，则使用BeanWrapper
	TypeConverter converter = (customConverter != null ? customConverter : bw);
	// Bean定义值解析器
	BeanDefinitionValueResolver valueResolver =
			new BeanDefinitionValueResolver(this.beanFactory, beanName, mbd, converter);

	int minNrOfArgs = cargs.getArgumentCount(); // 参数的数量
    // 通过索引位置配置的参数，走这里
	for (Map.Entry<Integer, ConstructorArgumentValues.ValueHolder> entry : cargs.getIndexedArgumentValues().entrySet()) {
		int index = entry.getKey(); // 索引
		if (index < 0) {
			throw new BeanCreationException(mbd.getResourceDescription(), beanName,
					"Invalid constructor argument index: " + index);
		}
		if (index > minNrOfArgs) {
			minNrOfArgs = index + 1;
		}
		ConstructorArgumentValues.ValueHolder valueHolder = entry.getValue(); // 参数值
		// 参数值是否已经转换，例如参数引用了一个Bean，这个Bean是否已经被创建出来
		if (valueHolder.isConverted()) {
			resolvedValues.addIndexedArgumentValue(index, valueHolder); // 回写方法参数，在外层再取出来
		}
		else {
		    // 参数转换后的值，例如参数是一个Bean，则此处会将Bean创建出来，如果Bean已经创建了，则直接从IoC容器中拿到这个Bean。
			Object resolvedValue =
					valueResolver.resolveValueIfNecessary("constructor argument", valueHolder.getValue());
			// 保存参数值的对象
			ConstructorArgumentValues.ValueHolder resolvedValueHolder =
					new ConstructorArgumentValues.ValueHolder(resolvedValue, valueHolder.getType(), valueHolder.getName());
			resolvedValueHolder.setSource(valueHolder);
			resolvedValues.addIndexedArgumentValue(index, resolvedValueHolder); // 回写方法参数
		}
	}
    // 通过类型、名称或者什么都没有指定的方式配置的参数，走这里
	for (ConstructorArgumentValues.ValueHolder valueHolder : cargs.getGenericArgumentValues()) {
		if (valueHolder.isConverted()) {
			resolvedValues.addGenericArgumentValue(valueHolder);
		}
		else {
		    // 参数值解析，如果引用了其它Bean，这里会将Bean创建出来
			Object resolvedValue =
					valueResolver.resolveValueIfNecessary("constructor argument", valueHolder.getValue());
			// 保存参数值的对象
			ConstructorArgumentValues.ValueHolder resolvedValueHolder = new ConstructorArgumentValues.ValueHolder(
					resolvedValue, valueHolder.getType(), valueHolder.getName()); 
			resolvedValueHolder.setSource(valueHolder);
			resolvedValues.addGenericArgumentValue(resolvedValueHolder); // 回写方法参数
		}
	}

	return minNrOfArgs;
}

执行工厂方法，实例化Bean

// ConstructorResolver
private Object instantiate(String beanName, RootBeanDefinition mbd,
		@Nullable Object factoryBean, Method factoryMethod, Object[] args) {

	try {
		if (System.getSecurityManager() != null) {
			return AccessController.doPrivileged((PrivilegedAction<Object>) () ->
					this.beanFactory.getInstantiationStrategy().instantiate(
							mbd, beanName, this.beanFactory, factoryBean, factoryMethod, args),
					this.beanFactory.getAccessControlContext());
		}
		else {
			// 通过反射的方式执行工厂方法(Method.invoke())实例化Bean
			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);
	}
}

// SimpleInstantiationStrategy
public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner,
		@Nullable Object factoryBean, final Method factoryMethod, Object... args) {

	try {
		if (System.getSecurityManager() != null) {
			AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
				ReflectionUtils.makeAccessible(factoryMethod);
				return null;
			});
		}
		else {
		    // 设置工厂方法的访问属性为 true
			ReflectionUtils.makeAccessible(factoryMethod);
		}

		Method priorInvokedFactoryMethod = currentlyInvokedFactoryMethod.get();
		try {
		    // 将当前工厂方法存入ThreadLocal对象
			currentlyInvokedFactoryMethod.set(factoryMethod);
			// 通过反射执行工厂方法，实例化Bean
			Object result = factoryMethod.invoke(factoryBean, args);
			if (result == null) {
				result = new NullBean();
			}
			return result;
		}
		finally {
			// ThreadLocal中的值重置
			if (priorInvokedFactoryMethod != null) {
				currentlyInvokedFactoryMethod.set(priorInvokedFactoryMethod);
			}
			else {
				currentlyInvokedFactoryMethod.remove();
			}
		}
	}
	// 异常处理代码，省略......
}

指定构造函数实例化Bean

// AbstractAutowireCapableBeanFactory
protected BeanWrapper autowireConstructor(
		String beanName, RootBeanDefinition mbd, @Nullable Constructor<?>[] ctors, @Nullable Object[] explicitArgs) {

	return new ConstructorResolver(this).autowireConstructor(beanName, mbd, ctors, explicitArgs);
}

// ConstructorResolver
public BeanWrapper autowireConstructor(String beanName, RootBeanDefinition mbd,
		@Nullable Constructor<?>[] chosenCtors, @Nullable Object[] explicitArgs) {

	BeanWrapperImpl bw = new BeanWrapperImpl();
	this.beanFactory.initBeanWrapper(bw);

	Constructor<?> constructorToUse = null; // 用于实例化Bean的构造函数
	ArgumentsHolder argsHolderToUse = null; // 保存了构造函数参数的对象
	Object[] argsToUse = null; // 构造函数的参数

	if (explicitArgs != null) {
		argsToUse = explicitArgs;
	}
	else {
		Object[] argsToResolve = null;
		synchronized (mbd.constructorArgumentLock) {
			/*
			 * 构造函数是否已经被解析过
			 * 第一次实例化Bean时，解析Bean定义，找到实例化Bean的构造函数，
			 * 然后会将构造函数回写到Bean定义中的resolvedConstructorOrFactoryMethod属性，
			 * 如果是有参构造函数，将constructorArgumentsResolved属性设置为true。
			 * 当下次再需要实例化这个Bean时，就无须再次解析，直接从Bean定义中获取即可，这是对非单例作用域的Bean实例化过程的优化
			 */
			constructorToUse = (Constructor<?>) mbd.resolvedConstructorOrFactoryMethod;
			if (constructorToUse != null && mbd.constructorArgumentsResolved) {
				// Found a cached constructor...
				argsToUse = mbd.resolvedConstructorArguments;
				if (argsToUse == null) {
					argsToResolve = mbd.preparedConstructorArguments;
				}
			}
		}
		if (argsToResolve != null) {
			// 解析缓存在给定 bean 定义中的参数
			argsToUse = resolvePreparedArguments(beanName, mbd, bw, constructorToUse, argsToResolve, true);
		}
	}

	if (constructorToUse == null || argsToUse == null) {
		// Take specified constructors, if any.
		Constructor<?>[] candidates = chosenCtors;
		if (candidates == null) {
			Class<?> beanClass = mbd.getBeanClass();
			try {
				// 获取Bean class中的所有构造函数
				candidates = (mbd.isNonPublicAccessAllowed() ?
						beanClass.getDeclaredConstructors() : beanClass.getConstructors());
			}
			catch (Throwable ex) {
				// 异常处理，省略
		}

		// 只有一个构造函数并且Bean定义中使用的无参构造函数，才执行这块代码
		if (candidates.length == 1 && explicitArgs == null && !mbd.hasConstructorArgumentValues()) {
			Constructor<?> uniqueCandidate = candidates[0];
			if (uniqueCandidate.getParameterCount() == 0) {
				synchronized (mbd.constructorArgumentLock) {
				    // 将解析结果回写到Bean定义对象中缓存起来
					mbd.resolvedConstructorOrFactoryMethod = uniqueCandidate;
					mbd.constructorArgumentsResolved = true;
					mbd.resolvedConstructorArguments = EMPTY_ARGS;
				}
				// 通过反射的方式执行构造函数，实例Bean
				bw.setBeanInstance(instantiate(beanName, mbd, uniqueCandidate, EMPTY_ARGS));
				return bw;
			}
		}

		// Need to resolve the constructor.
		// 是否是构造器注入
		boolean autowiring = (chosenCtors != null ||
				mbd.getResolvedAutowireMode() == AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR);
		ConstructorArgumentValues resolvedValues = null;

		int minNrOfArgs;
		if (explicitArgs != null) {
			minNrOfArgs = explicitArgs.length;
		}
		else {
			// 获取Bean定义中的构造函数参数信息
			ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();
			resolvedValues = new ConstructorArgumentValues();
			// 解析构造参数，如果Bean需要注入的其它Bean还没有创建，此处会将需要注入的Bean创建出来
			minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);
		}
        // 构造函数排序，参数多的排在前面
		AutowireUtils.sortConstructors(candidates);
		int minTypeDiffWeight = Integer.MAX_VALUE;
		Set<Constructor<?>> ambiguousConstructors = null;
		LinkedList<UnsatisfiedDependencyException> causes = null;

		for (Constructor<?> candidate : candidates) {
			int parameterCount = candidate.getParameterCount(); // 构造函数的参数个数
			if (constructorToUse != null && argsToUse != null && argsToUse.length > 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) {
					    // 参数名称解析器 DefaultParameterNameDiscoverer
						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) {
					// 异常缓存起来，省略了一些代码
					causes.add(ex);
					continue;
				}
			}
			else {
				// Explicit arguments given -> arguments length must match exactly.
				if (parameterCount != 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 (explicitArgs == null && argsHolderToUse != null) {
		    // 解析结果回写代Bean定义的相关属性
			argsHolderToUse.storeCache(mbd, constructorToUse);
		}
	}

	Assert.state(argsToUse != null, "Unresolved constructor arguments");
	// 通过反射的方式执行构造函数实例化Bean
	bw.setBeanInstance(instantiate(beanName, mbd, constructorToUse, argsToUse));
	return bw;
}

构造函数参数解析

执行构造函数，实例化Bean

// ConstructorResolver
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 {
		    // 通过反射的方式实例化Bean，Constructor.newInstance(args)
			return strategy.instantiate(mbd, beanName, this.beanFactory, constructorToUse, argsToUse);
		}
	}
	catch (Throwable ex) {
		throw new BeanCreationException(mbd.getResourceDescription(), beanName,
				"Bean instantiation via constructor failed", ex);
	}
}

// SimpleInstantiationStrategy
public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner,
		final Constructor<?> ctor, Object... args) {

	if (!bd.hasMethodOverrides()) {
		if (System.getSecurityManager() != null) {
			// use own privileged to change accessibility (when security is on)
			AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
				ReflectionUtils.makeAccessible(ctor);
				return null;
			});
		}
		// 使用反射创建Bean实例
		return BeanUtils.instantiateClass(ctor, args);
	}
	else {
		return instantiateWithMethodInjection(bd, beanName, owner, ctor, args);
	}
}

// BeanUtils
public static <T> T instantiateClass(Constructor<T> ctor, Object... args) throws BeanInstantiationException {
	Assert.notNull(ctor, "Constructor must not be null");
	try {
		ReflectionUtils.makeAccessible(ctor); // 将构造函数设置为可访问
		if (KotlinDetector.isKotlinReflectPresent() && KotlinDetector.isKotlinType(ctor.getDeclaringClass())) {
			return KotlinDelegate.instantiateClass(ctor, args);
		}
		else {
		    // 获取构造函数的参数类型
			Class<?>[] parameterTypes = ctor.getParameterTypes();
			Assert.isTrue(args.length <= parameterTypes.length, "Can't specify more arguments than constructor parameters");
			Object[] argsWithDefaultValues = new Object[args.length];
			for (int i = 0 ; i < args.length; i++) { // 构造函数的参数处理
				if (args[i] == null) { // 如果参数值为空，获取默认值
					Class<?> parameterType = parameterTypes[i];
					argsWithDefaultValues[i] = (parameterType.isPrimitive() ? DEFAULT_TYPE_VALUES.get(parameterType) : null);
				}
				else {
					argsWithDefaultValues[i] = args[i];
				}
			}
			return ctor.newInstance(argsWithDefaultValues); // 使用构造函数创建Bean实例
		}
	}
	// 省略掉所有异常处理的代码
}

默认无参构造函数实例化Bean

// AbstractAutowireCapableBeanFactory
protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
	try {
		Object beanInstance;
		final BeanFactory parent = this; // IoC容器
		if (System.getSecurityManager() != null) {
			beanInstance = AccessController.doPrivileged((PrivilegedAction<Object>) () ->
					getInstantiationStrategy().instantiate(mbd, beanName, parent),
					getAccessControlContext());
		}
		else {
			// 通过反射，执行构造函数实例化Bean
			beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
		}
		// 返回一个包装类
		BeanWrapper bw = new BeanWrapperImpl(beanInstance);
		initBeanWrapper(bw);
		return bw;
	}
	catch (Throwable ex) {
		throw new BeanCreationException(
				mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
	}
}

// SimpleInstantiationStrategy
public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
	// Don't override the class with CGLIB if no overrides.
	// 如果不存在方法覆写(lookup-method 和 replaced-method)，那就使用 java 反射进行实例化，否则使用 CGLIB
	if (!bd.hasMethodOverrides()) {
		Constructor<?> constructorToUse;
		synchronized (bd.constructorArgumentLock) {
		    // 构造函数或工厂方法是否有被解析过，第一次解析时会将构造函数或工厂方法回写到Bean定义中
			constructorToUse = (Constructor<?>) bd.resolvedConstructorOrFactoryMethod;
			if (constructorToUse == null) {
				final Class<?> clazz = bd.getBeanClass(); // Bean的类型
				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 {
						// 获取class的默认构造函数
						constructorToUse = clazz.getDeclaredConstructor();
					}
					// 将构造函数回写到Bean定义中，下次再创建实例时，无须再次解析
					bd.resolvedConstructorOrFactoryMethod = constructorToUse;
				}
				catch (Throwable ex) {
					throw new BeanInstantiationException(clazz, "No default constructor found", ex);
				}
			}
		}
		// 使用反射的方式创建Bean实例
		return BeanUtils.instantiateClass(constructorToUse);
	}
	else {
		// Must generate CGLIB subclass.
		// 存在方法覆写，利用 CGLIB 来完成实例化，需要依赖于 CGLIB 生成子类
		return instantiateWithMethodInjection(bd, beanName, owner);
	}
}