1. createBeanInstance方法创建Bean的java实例对象

在createBeanInstance方法中，根据指定的初始化策略，使用静态工厂、工厂方法或者容器的自动装配特性生成java实例对象，源码如下：

//创建Bean的实例对象  
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {  
    //检查确认Bean是可实例化的  
    Class<?> beanClass = resolveBeanClass(mbd, beanName);  
    //使用工厂方法对Bean进行实例化  
    if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) { 
        throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Bean class isn't public, and non-public access not allowed: " + beanClass.getName()); 
    }  
    Supplier<?> instanceSupplier = mbd.getInstanceSupplier(); 
    if (instanceSupplier != null) { 
        return obtainFromSupplier(instanceSupplier, beanName); 
    }  
    if (mbd.getFactoryMethodName() != null)  { 
        //调用工厂方法实例化  
        return instantiateUsingFactoryMethod(beanName, mbd, args);
    }  
    //使用容器的自动装配方法进行实例化  
    boolean resolved = false; 
    boolean autowireNecessary = false; 
    if (args == null) { 
        synchronized (mbd.constructorArgumentLock) { 
            if (mbd.resolvedConstructorOrFactoryMethod != null) { 
                resolved = true; 
                autowireNecessary = mbd.constructorArgumentsResolved; 
            } 
        } 
    } 
    if (resolved) {
        if (autowireNecessary) { 
            //配置了自动装配属性，使用容器的自动装配实例化,容器的自动装配是根据参数类型匹配Bean的构造方法  
            return autowireConstructor(beanName, mbd, null, null); 
        } 
        else { 
            //使用默认的无参构造方法实例化  
            return instantiateBean(beanName, mbd); 
        } 
    }  
    //使用Bean的构造方法进行实例化  
    Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName); 
    if (ctors != null || mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR || mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args))  { 
        //使用容器的自动装配特性，调用匹配的构造方法实例化  
        return autowireConstructor(beanName, mbd, ctors, args); 
    }  
    //使用默认的无参构造方法实例化  
    return instantiateBean(beanName, mbd);
}  
  
//使用默认的无参构造方法实例化Bean对象  
protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {  
    try { 
        Object beanInstance; 
        final BeanFactory parent = this; 
        //获取系统的安全管理接口，JDK标准的安全管理API  
        if (System.getSecurityManager() != null) { 
            //这里是一个匿名内置类，根据实例化策略创建实例对象  
            beanInstance = AccessController.doPrivileged(
                (PrivilegedAction<Object>) () -> getInstantiationStrategy().instantiate(mbd, beanName, parent), getAccessControlContext()); 
        }
        else { 
            //将实例化的对象封装起来  
            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); 
    }
}

根据代码可以看出实例化bean的主要方法

obtainFromSupplier(instanceSupplier, beanName)：使用给定的回调方法初始化策略
instantiateUsingFactoryMethod(beanName, mbd, args)：使用 FactoryBean 的 factory-method 来创建
autowireConstructor(beanName, mbd, null, null)：autowire 自动注入，调用构造函数自动注入
instantiateBean(beanName, mbd) ：使用默认构造函数构造

可以看出：对使用工厂方法和自动装配特性的Bean的实例化比较清楚，调用相应的工厂方法或者参数匹配的构造方法即可完成实例化对象的工作，但是对于最常使用的默认无参构造方法就需要使用相应的初始化策略(JDK的反射机制或者CGLIB)来进行初始化了，在方法getInstantiationStrategy().instantiate()中就具体实现类使用初始策略实例化对象。

2. 创建 Class 对象前置检查

	@Override
	protected Object createBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
			throws BeanCreationException {

		if (logger.isDebugEnabled()) {
			logger.debug("Creating instance of bean '" + beanName + "'");
		}
		// Make sure bean class is actually resolved at this point.
		resolveBeanClass(mbd, beanName);

		// Prepare method overrides.
		try {
			mbd.prepareMethodOverrides();
		}
		catch (BeanDefinitionValidationException ex) {
			throw new BeanDefinitionStoreException(mbd.getResourceDescription(),
					beanName, "Validation of method overrides failed", ex);
		}

		try {
			// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
			Object bean = resolveBeforeInstantiation(beanName, mbd);
			if (bean != null) {
				return bean;
			}
		}
		catch (Throwable ex) {
			throw new BeanCreationException(mbd.getResourceDescription(), beanName,
					"BeanPostProcessor before instantiation of bean failed", ex);
		}

		Object beanInstance = doCreateBean(beanName, mbd, args);
		if (logger.isDebugEnabled()) {
			logger.debug("Finished creating instance of bean '" + beanName + "'");
		}
		return beanInstance;
	}

方法调用链

 createBean ——> doCreateBean ——> createBeanInstance

// AbstractAutowireCapableBeanFactory#createBean(...) 方法
// <1> 获取 `mbd` 对应的 Class 对象，确保当前 Bean 能够被创建出来
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
// 如果这里获取到了 Class 对象，但是 `mbd` 中没有 Class 对象的相关信息，表示这个 Class 对象是动态解析出来的
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
    // 复制一份 `mbd`，并设置 Class 对象，因为动态解析出来的 Class 对象不被共享
    mbdToUse = new RootBeanDefinition(mbd);
    mbdToUse.setBeanClass(resolvedClass);
}

创建一个 Java 对象之前，需要确保存在对应的 Class 对象。如果这里获取到了 Class 对象，但是 mbd 中没有 Class 对象的相关信息，表示这个 Class 对象是动态解析出来的，则需要复制一份 mbd，并设置 Class 对象，因为动态解析出来的 Class 对象不被共享

2.1. resolveBeanClass 方法

resolveBeanClass(final RootBeanDefinition mbd, String beanName, final Class<?>... typesToMatch) ，获取 beanName 的 Class 对象，方法如下：

// AbstractBeanFactory.java
@Nullable
protected Class<?> resolveBeanClass(final RootBeanDefinition mbd, String beanName, final Class<?>... typesToMatch)
        throws CannotLoadBeanClassException {
    try {
        // 有 Class 对象则直接返回
        if (mbd.hasBeanClass()) {
            return mbd.getBeanClass();
        }
        // 否则，调用 `doResolveBeanClass(...)` 方法，加载出一个 Class 对象
        if (System.getSecurityManager() != null) {
            return AccessController.doPrivileged((PrivilegedExceptionAction<Class<?>>) () -> 
                                                 doResolveBeanClass(mbd, typesToMatch), getAccessControlContext());
        } else {
            return doResolveBeanClass(mbd, typesToMatch);
        }
    }
    // ... 省略 catch 各种异常
}

如果有 Class 对象则直接返回，没有的话调用 doResolveBeanClass(...) 方法去获取 Class 对象

2.1.1. doResolveBeanClass 方法

