方法执行流程

    1. 判断可以访问
    2. 通过 Supplier<?> 创建对象
    3. 通过工厂方法创建对象
    4. 使用合适的构造函数创建对象
    5. 使用无参构造函数创建对象

    方法完整内容

    1. protected BeanWrapper createBeanInstance(String beanName
    2.                                          , RootBeanDefinition mbd, @Nullable Object[] args) {
    3.     // Make sure bean class is actually resolved at this point.
    4.     // 得到对应的Class对象
    5.     Class<?> beanClass = resolveBeanClass(mbd, beanName);
    6.     // 判断Class对象；访问修饰符；nonPublicAccessAllowed默认为true
    7.     if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) 
    8.         && !mbd.isNonPublicAccessAllowed()) {
    9.         throw new BeanCreationException(mbd.getResourceDescription(), beanName,
    10.                 "Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
    11.     }
    12.     // 通过给定的函数获取对象
    13.     Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
    14.     if (instanceSupplier != null) {
    15.         return obtainFromSupplier(instanceSupplier, beanName);
    16.     }
    17.     // 工厂方法获取对象
    18.     if (mbd.getFactoryMethodName() != null) {
    19.         return instantiateUsingFactoryMethod(beanName, mbd, args);
    20.     }
    22.     // 一个类可能有多个构造器，Spring根据参数个数、类型确定需要调用的构造器
    24.     // Shortcut when re-creating the same bean...
    25.     // 标记防止重复创建
    26.     boolean resolved = false;
    27.     // 是否需要自动装配
    28.     boolean autowireNecessary = false;
    29.     // 如果没有参数
    30.     if (args == null) {
    31.         synchronized (mbd.constructorArgumentLock) {
    32.             // 已经缓存的构造方法或者工厂方法（Spring会将解析过后确定下来的构造器或工厂方法保存在缓存中，
    33.             // 避免再次创建相同bean时再次解析）
    34.             if (mbd.resolvedConstructorOrFactoryMethod != null) {
    35.                 resolved = true;
    36.                 autowireNecessary = mbd.constructorArgumentsResolved;
    37.             }
    38.         }
    39.     }
    40.     // 有构造参数或者工厂方法
    41.     if (resolved) {
    42.         if (autowireNecessary) {
    43.             // 构造器有参数，构造函数自动注入
    44.             return autowireConstructor(beanName, mbd, null, null);
    45.         } else {
    46.             // 默认构造函数
    47.             return instantiateBean(beanName, mbd);
    48.         }
    49.     }
    51.     // Candidate constructors for autowiring?
    52.     // 从bean后置处理器中为自动装配寻找构造方法
    53.     Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
    54.     if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
    55.             mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
    56.         return autowireConstructor(beanName, mbd, ctors, args);
    57.     }
    59.     // Preferred constructors for default construction?
    60.     // 找出最合适的默认构造方法
    61.     ctors = mbd.getPreferredConstructors();
    62.     if (ctors != null) {
    63.         // 构造函数自动注入
    64.         return autowireConstructor(beanName, mbd, ctors, null);
    65.     }
    67.     // No special handling: simply use no-arg constructor.
    68.     // 使用默认无参构造函数创建对象
    69.     return instantiateBean(beanName, mbd);
    70. }