// AbstractBeanFactory.java
@Nullable
private Class<?> doResolveBeanClass(RootBeanDefinition mbd, Class<?>... typesToMatch)
        throws ClassNotFoundException {
    // 获取 ClassLoader 加载器
    ClassLoader beanClassLoader = getBeanClassLoader();
    ClassLoader dynamicLoader = beanClassLoader;
    boolean freshResolve = false;

    if (!ObjectUtils.isEmpty(typesToMatch)) {
        // When just doing type checks (i.e. not creating an actual instance yet),
        // use the specified temporary class loader (e.g. in a weaving scenario).
        ClassLoader tempClassLoader = getTempClassLoader();
        if (tempClassLoader != null) {
            dynamicLoader = tempClassLoader;
            freshResolve = true;
            if (tempClassLoader instanceof DecoratingClassLoader) {
                DecoratingClassLoader dcl = (DecoratingClassLoader) tempClassLoader;
                for (Class<?> typeToMatch : typesToMatch) {
                    dcl.excludeClass(typeToMatch.getName());
                }
            }
        }
    }

    // 获取 `className`
    String className = mbd.getBeanClassName();
    if (className != null) {
        // 根据 BeanExpressionResolver 表达式处理器计算出 `className` 对应的结果
        // 可能还是一个类名称，也可能是一个 Class 对象
        Object evaluated = evaluateBeanDefinitionString(className, mbd);
        if (!className.equals(evaluated)) {
            // A dynamically resolved expression, supported as of 4.2...
            if (evaluated instanceof Class) {
                return (Class<?>) evaluated;
            }
            else if (evaluated instanceof String) {
                className = (String) evaluated;
                freshResolve = true;
            }
            else {
                throw new IllegalStateException("Invalid class name expression result: " + evaluated);
            }
        }
        // 如果被处理过，则根据这个 `className` 创建一个 Class 对象
        // 创建的 Class 对象不会设置到 `mbd` 中
        if (freshResolve) {
            // When resolving against a temporary class loader, exit early in order
            // to avoid storing the resolved Class in the bean definition.
            if (dynamicLoader != null) {
                try {
                    return dynamicLoader.loadClass(className);
                }
                catch (ClassNotFoundException ex) {
                    if (logger.isTraceEnabled()) {
                        logger.trace("Could not load class [" + className + "] from " + dynamicLoader + ": " + ex);
                    }
                }
            }
            return ClassUtils.forName(className, dynamicLoader);
        }
    }

    // Resolve regularly, caching the result in the BeanDefinition...
    // 让 RootBeanDefinition 自己解析出 Class 对象
    return mbd.resolveBeanClass(beanClassLoader);
}

暂时忽略上面具体的每个细节，底层会根据 className 通过来加载器获取对应的 Class 对象，并设置到 RootBeanDefinition

注意，这个过程可能是动态解析出来的，例如 className 是一个表达式，通过 BeanDefinition 表达式解析器解析出来的，然后根据其获取 Class 对象，这里是不会设置到 RootBeanDefinition 中

2.2. MethodOverride 的验证与准备

对应代码段：

// AbstractAutowireCapableBeanFactory#createBean(...) 方法
try {
    // <2> 对所有的 MethodOverride 进行验证和准备工作（确保存在对应的方法，并设置为不能重复加载）
    mbdToUse.prepareMethodOverrides();
}
catch (BeanDefinitionValidationException ex) {
    throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
            beanName, "Validation of method overrides failed", ex);
}

和标签会被解析成 LookupOverride 和 ReplaceOverride 对象，用于实现或覆盖某个方法，这里会进行验证和准备工作，过程如下：

// AbstractBeanDefinition.java
public void prepareMethodOverrides() throws BeanDefinitionValidationException {
    // Check that lookup methods exist and determine their overloaded status.
    if (hasMethodOverrides()) { // 如果存在 `methodOverrides`
        // 获取所有的 override method，遍历进行处理
        getMethodOverrides().getOverrides().forEach(this::prepareMethodOverride);
    }
}
protected void prepareMethodOverride(MethodOverride mo) throws BeanDefinitionValidationException {
    int count = ClassUtils.getMethodCountForName(getBeanClass(), mo.getMethodName());
    if (count == 0) {
        throw new BeanDefinitionValidationException(
                "Invalid method override: no method with name '" + mo.getMethodName() +
                "' on class [" + getBeanClassName() + "]");
    }
    else if (count == 1) {
        // Mark override as not overloaded, to avoid the overhead of arg type checking.
        mo.setOverloaded(false);
    }
}

确保这个类中存在对应的方法，并设置为不能重复加载

2.3. 实例化前阶段

对应代码段：

// AbstractAutowireCapableBeanFactory#createBean(...) 方法
try {
    // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
    /**
     * <3> 在实例化前进行相关处理，会先调用所有 {@link InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation}
     * 注意，如果这里返回对象不是 `null` 的话，不会继续往下执行原本初始化操作，直接返回，也就是说这个方法返回的是最终实例对象
     * 可以通过这种方式提前返回一个代理对象，例如 AOP 的实现，或者 RPC 远程调用的实现（因为本地类没有远程能力，可以通过这种方式进行拦截）
     */
    Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
    if (bean != null) {
        return bean;
    }
}
catch (Throwable ex) {
    throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
            "BeanPostProcessor before instantiation of bean failed", ex);
}

在开始创建 Bean 执行，调用 resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) 方法进行处理，尝试获取一个代理对象

注意，如果这里返回对象不是 null 的话，不会继续往下执行原本初始化操作，直接返回，也就是说这个方法返回的是最终实例对象。可以通过这种方式提前返回一个代理对象，例如 AOP 的实现，或者 RPC 远程调用的实现（因为本地类没有远程能力，可以通过这种方式进行拦截）

2.3.1. resolveBeforeInstantiation 方法

// AbstractAutowireCapableBeanFactory.java
@Nullable
protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
    Object bean = null;
    if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
        // Make sure bean class is actually resolved at this point.
        // 如果 RootBeanDefinition 不是用户定义的（由 Spring 解析出来的），并且存在 InstantiationAwareBeanPostProcessor 处理器
        if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
            Class<?> targetType = determineTargetType(beanName, mbd);
            if (targetType != null) {
                 // 实例化前置处理
                bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
                if (bean != null) {
                    // 后置处理
                    bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
                }
            }
        }
        mbd.beforeInstantiationResolved = (bean != null);
    }
    return bean;
}

如果 RootBeanDefinition 不是用户定义的（由 Spring 解析出来的），并且存在 InstantiationAwareBeanPostProcessor 处理器，则进行下面的处理：

实例化前置处理，调用 applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) 方法，如下

@Nullable
protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {
    for (BeanPostProcessor bp : getBeanPostProcessors()) {
        if (bp instanceof InstantiationAwareBeanPostProcessor) {
            InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
            Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
            if (result != null) {
                return result;
            }
        }
    }
    return null;
}

遍历所有的 InstantiationAwareBeanPostProcessor 处理器，执行 postProcessBeforeInstantiation 方法，实例化前置处理，如果有一个处理后返回的结果不为空则直接返回

如果第 1 步返回的对象不为空，则调用 applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName) 方法，如下：

// AbstractAutowireCapableBeanFactory.java
@Override
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
        throws BeansException {

    Object result = existingBean;
    // 遍历 BeanPostProcessor
    for (BeanPostProcessor processor : getBeanPostProcessors()) {
        // 处理
        Object current = processor.postProcessAfterInitialization(result, beanName);
        // 返回空，则返回 result
        if (current == null) {
            return result;
        }
        // 修改 result
        result = current;
    }
    return result;
}

遍历所有的 BeanPostProcessor 处理器，执行 postProcessAfterInitialization 方法，初始化后置处理

3. Bean 的实例化

对应代码段：

// AbstractAutowireCapableBeanFactory#doCreateBean(...) 方法
// Instantiate the bean.
/**
 * <1> Bean 的实例化阶段，会将 Bean 的实例对象封装成 {@link BeanWrapperImpl} 包装对象
 * BeanWrapperImpl 承担的角色：
 * 1. Bean 实例的包装
 * 2. {@link org.springframework.beans.PropertyAccessor} 属性编辑器
 * 3. {@link org.springframework.beans.PropertyEditorRegistry} 属性编辑器注册表
 * 4. {@link org.springframework.core.convert.ConversionService} 类型转换器（Spring 3+，替换了之前的 TypeConverter）
 */
BeanWrapper instanceWrapper = null;
// <1.1> 如果是单例模式，则先尝试从 `factoryBeanInstanceCache` 缓存中获取实例对象，并从缓存中移除
if (mbd.isSingleton()) {
    instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
// <1.2> 使用合适的实例化策略来创建 Bean 的实例：工厂方法、构造函数自动注入、简单初始化
// 主要是将 BeanDefinition 转换为 BeanWrapper 对象
if (instanceWrapper == null) {
    instanceWrapper = createBeanInstance(beanName, mbd, args);
}
// <1.3> 获取包装的实例对象 `bean`
final Object bean = instanceWrapper.getWrappedInstance();
// <1.4> 获取包装的实例对象的类型 `beanType`
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
    mbd.resolvedTargetType = beanType;
}

Bean 的实例化阶段，会将 Bean 的实例对象封装成 BeanWrapperImpl 包装对象，BeanWrapperImpl 承担的角色：

Bean 实例的包装
PropertyAccessor 属性编辑器
PropertyEditorRegistry 属性编辑器注册表
ConversionService 类型转换器（Spring 3+，替换了之前的 TypeConverter）

该过程大致如下

如果是单例模式，则先尝试从 factoryBeanInstanceCache 缓存中获取实例对象，并从缓存中移除
使用合适的实例化策略来创建 Bean 的实例：工厂方法、构造函数自动注入、简单初始化，主要是将 BeanDefinition 转换为 BeanWrapper 对象，调用 createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) 方法
获取包装的实例对象 bean
获取包装的实例对象的类型 beanType

3.1. createBeanInstance 方法

createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) 方法，创建一个 Bean 的实例对象，如下：

// AbstractAutowireCapableBeanFactory.java
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
    // Make sure bean class is actually resolved at this point.
    // <1> 获取 `beanName` 对应的 Class 对象
    Class<?> beanClass = resolveBeanClass(mbd, beanName);

    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());
    }

    // <2> 如果存在 Supplier 实例化回调接口，则使用给定的回调方法创建一个实例对象
    Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
    if (instanceSupplier != null) {
        return obtainFromSupplier(instanceSupplier, beanName);
    }

    // <3> 如果配置了 `factory-method` 工厂方法，则调用该方法来创建一个实例对象
    // 通过 @Bean 标注的方法会通过这里进行创建
    if (mbd.getFactoryMethodName() != null) {
        // 这个过程非常复杂，你可以理解为：
        // 找到最匹配的 Method 工厂方法，获取相关参数（依赖注入），然后通过调用该方法返回一个实例对象（反射机制）
        return instantiateUsingFactoryMethod(beanName, mbd, args);
    }

    // Shortcut when re-creating the same bean...
    // <4> 判断这个 RootBeanDefinition 的构造方法是否已经被解析出来了
    // 因为找到最匹配的构造方法比较繁琐，找到后会设置到 RootBeanDefinition 中，避免重复这个过程
    boolean resolved = false;
    boolean autowireNecessary = false;
    if (args == null) {
        synchronized (mbd.constructorArgumentLock) { // 加锁
            // <4.1> 构造方法已经解析出来了
            if (mbd.resolvedConstructorOrFactoryMethod != null) {
                resolved = true;
                // <4.2> 这个构造方法有入参，表示需要先获取到对应的入参（构造器注入）
                autowireNecessary = mbd.constructorArgumentsResolved;
            }
        }
    }

    // <5> 如果最匹配的构造方法已解析出来
    if (resolved) {
        // <5.1> 如果这个构造方法有入参
        if (autowireNecessary) {
            // 这个过程很复杂，你可以理解为：
            // 找到最匹配的构造方法，这里会拿到已经被解析出来的这个方法，并找到入参（构造器注入），然后调用该方法返回一个实例对象（反射机制）
            return autowireConstructor(beanName, mbd, null, null);
        }
            // <5.2> 否则，没有入参
        else {
            // 直接调用解析出来构造方法，返回一个实例对象（反射机制）
            return instantiateBean(beanName, mbd);
        }
    }

    // Candidate constructors for autowiring?
    // <6> 如果最匹配的构造方法还没开始解析，那么需要找到一个最匹配的构造方法，然后创建一个实例对象

    /**
	 * <6.1> 尝试通过 SmartInstantiationAwareBeanPostProcessor 处理器的 determineCandidateConstructors 方法来找到一些合适的构造方法
	 * 参考 {@link org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor#determineCandidateConstructors}
	 */
    Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
    // <6.2> 是否满足下面其中一个条件
    if (ctors != null // 上一步找到了合适的构造方法
        || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR // 构造器注入
        || mbd.hasConstructorArgumentValues() // 定义了构造方法的入参
        || !ObjectUtils.isEmpty(args)) // 当前方法指定了入参
    {
        // 找到最匹配的构造方法，如果 `ctors` 不为空，会从这里面找一个最匹配的，
        // 并找到入参（构造器注入），然后调用该方法返回一个实例对象（反射机制）
    return autowireConstructor(beanName, mbd, ctors, args);
}

    // Preferred constructors for default construction?
    /**
    * <7> 如果第 `6` 步还不满足，那么尝试获取优先的构造方法
    * 参考 {@link org.springframework.context.support.GenericApplicationContext.ClassDerivedBeanDefinition}
    */
    ctors = mbd.getPreferredConstructors();
    if (ctors != null) {
    // 如果存在优先的构造方法，则从里面找到最匹配的一个，并找到入参（构造器注入），然后调用该方法返回一个实例对象（反射机制）
    return autowireConstructor(beanName, mbd, ctors, null);
}

    // No special handling: simply use no-arg constructor.
    // <8> 如果上面多种情况都不满足，那只能使用兜底方法了，直接调用默认构造方法返回一个实例对象（反射机制）
    return instantiateBean(beanName, mbd);
}

过程大致如下：

获取 beanName 对应的 Class 对象
如果存在 Supplier 实例化回调接口，则使用给定的回调方法创建一个实例对象
如果配置了 factory-method 工厂方法，则调用该方法来创建一个实例对象，通过 @Bean 标注的方法会通过这里进行创建

如果上面两种情况都不是，那么就进行接下来正常创建 Bean 实例的一个过程

判断这个 RootBeanDefinition 的构造方法是否已经被解析出来了，因为找到最匹配的构造方法比较繁琐，找到后会设置到 RootBeanDefinition 中，避免重复这个过程
1. RootBeanDefinition 的 resolvedConstructorOrFactoryMethod 是否不为空，不为空表示构造方法已经解析出来了
2. 构造方法已经解析出来了，则判断它的 constructorArgumentsResolved 是否不为空，不为空表示有入参，需要先获取到对应的入参（构造器注入）
如果最匹配的构造方法已解析出来
1. 如果这个构造方法有入参，则找到最匹配的构造方法，这里会拿到已经被解析出来的这个方法，并找到入参（构造器注入），然后调用该方法返回一个实例对象（反射机制）
2. 否则，没有入参，直接调用解析出来构造方法，返回一个实例对象（反射机制）
如果最匹配的构造方法还没开始解析，那么需要找到一个最匹配的构造方法，然后创建一个实例对象
1. 先尝试通过 SmartInstantiationAwareBeanPostProcessor 处理器找到一些合适的构造方法，保存在 ctors 中
2. 是否满足下面其中一个条件：ctors 不为空、构造器注入模式、定义了构造方法的入参、当前方法指定了入参，则找到最匹配的构造方法，如果 ctors 不为空，会从这里面找一个最匹配的，并找到入参（构造器注入），然后调用该方法返回一个实例对象（反射机制）

如果第 6 步还不满足，那么尝试从 RootBeanDefinition 中获取优先的构造方法
1. 如果存在优先的构造方法，则从里面找到最匹配的一个，并找到入参（构造器注入），然后调用该方法返回一个实例对象（反射机制）

如果上面多种情况都不满足，那只能使用兜底方法了，直接调用默认构造方法返回一个实例对象（反射机制）

整个的实例化过程非常的复杂，接下来进行概括：

先拿到对应 Class 对象
如果设置了 Supplier 实例化回调接口，则通过该回调接口获取实例对象
如果配置了通过 factory-method 工厂方法获取实例对象，则通过这个方法创建实例对象，@Bean 标注的方法也是通过这里创建实例对象，方法入参会依赖注入
找到最匹配的一个构造方法，并找到对应的入参（构造器注入），通过调用该方法返回一个实例对象
兜底方法，调用默认构造方法创建一个实例对象

3.2. 对 RootBeanDefinition 加工处理

对应代码段：

// AbstractAutowireCapableBeanFactory#doCreateBean(...) 方法
// Allow post-processors to modify the merged bean definition.
// <2> 对 RootBeanDefinition（合并后）进行加工处理
synchronized (mbd.postProcessingLock) { // 加锁，线程安全
    // <2.1> 如果该 RootBeanDefinition 没有处理过，则进行下面的处理
    if (!mbd.postProcessed) {
        try {
            /**
             * <2.2> 对 RootBeanDefinition（合并后）进行加工处理
             * 调用所有 {@link MergedBeanDefinitionPostProcessor#postProcessMergedBeanDefinition}
             * 【重要】例如有下面两个处理器：
             * 1. AutowiredAnnotationBeanPostProcessor 会先解析出 @Autowired 和 @Value 注解标注的属性的注入元信息，后续进行依赖注入；
             * 2. CommonAnnotationBeanPostProcessor 会先解析出 @Resource 注解标注的属性的注入元信息，后续进行依赖注入，
             * 它也会找到 @PostConstruct 和 @PreDestroy 注解标注的方法，并构建一个 LifecycleMetadata 对象，用于后续生命周期中的初始化和销毁
             */
            applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
        }
        catch (Throwable ex) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                    "Post-processing of merged bean definition failed", ex);
        }
        // <2.3> 设置该 RootBeanDefinition 被处理过，避免重复处理
        mbd.postProcessed = true;
    }
}

在创建好实例对象后，允许你通过 MergedBeanDefinitionPostProcessor 处理器对该 RootBeanDefinition 进行加工处理，也可以从中获取相关信息

如果该 RootBeanDefinition 没有加工处理过，则进行下面的处理，否则忽略该过程
对 RootBeanDefinition（合并后）进行加工处理，调用 applyMergedBeanDefinitionPostProcessors(RootBeanDefinition mbd, Class<?> beanType, String beanName) 方法，如下：

// AbstractAutowireCapableBeanFactory.java
protected void applyMergedBeanDefinitionPostProcessors(RootBeanDefinition mbd, Class<?> beanType, String beanName) {
    for (BeanPostProcessor bp : getBeanPostProcessors()) {
        if (bp instanceof MergedBeanDefinitionPostProcessor) {
            MergedBeanDefinitionPostProcessor bdp = (MergedBeanDefinitionPostProcessor) bp;
            bdp.postProcessMergedBeanDefinition(mbd, beanType, beanName);
        }
    }
}

调用所有 MergedBeanDefinitionPostProcessor 的 postProcessMergedBeanDefinition 方法对 RootBeanDefinition 进行加工处理，例如：

AutowiredAnnotationBeanPostProcessor 会先解析出 @Autowired 和 @Value 注解标注的属性的注入元信息，后续进行依赖注入；
CommonAnnotationBeanPostProcessor 会先解析出 @Resource 注解标注的属性的注入元信息，后续进行依赖注入，它也会找到 @PostConstruct 和 @PreDestroy 注解标注的方法，并构建一个 LifecycleMetadata 对象，用于后续生命周期中的初始化和销毁

设置该 RootBeanDefinition 被处理过，避免重复处理

3.3. 提前暴露当前 Bean

目的是解决单例模式 Bean 的循环依赖注入

对应代码段：

// AbstractAutowireCapableBeanFactory#doCreateBean(...) 方法
// Eagerly cache singletons to be able to resolve circular references
// even when triggered by lifecycle interfaces like BeanFactoryAware.
// <3> 提前暴露这个 `bean`，如果可以的话，目的是解决单例模式 Bean 的循环依赖注入
// <3.1> 判断是否可以提前暴露
boolean earlySingletonExposure = (mbd.isSingleton() // 单例模式
        && this.allowCircularReferences // 允许循环依赖，默认为 true
        && isSingletonCurrentlyInCreation(beanName)); // 当前单例 bean 正在被创建，在前面已经标记过
if (earlySingletonExposure) {
    if (logger.isTraceEnabled()) {
        logger.trace("Eagerly caching bean '" + beanName +
                "' to allow for resolving potential circular references");
    }
    /**
     * <3.2>
     * 创建一个 ObjectFactory 实现类，用于返回当前正在被创建的 `bean`，提前暴露，保存在 `singletonFactories` （**三级 Map**）缓存中
     *
     * 可以回到前面的 {@link AbstractBeanFactory#doGetBean#getSingleton(String)} 方法
     * 加载 Bean 的过程会先从缓存中获取单例 Bean，可以避免单例模式 Bean 循环依赖注入的问题
     */
    addSingletonFactory(beanName,
            // ObjectFactory 实现类
            () -> getEarlyBeanReference(beanName, mbd, bean));
}

在创建好实例对象后，此时还没有进行属性的填充和初始化等工作，先判断是否可以提前暴露这个实例对象，目的是解决单例模式 Bean 的循环依赖注入

判断是否可以提前暴露，满足这些条件：单例模式、允许循环依赖（默认为 true）、当前单例 Bean 正在被创建（前面已经标记过）
如果可以的话，先通过 Lambda 表达式创建一个 ObjectFactory 实现类，如下：

// AbstractAutowireCapableBeanFactory.java
protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
    Object exposedObject = bean;
    if (!mbd.isSynthetic() // RootBeanDefinition 不是用户定义的（由 Spring 解析出来的）
        && hasInstantiationAwareBeanPostProcessors()) {
        for (BeanPostProcessor bp : getBeanPostProcessors()) {
            if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
                SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
                exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
            }
        }
    }
    return exposedObject;
}

入参 bean 为当前 Bean 的实例对象（未初始化），这个实现类允许通过 SmartInstantiationAwareBeanPostProcessor 对这个提前暴露的对象进行处理，最终会返回这个提前暴露的对象

然后调用 addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) 方法，如下：

// DefaultSingletonBeanRegistry.java
protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
    Assert.notNull(singletonFactory, "Singleton factory must not be null");
    synchronized (this.singletonObjects) {
        if (!this.singletonObjects.containsKey(beanName)) {
            this.singletonFactories.put(beanName, singletonFactory);
            this.earlySingletonObjects.remove(beanName);
            this.registeredSingletons.add(beanName);
        }
    }
}

可以看到会往 singletonFactories 集合（三级 Map）中添加当前 beanName 和 singletonFactory（ObjectFactory 实现类）的映射关系；从 earlySingletonObjects 集合（二级 Map）中移除当前 beanName；往 registeredSingletons 集合（已注册的 Bean 的名称集合）中添加当前 beanName

singletonObjects：一级缓存 Map

earlySingletonObjects： 二级缓存 Map

singletonFactories： 三级缓存 Map

4. bean实例化的主要方法

根据代码可以看出实例化bean的主要方法

obtainFromSupplier(instanceSupplier, beanName)：使用给定的回调方法初始化策略
instantiateUsingFactoryMethod(beanName, mbd, args)：使用 FactoryBean 的 factory-method 来创建
autowireConstructor(beanName, mbd, null, null)：autowire 自动注入，调用构造函数自动注入
instantiateBean(beanName, mbd) ：使用默认构造函数构造

4.1. BeanWrapper

可以看到上面四个方法返回类型都是BeanWrapper

4.1.1. 什么是BeanWrapper

BeanWrapper 是 Spring 框架中重要的组件类，它就相当于一个代理类，Spring 委托 BeanWrapper 完成 Bean 属性的填充工作。在 Bean 实例被 InstantiationStrategy 创建出来后，Spring 容器会将 Bean 实例通过 BeanWrapper 包裹起来

其主要的核心接口为

PropertyAccessor
TypeConverter
PropertyEditorRegistry

这三个接口主要的作用

BeanWrapper 继承上述三个接口，那么它就具有三重身份：

属性编辑器
属性编辑器注册表
类型转换器

在 Spring 容器中，BeanWrapper 主要用于在 Spring 容器初始化 Bean 时设置 Bean 的属性值。

4.2. obtainFromSupplier

	protected BeanWrapper obtainFromSupplier(Supplier<?> instanceSupplier, String beanName) {
		Object instance;
		// 获得bean的实例对象
		String outerBean = this.currentlyCreatedBean.get();
		// 设置新的 Bean 的对象名，到 currentlyCreatedBean 中
		this.currentlyCreatedBean.set(beanName);
		try {
			// 调用 Supplier 的 get()，返回一个 Bean 对象
			instance = instanceSupplier.get();
		}
		finally {
			// 创建bean的名字到currentlyCreatedBean中
			if (outerBean != null) {
				this.currentlyCreatedBean.set(outerBean);
			}
			else {
				this.currentlyCreatedBean.remove();
			}
		}
		// 未创建 Bean 对象，则创建 NullBean 对象
		if (instance == null) {
			instance = new NullBean();
		}
		// 创建bean的包装类
		BeanWrapper bw = new BeanWrapperImpl(instance);
		// 初始化bean的包装
		initBeanWrapper(bw);
		return bw;
	}

首先，调用 Supplier 的 get() 方法，获得一个 Bean 实例对象。
然后，根据该实例对象构造一个 BeanWrapper 对象 bw 。
最后，初始化该对象。

4.3. instantiateUsingFactoryMethod

假如存在工厂方法，则使用工厂方法完成bean的初始化工作

protected BeanWrapper instantiateUsingFactoryMethod(
			String beanName, RootBeanDefinition mbd, @Nullable Object[] explicitArgs) {
 
		return new ConstructorResolver(this).instantiateUsingFactoryMethod(beanName, mbd, explicitArgs);
	}

工厂类的委托类，最终使用的是其instantiateUsingFactoryMethod的方法

	public BeanWrapper instantiateUsingFactoryMethod(
			String beanName, RootBeanDefinition mbd, @Nullable Object[] explicitArgs) {
 
		//构造bean的包装类
		BeanWrapperImpl bw = new BeanWrapperImpl();
		//初始化包装类
		this.beanFactory.initBeanWrapper(bw);
 
		Object factoryBean;
		Class<?> factoryClass;
		boolean isStatic;
 
		//获得bean的工厂名字
		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");
			}
			//根据名字获得bean的工厂
			factoryBean = this.beanFactory.getBean(factoryBeanName);
			//假如bean是单例，且工厂已经存在
			if (mbd.isSingleton() && this.beanFactory.containsSingleton(beanName)) {
				throw new ImplicitlyAppearedSingletonException();
			}
			// 获得工厂字节码
			factoryClass = factoryBean.getClass();
			isStatic = false;
		}
		else {
			// 工厂名为空，则其可能是一个静态工厂
			// 静态工厂创建bean，必须要提供工厂的全类名
			// It's a static factory method on the bean class.
			if (!mbd.hasBeanClass()) {
				throw new BeanDefinitionStoreException(mbd.getResourceDescription(), beanName,
						"bean definition declares neither a bean class nor a factory-bean reference");
			}
			factoryBean = null;
			factoryClass = mbd.getBeanClass();
			isStatic = true;
		}
		// 获得 factoryMethodToUse、argsHolderToUse、argsToUse 属性
		Method factoryMethodToUse = null;
		ArgumentsHolder argsHolderToUse = null;
		Object[] argsToUse = null;
 
		// 如果指定了构造方法的参数，则构造bean 的时候使用此构造方法
		if (explicitArgs != null) {
			argsToUse = explicitArgs;
		}
		else { // 没有指定，则尝试从配置文件中解析
			Object[] argsToResolve = null;
			synchronized (mbd.constructorArgumentLock) {
				// 尝试用构造工厂中获取
				factoryMethodToUse = (Method) mbd.resolvedConstructorOrFactoryMethod;
				if (factoryMethodToUse != null && mbd.constructorArgumentsResolved) {
					// Found a cached factory method...
					// 尝试从缓存中获取
					argsToUse = mbd.resolvedConstructorArguments;
					if (argsToUse == null) {
						// 获取缓存中的构造函数参数的包可见字段
						argsToResolve = mbd.preparedConstructorArguments;
					}
				}
			}
			// 缓存中存在,则解析存储在 BeanDefinition 中的参数
			// 如给定方法的构造函数 A(int ,int )，则通过此方法后就会把配置文件中的("1","1")转换为 (1,1)
			// 缓存中的值可能是原始值也有可能是最终值
			if (argsToResolve != null) {
				argsToUse = resolvePreparedArguments(beanName, mbd, bw, factoryMethodToUse, argsToResolve, true);
			}
		}
 
		if (factoryMethodToUse == null || argsToUse == null) {
			// Need to determine the factory method...
			// Try all methods with this name to see if they match the given arguments.
			// 获取工厂方法的全名称
			factoryClass = ClassUtils.getUserClass(factoryClass);
			// 获取所有的待定方法
			Method[] rawCandidates = getCandidateMethods(factoryClass, mbd);
			List<Method> candidateList = new ArrayList<>();
			// 检索所有方法，这里是对方法进行过滤
			for (Method candidate : rawCandidates) {
				// 如果有方法为静态方法，且为工厂方法则添加到candidateList中
				if (Modifier.isStatic(candidate.getModifiers()) == isStatic && mbd.isFactoryMethod(candidate)) {
					candidateList.add(candidate);
				}
			}
			// 假如静态的工厂方法数量为1
			if (candidateList.size() == 1 && explicitArgs == null && !mbd.hasConstructorArgumentValues()) {
				Method uniqueCandidate = candidateList.get(0);
				// 使用静态的工厂方法创建bean
				if (uniqueCandidate.getParameterCount() == 0) {
					mbd.factoryMethodToIntrospect = uniqueCandidate;
					synchronized (mbd.constructorArgumentLock) {
						mbd.resolvedConstructorOrFactoryMethod = uniqueCandidate;
						mbd.constructorArgumentsResolved = true;
						mbd.resolvedConstructorArguments = EMPTY_ARGS;
					}
					bw.setBeanInstance(instantiate(beanName, mbd, factoryBean, uniqueCandidate, EMPTY_ARGS));
					return bw;
				}
			}
			// 排序构造函数
			Method[] candidates = candidateList.toArray(new Method[0]);
			// public 构造函数优先参数数量降序，非 public 构造函数参数数量降序
			AutowireUtils.sortFactoryMethods(candidates);
			// 用来承载解析后构造函数的值
			ConstructorArgumentValues resolvedValues = null;
			boolean autowiring = (mbd.getResolvedAutowireMode() == AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR);
			int minTypeDiffWeight = Integer.MAX_VALUE;
			Set<Method> ambiguousFactoryMethods = null;
 
			int minNrOfArgs;
			if (explicitArgs != null) {
				minNrOfArgs = explicitArgs.length;
			}
			else {
				// We don't have arguments passed in programmatically, so we need to resolve the
				// arguments specified in the constructor arguments held in the bean definition.
				// 如果getBean没有传递参数，则需要解析保存在 BeanDefinition 构造函数中指定的参数
				if (mbd.hasConstructorArgumentValues()) {
					// 构造函数的参数
					ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();
					resolvedValues = new ConstructorArgumentValues();
					// 将构造函数的参数解析进resolvedValues中
					minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);
				}
				else {
					minNrOfArgs = 0;
				}
			}
 
			LinkedList<UnsatisfiedDependencyException> causes = null;
			// 遍历 candidates 数组
			for (Method candidate : candidates) {
				// 方法体的参数
				Class<?>[] paramTypes = candidate.getParameterTypes();
 
				if (paramTypes.length >= minNrOfArgs) {
					// 保存参数的对象
					ArgumentsHolder argsHolder;
 
					// 传递了参数
					if (explicitArgs != null) {
						// Explicit arguments given -> arguments length must match exactly.
						// 显示给定参数，参数长度必须完全匹配
						if (paramTypes.length != explicitArgs.length) {
							continue;
						}
						// 根据参数创建参数持有者 ArgumentsHolder 对象
						argsHolder = new ArgumentsHolder(explicitArgs);
					}
					else {
						// 未提供参数
						// Resolved constructor arguments: type conversion and/or autowiring necessary.
						try {
							String[] paramNames = null;
							// 获取 ParameterNameDiscoverer 对象
							// ParameterNameDiscoverer 是用于解析方法和构造函数的参数名称的接口，为参数名称探测器
							ParameterNameDiscoverer pnd = this.beanFactory.getParameterNameDiscoverer();
							// 获取指定构造函数的参数名称
							if (pnd != null) {
								paramNames = pnd.getParameterNames(candidate);
							}
							// 在已经解析的构造函数参数值的情况下，创建一个参数持有者 ArgumentsHolder 对象
							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<>();
							}
							causes.add(ex);
							continue;
						}
					}
 
					// isLenientConstructorResolution 判断解析构造函数的时候是否以宽松模式还是严格模式
					// 严格模式：解析构造函数时，必须所有的都需要匹配，否则抛出异常
					// 宽松模式：使用具有"最接近的模式"进行匹配
					// typeDiffWeight：类型差异权重
					int typeDiffWeight = (mbd.isLenientConstructorResolution() ?
							argsHolder.getTypeDifferenceWeight(paramTypes) : argsHolder.getAssignabilityWeight(paramTypes));
					// Choose this factory method if it represents the closest match.
					// 代表最接近的类型匹配，则选择作为构造函数
					if (typeDiffWeight < minTypeDiffWeight) {
						factoryMethodToUse = candidate;
						argsHolderToUse = argsHolder;
						argsToUse = argsHolder.arguments;
						minTypeDiffWeight = typeDiffWeight;
						ambiguousFactoryMethods = null;
					}
					// Find out about ambiguity: In case of the same type difference weight
					// for methods with the same number of parameters, collect such candidates
					// and eventually raise an ambiguity exception.
					// However, only perform that check in non-lenient constructor resolution mode,
					// and explicitly ignore overridden methods (with the same parameter signature).
					// 如果具有相同参数数量的方法具有相同的类型差异权重，则收集此类型选项
					// 但是，仅在非宽松构造函数解析模式下执行该检查，并显式忽略重写方法（具有相同的参数签名）
					else if (factoryMethodToUse != null && typeDiffWeight == minTypeDiffWeight &&
							!mbd.isLenientConstructorResolution() &&
							paramTypes.length == factoryMethodToUse.getParameterCount() &&
							!Arrays.equals(paramTypes, factoryMethodToUse.getParameterTypes())) {
						if (ambiguousFactoryMethods == null) {
							ambiguousFactoryMethods = new LinkedHashSet<>();
							// 存在多个可选方法
							ambiguousFactoryMethods.add(factoryMethodToUse);
						}
						ambiguousFactoryMethods.add(candidate);
					}
				}
			}
			// 没有可执行的工厂方法，抛出异常
			if (factoryMethodToUse == null) {
				if (causes != null) {
					UnsatisfiedDependencyException ex = causes.removeLast();
					for (Exception cause : causes) {
						this.beanFactory.onSuppressedException(cause);
					}
					throw ex;
				}
				List<String> argTypes = new ArrayList<>(minNrOfArgs);
				if (explicitArgs != null) {
					for (Object arg : explicitArgs) {
						argTypes.add(arg != null ? arg.getClass().getSimpleName() : "null");
					}
				}
				else if (resolvedValues != null) {
					Set<ValueHolder> valueHolders = new LinkedHashSet<>(resolvedValues.getArgumentCount());
					valueHolders.addAll(resolvedValues.getIndexedArgumentValues().values());
					valueHolders.addAll(resolvedValues.getGenericArgumentValues());
					for (ValueHolder value : valueHolders) {
						String argType = (value.getType() != null ? ClassUtils.getShortName(value.getType()) :
								(value.getValue() != null ? value.getValue().getClass().getSimpleName() : "null"));
						argTypes.add(argType);
					}
				}
				String argDesc = StringUtils.collectionToCommaDelimitedString(argTypes);
				throw new BeanCreationException(mbd.getResourceDescription(), beanName,
						"No matching factory method found: " +
						(mbd.getFactoryBeanName() != null ?
							"factory bean '" + mbd.getFactoryBeanName() + "'; " : "") +
						"factory method '" + mbd.getFactoryMethodName() + "(" + argDesc + ")'. " +
						"Check that a method with the specified name " +
						(minNrOfArgs > 0 ? "and arguments " : "") +
						"exists and that it is " +
						(isStatic ? "static" : "non-static") + ".");
			}
			else if (void.class == factoryMethodToUse.getReturnType()) {
				throw new BeanCreationException(mbd.getResourceDescription(), beanName,
						"Invalid factory method '" + mbd.getFactoryMethodName() +
						"': needs to have a non-void return type!");
			}
			else if (ambiguousFactoryMethods != null) {
				throw new BeanCreationException(mbd.getResourceDescription(), beanName,
						"Ambiguous factory method matches found in bean '" + beanName + "' " +
						"(hint: specify index/type/name arguments for simple parameters to avoid type ambiguities): " +
						ambiguousFactoryMethods);
			}
 
			if (explicitArgs == null && argsHolderToUse != null) {
				mbd.factoryMethodToIntrospect = factoryMethodToUse;
				argsHolderToUse.storeCache(mbd, factoryMethodToUse);
			}
		}
		// 验证
		Assert.state(argsToUse != null, "Unresolved factory method arguments");
		// 创建 Bean 对象，并设置到 bw 中
		bw.setBeanInstance(instantiate(beanName, mbd, factoryBean, factoryMethodToUse, argsToUse));
		return bw;
	}

4.4. autowireConstructor

带有参数的构造方法，来初始化 Bean 对象

protected BeanWrapper autowireConstructor(
			String beanName, RootBeanDefinition mbd, @Nullable Constructor<?>[] ctors, @Nullable Object[] explicitArgs) {
 
		return new ConstructorResolver(this).autowireConstructor(beanName, mbd, ctors, explicitArgs);
	}
 
 
public BeanWrapper autowireConstructor(String beanName, RootBeanDefinition mbd,
			@Nullable Constructor<?>[] chosenCtors, @Nullable Object[] explicitArgs) {
 
		// 封装BeanWrapper
		BeanWrapperImpl bw = new BeanWrapperImpl();
		// 初始化BeanWrapper
		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) {
					// Found a cached constructor...
					// 从缓存中获取构造参数
					argsToUse = mbd.resolvedConstructorArguments;
					if (argsToUse == null) {
						argsToResolve = mbd.preparedConstructorArguments;
					}
				}
			}
			// 缓存中存在,则解析存储在 BeanDefinition 中的参数
			// 如给定方法的构造函数 A(int ,int )，则通过此方法后就会把配置文件中的("1","1")转换为 (1,1)
			// 缓存中的值可能是原始值也有可能是最终值
			if (argsToResolve != null) {
				argsToUse = resolvePreparedArguments(beanName, mbd, bw, constructorToUse, argsToResolve, true);
			}
		}
 
		// 没有缓存，则尝试从配置文件中获取参数
		if (constructorToUse == null || argsToUse == null) {
			// Take specified constructors, if any.
			// 如果 chosenCtors 未传入，则获取构造方法们
			Constructor<?>[] candidates = chosenCtors;
			if (candidates == null) {
				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);
				}
			}
 
			// 假如参数匹配，构造bean的包装
			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;
					}
					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 {
				// 从 BeanDefinition 中获取构造参数，也就是从配置文件中提取构造参数
				ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();
				resolvedValues = new ConstructorArgumentValues();
				// 解析构造函数的参数
				// 将该 bean 的构造函数参数解析为 resolvedValues 对象，其中会涉及到其他 bean
				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();
 
				if (constructorToUse != null && argsToUse != null && argsToUse.length > paramTypes.length) {
					// Already found greedy constructor that can be satisfied ->
					// do not look any further, there are only less greedy constructors left.
					// 如果已经找到选用的构造函数或者需要的参数个数小于当前的构造函数参数个数，则终止。
					// 因为，已经按照参数个数降序排列了
					break;
				}
				// 参数数量不正确，继续
				if (paramTypes.length < minNrOfArgs) {
					continue;
				}
 
				// 参数持有者 ArgumentsHolder 对象
				ArgumentsHolder argsHolder;
				if (resolvedValues != null) {
					try {
						// 注释上获取参数名称
						String[] paramNames = ConstructorPropertiesChecker.evaluate(candidate, paramTypes.length);
						if (paramNames == null) {
							// 获取构造函数、参数探测器
							ParameterNameDiscoverer pnd = this.beanFactory.getParameterNameDiscoverer();
							if (pnd != null) {
								// 通过探测器获取构造函数的参数名称
								paramNames = pnd.getParameterNames(candidate);
							}
						}
						// 根据构造函数和构造参数，创建参数持有者 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 LinkedList<>();
						}
						causes.add(ex);
						continue;
					}
				}
				else {
					// continue 构造函数没有参数
					// Explicit arguments given -> arguments length must match exactly.
					if (paramTypes.length != explicitArgs.length) {
						continue;
					}
					argsHolder = new ArgumentsHolder(explicitArgs);
				}
 
				// isLenientConstructorResolution 判断解析构造函数的时候是否以宽松模式还是严格模式
				// 严格模式：解析构造函数时，必须所有的都需要匹配，否则抛出异常
				// 宽松模式：使用具有"最接近的模式"进行匹配
				// typeDiffWeight：类型差异权重
				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);
			}
		}
		// 创建bean并包装
		Assert.state(argsToUse != null, "Unresolved constructor arguments");
		bw.setBeanInstance(instantiate(beanName, mbd, constructorToUse, argsToUse));
		return bw;
	}

4.5. instantiateBean

不带有参数的构造方法，来初始化 Bean 对象

	protected BeanWrapper instantiateBean(String beanName, RootBeanDefinition mbd) {
		try {
			Object beanInstance;
			if (System.getSecurityManager() != null) {
				beanInstance = AccessController.doPrivileged(
						(PrivilegedAction<Object>) () -> getInstantiationStrategy().instantiate(mbd, beanName, this),
						getAccessControlContext());
			}
			else {
				beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, this);
			}
			BeanWrapper bw = new BeanWrapperImpl(beanInstance);
			initBeanWrapper(bw);
			return bw;
		}
		catch (Throwable ex) {
			throw new BeanCreationException(
					mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
		}
	}

可以看到是通过方法getInstantiationStrategy().instantiate()来创建Bean

4.5.1 getInstantiationStrategy().instantiate()通过策略模式来实例化Bean

getInstantiationStrategy().instantiate()调用了SimpleInstantiationStrategy类中的实例化Bean的方法，源码如下：

    //org.springframework.beans.factory.support.SimpleInstantiationStrategy
    //使用初始化策略实例化Bean对象  
    @Override
	public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
		// Don't override the class with CGLIB if no overrides.
		// 没有覆盖，直接使用反射实例化即可
		if (!bd.hasMethodOverrides()) {
			// 获得构造方法 constructorToUse
			Constructor<?> constructorToUse;
			synchronized (bd.constructorArgumentLock) {
				constructorToUse = (Constructor<?>) bd.resolvedConstructorOrFactoryMethod;
				if (constructorToUse == null) {
					final Class<?> clazz = bd.getBeanClass();
					// 如果是接口，抛出 BeanInstantiationException 异常
					if (clazz.isInterface()) {
						throw new BeanInstantiationException(clazz, "Specified class is an interface");
					}
					try {
						// 从 clazz 中，获得构造方法
						if (System.getSecurityManager() != null) {
							constructorToUse = AccessController.doPrivileged(
									(PrivilegedExceptionAction<Constructor<?>>) clazz::getDeclaredConstructor);
						}
						else {
							constructorToUse = clazz.getDeclaredConstructor();
						}
						// 标记 resolvedConstructorOrFactoryMethod 属性
						bd.resolvedConstructorOrFactoryMethod = constructorToUse;
					}
					catch (Throwable ex) {
						throw new BeanInstantiationException(clazz, "No default constructor found", ex);
					}
				}
			}
			// 通过 BeanUtils 直接使用构造器对象实例化 Bean 对象
			return BeanUtils.instantiateClass(constructorToUse);
		}
		else {
			// Must generate CGLIB subclass.
			// 生成 CGLIB 创建的子类对象
			return instantiateWithMethodInjection(bd, beanName, owner);
		}
	}

通过分析，如果Bean有方法被覆盖了，则使用JDK的反射机制进行实例化，否则使用CGLIB进行实例化。

4.5.2 通过 BeanUtils 直接使用构造器对象实例化 Bean 对象

	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];
					}
				}
                // 使用JDK反射进行实例化
				return ctor.newInstance(argsWithDefaultValues);
			}
		}
		catch (InstantiationException ex) {
			throw new BeanInstantiationException(ctor, "Is it an abstract class?", ex);
		}
		catch (IllegalAccessException ex) {
			throw new BeanInstantiationException(ctor, "Is the constructor accessible?", ex);
		}
		catch (IllegalArgumentException ex) {
			throw new BeanInstantiationException(ctor, "Illegal arguments for constructor", ex);
		}
		catch (InvocationTargetException ex) {
			throw new BeanInstantiationException(ctor, "Constructor threw exception", ex.getTargetException());
		}
	}

这里我们重点关注有构造函数的实例化，实例化方式为 ctor.newInstance(args);，把入参信息传递给 newInstance 进行实例化。

4.5.3 使用CGLIB 实例化 Bean 对象

instantiateWithMethodInjection方法调用SimpleInstantiationStrategy的子类CglibSubclassingInstantiationStrategy，使用CGLIB来进行初始化，源码如下：

//org.springframework.beans.factory.support.CglibSubclassingInstantiationStrategy
//使用CGLIB进行Bean对象实例化  
public Object instantiate(@Nullable Constructor<?> ctor, @Nullable Object... args) {  
    //创建代理子类  
    Class<?> subclass = createEnhancedSubclass(this.beanDefinition);       
    Object instance; 
    if (ctor == null) { 
        instance = BeanUtils.instantiateClass(subclass); 
    } 
    else { 
        try { 
            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;
}  
  
private Class<?> createEnhancedSubclass(RootBeanDefinition beanDefinition) {  
    //CGLIB中的类  
    Enhancer enhancer = new Enhancer(); 
    //将Bean本身作为其基类  
    enhancer.setSuperclass(beanDefinition.getBeanClass());  
    enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE); 
    if (this.owner instanceof ConfigurableBeanFactory) { 
        ClassLoader cl = ((ConfigurableBeanFactory) this.owner).getBeanClassLoader(); 
        enhancer.setStrategy(new ClassLoaderAwareGeneratorStrategy(cl)); 
    } 
    enhancer.setCallbackFilter(new MethodOverrideCallbackFilter(beanDefinition));   
    enhancer.setCallbackTypes(CALLBACK_TYPES); 
    //使用CGLIB的createClass方法生成实例对象  
    return enhancer.createClass();
}

CGLIB是一个常用的字节码生成器的类库，它提供了一系列API实现java字节码的生成和转换功能。在学习JDK的动态代理时知道，JDK的动态代理只能针对接口，如果一个类没有实现任何接口，要对其进行动态代理只能使用CGLIB。

Spring createBeanInstance方法创建Bean对象

1. createBeanInstance方法创建Bean的java实例对象

2. 创建 Class 对象前置检查

2.1. resolveBeanClass 方法

2.1.1. doResolveBeanClass 方法

2.2. MethodOverride 的验证与准备

2.3. 实例化前阶段

2.3.1. resolveBeforeInstantiation 方法

3. Bean 的实例化

3.1. createBeanInstance 方法

3.2. 对 RootBeanDefinition 加工处理

3.3. 提前暴露当前 Bean

4. bean实例化的主要方法

4.1. BeanWrapper

4.1.1. 什么是BeanWrapper

4.2. obtainFromSupplier

4.3. instantiateUsingFactoryMethod

4.4. autowireConstructor

4.5. instantiateBean

4.5.1 getInstantiationStrategy().instantiate()通过策略模式来实例化Bean

4.5.2 通过 BeanUtils 直接使用构造器对象实例化 Bean 对象

4.5.3 使用CGLIB 实例化 Bean 对象