接着 我们正式开始学习获取 bean 实例方法，该方法是Spring 最核心的方法，也是最难的方法，我们首先不能扣太多的细节，先从一个比较简单的实例化的依赖注入入手。

  1. @Override
  2. public Object getBean(String name) throws BeansException {
  3.     // 获取name对应的bean实例，如果不存在，则创建一个
  4.     return doGetBean(name, null, null, false);
  5. }

doGetBean 方法详解。

  1. protected <T> T doGetBean(
  2. String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
  3.             throws BeansException {
  5.   // 1.解析beanName，主要是解析别名、去掉FactoryBean的前缀“&”
  6.   String beanName = transformedBeanName(name);
  7.   Object bean;
  9.   // 2.从Spring的三级缓存中获取bean,解决循环依赖的主要的思想
  10.   // 当A依赖B，B返回来也依赖A的时候，这个时候获取到的A就是从Spring的第三级缓存中获取到
  11.   Object sharedInstance = getSingleton(beanName);
  13.   // 6.如果不是仅仅做类型检测，而是创建bean实例，这里要将beanName放到alreadyCreated缓存
  14.   if (!typeCheckOnly) {
  15.         markBeanAsCreated(beanName);
  16.   }
  18.   try {
  19.     // 7.根据beanName重新获取MergedBeanDefinition（步骤6将MergedBeanDefinition删除了，这边获取一个新的）
  20.     RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
  21.     checkMergedBeanDefinition(mbd, beanName, args);
  23.     // 8.拿到当前bean依赖的bean名称集合，在实例化自己之前，需要先实例化自己依赖的bean
  24.     String[] dependsOn = mbd.getDependsOn();
  25.     if (dependsOn != null) {
  26.         // 8.1 遍历当前bean依赖的bean名称集合
  27.         for (String dep : dependsOn) {
  28.             // 8.2 检查dep是否依赖于beanName，即检查是否存在循环依赖
  29.             if (isDependent(beanName, dep)) {
  30.                 // 8.3 如果是循环依赖则抛异常
  31.                 throw new BeanCreationException("Circular depends-on relationship between '" );}
  32.                 registerDependentBean(dep, beanName);
  33.                 try {
  34.                      getBean(dep);
  35.                 }
  36.                 catch (NoSuchBeanDefinitionException ex) {
  37.                     throw new BeanCreationException(mbd.getResourceDescription(), beanName,
  38.                                     "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
  39.                         }
  40.                     }
  41.                 }
  43.     // Create bean instance.创建bean实例
  44.     // scope为singleton的bean创建（新建了一个ObjectFactory，并且重写了getObject方法）
  45.     if (mbd.isSingleton()) {
  46.         sharedInstance = getSingleton(beanName, () -> {
  47.             try {
  48.                 // ****调用createBean创建Bean实例****
  49.                 return createBean(beanName, mbd, args);
  50.             }
  51.         });
  52.         bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
  53.     }
  54. }
  56.     // 10.检查所需类型是否与实际的bean对象的类型匹配
  57.     if (requiredType != null && !requiredType.isInstance(bean)) {
  58.         T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
  59.         if (convertedBean == null) {
  60.             throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
  61.         }
  62.         return convertedBean;
  63.     }
  64.     return (T) bean;
  65. }

createBean方法总体流程

  1. @Override
  2.     protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
  3.             throws BeanCreationException {
  5.         RootBeanDefinition mbdToUse = mbd;
  7.         // 1.解析beanName对应的Bean的类型，例如：com.joonwhee.open.demo.service.impl.UserServiceImpl
  8.         Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
  9.         if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
  10.             // 如果resolvedClass存在，并且mdb的beanClass类型不是Class，并且mdb的beanClass不为空（则代表beanClass存的是Class的name）,
  11.             // 则使用mdb深拷贝一个新的RootBeanDefinition副本，并且将解析的Class赋值给拷贝的RootBeanDefinition副本的beanClass属性，
  12.             // 该拷贝副本取代mdb用于后续的操作
  13.             mbdToUse = new RootBeanDefinition(mbd);
  14.             mbdToUse.setBeanClass(resolvedClass);
  15.         }
  18.         try {
  19.             // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
  20.             // 3.实例化前的处理，给InstantiationAwareBeanPostProcessor一个机会返回代理对象来替代真正的bean实例，达到“短路”效果
  21.             Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
  22.             // 4.如果bean不为空，则会跳过Spring默认的实例化过程，直接使用返回的bean
  23.             if (bean != null) {
  24.                 return bean;
  25.             }
  26.         }
  28.         // 5.创建Bean实例（真正创建Bean的方法）
  29.         Object beanInstance = doCreateBean(beanName, mbdToUse, args);
  30.         return beanInstance;
  31.     }

doCreateBean方法

  1. protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
  2.             throws BeanCreationException {
  4.         // Instantiate the bean.
  5.         // 1.新建Bean包装类
  6.         BeanWrapper instanceWrapper = null;
  7.         if (mbd.isSingleton()) {
  8.             // 2.如果是FactoryBean，则需要先移除未完成的FactoryBean实例的缓存
  9.             // *********重点*********
  10.             instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
  11.         }
  12.         if (instanceWrapper == null) {
  13.             // 3.根据beanName、mbd、args，使用对应的策略创建Bean实例，并返回包装类BeanWrapper
  14.             instanceWrapper = createBeanInstance(beanName, mbd, args);
  15.         }
  16.         // 4.拿到创建好的Bean实例
  17.         final Object bean = instanceWrapper.getWrappedInstance();
  18.         // 5.拿到Bean实例的类型
  19.         Class<?> beanType = instanceWrapper.getWrappedClass();
  20.         if (beanType != NullBean.class) {
  21.             mbd.resolvedTargetType = beanType;
  22.         }
  24.         // Allow post-processors to modify the merged bean definition.
  25.        // 6.应用后置处理器MergedBeanDefinitionPostProcessor，允许修改MergedBeanDefinition，
  26.        // Autowired注解正是通过此方法实现注入类型的预解析
  27.         synchronized (mbd.postProcessingLock) {
  28.             if (!mbd.postProcessed) {
  29.                 try {
  30.                     applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
  31.                 }
  32.                 catch (Throwable ex) {
  33.                     throw new BeanCreationException(mbd.getResourceDescription(), beanName,
  34.                             "Post-processing of merged bean definition failed", ex);
  35.                 }
  36.                 mbd.postProcessed = true;
  37.             }
  38.         }
  40.         // 7.判断是否需要提早曝光实例：单例 && 允许循环依赖 && 当前bean正在创建中
  41.         boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
  42.                 isSingletonCurrentlyInCreation(beanName));
  43.         if (earlySingletonExposure) {
  44.             // 8.提前曝光beanName的ObjectFactory，放入到Sprign的三级缓存中
  45.             addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
  46.         }
  48.         // Initialize the bean instance.初始化bean实例。
  49.         Object exposedObject = bean;
  50.         try {
  51.             // 9.对bean进行属性填充；其中，可能存在依赖于其他bean的属性，则会递归初始化依赖的bean实例
  52.             populateBean(beanName, mbd, instanceWrapper);
  53.             exposedObject = initializeBean(beanName, exposedObject, mbd);
  54.         }
  55.         //......
  56.         return exposedObject;
  57.     }

createBeanInstance创建Bean实例方法

  1. protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
  2.     // Make sure bean class is actually resolved at this point.
  3.     // 解析bean的类型信息,
  4.     Class<?> beanClass = resolveBeanClass(mbd, beanName);
  6.     // beanClass != null && 当前类不是public && 不允许访问非公共构造函数和方法。抛出异常
  7.     if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
  8.         throw new BeanCreationException(mbd.getResourceDescription(), beanName,
  9.                 "Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
  10.     }
  12.     // 1. 是否有bean的 Supplier 接口，如果有，通过回调来创建bean
  13.     Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
  14.     if (instanceSupplier != null) {
  15.         return obtainFromSupplier(instanceSupplier, beanName);
  16.     }
  17.     // 2. 如果工厂方法不为空，则使用工厂方法初始化策略
  18.     // 通过 @Bean 注解方法注入的bean或者xml 配置factory-method属性注入的
  19.     // BeanDefinition 会存在这个值。而注入这个bean的方法就是工厂方法。后面会详细解读
  20.     if (mbd.getFactoryMethodName() != null) {
  21.         // 执行工厂方法，创建bean
  22.         return instantiateUsingFactoryMethod(beanName, mbd, args);
  23.     }
  25.     /* 3. 尝试使用构造函数构建bean，后面详解
  26.     * 经过上面两步，Spring确定没有其他方式来创建bean，所以打算使用构造函数来进行创建bean。 
  27.     * 但是 bean 的构造函数可能有多个，需要确定使用哪一个。
  28.     */
  30.     // resolved 表示构造函数是否已经解析完成
  31.     boolean resolved = false;
  32.     // autowireNecessary: 是否需要自动注入（即是否需要解析构造函数参数）
  33.     boolean autowireNecessary = false;
  34.     if (args == null) {
  35.         // 2.加锁
  36.         synchronized (mbd.constructorArgumentLock) {
  37.             // 一个类可能有多个不同的构造函数，每个构造函数参数列表不同，所以调用前需要根据参数锁定对应的构造函数或工程方法
  38.             // 如果这个bean的构造函数或者工厂方法已经解析过了，会保存到 mbd.resolvedConstructorOrFactoryMethod 中。这里来判断是否已经解析过了。
  39.             if (mbd.resolvedConstructorOrFactoryMethod != null) {
  40.                 // 2.1 则将resolved标记为已解析
  41.                 resolved = true;
  42.                 // 2.2 根据constructorArgumentsResolved判断是否需要自动注入
  43.                 autowireNecessary = mbd.constructorArgumentsResolved;
  44.             }
  45.         }
  46.     }
  47.     // 如果已经解析过则使用功能解析好的构造函数方法，不需要再次解析。
  48.     // 这里的是通过 mbd.resolvedConstructorOrFactoryMethod 属性来缓存解析过的构造函数。
  49.     if (resolved) {
  50.         if (autowireNecessary) {
  51.             // 3.1 需要自动注入，则执行构造函数自动注入
  52.             return autowireConstructor(beanName, mbd, null, null);
  53.         } else {
  54.             // 3.2 否则使用默认的构造函数进行bean的实例化
  55.             return instantiateBean(beanName, mbd);
  56.         }
  57.     }
  59.     // Spring通过调用后置处理器的determineCandidateConstructors方法将所有被@Autowired标注的构造方法给查找了出来,
  60.     // 如果不存在缓存则需要进行解析，这里通过 determineConstructorsFromBeanPostProcessors 方法调用了
  61.     // SmartInstantiationAwareBeanPostProcessor.determineCandidateConstructors 的后处理器方法来进行解析，
  62.     // Spring 默认的实现在AutowiredAnnotationBeanPostProcessor.determineCandidateConstructors 方法中。
  63.     // 通过determineCandidateConstructors 方法获取到了候选的构造函数(因为满足条件的构造函数可能不止一个，需要进行进一步的选择)。
  64.     Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
  65.     if (ctors != null ||
  66.             mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
  67.             mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
  68.         // 5.如果ctors不为空 || mbd的注入方式为AUTOWIRE_CONSTRUCTOR || mdb定义了构造函数的参数值 || args不为空，则执行构造函数自动注入
  69.         return autowireConstructor(beanName, mbd, ctors, args);
  70.     }
  72.     // No special handling: simply use no-arg constructor.
  73.     // 6.没有特殊处理，则使用默认的构造函数进行bean的实例化
  74.     return instantiateBean(beanName, mbd);
  75. }

创建实例的方法通常有以下几种：
Supplier方法 : 留给用户可以进行扩展的方法

  1. public class CustomSupplierBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
  3.     //自己定义了 supplier
  4.     @Override
  5.     public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
  6.         AbstractBeanDefinition beanDefinition = (AbstractBeanDefinition) beanFactory.getBeanDefinition("student");
  7.         beanDefinition.setInstanceSupplier(SupplierObject::create);
  8.         System.out.println("do Custom Supplier BeanFactoryPostProcessor");
  9.     }
  11.     // 没有定义 supplier，这样也可以。
  12.     @Override
  13.     public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
  14.         AbstractBeanDefinition beanDefinition = (AbstractBeanDefinition) beanFactory.getBeanDefinition("student");
  15.         beanDefinition.setInstanceSupplier(()->{
  16.             Student custom = new Student();
  17.             custom.setStudentName("zhao");
  18.             return custom;
  19.         });
  20.         System.out.println("do Custom Supplier BeanFactoryPostProcessor");
  21.     }
  22. }

工厂方法:https://www.cnblogs.com/javastack/p/13431216.html
构造函数自动装配（通常指带有参数的构造函数）

简单实例化
1、通过BeanUtils，它使用了JVM的反射功能来生成Java对象实例
2、用CGLIB来生成，CGLIB是一种常用的字节码生成器的类库

  1. @Override
  2.     public Object instantiate(RootBeanDefinition bd, String beanName, BeanFactory owner) {
  3.         // Don't override the class with CGLIB if no overrides.
  4.         // 如果MethOverrides为空.
  5.         // spring有两个标签参数会产生MethodOverrides ，分别是 lookup-method,replaced-method 
  6.         // 其中replaced-method使用方法 https://blog.csdn.net/wang0907/article/details/114325252
  7.         if (bd.getMethodOverrides().isEmpty()) {
  8.             Constructor<?> constructorToUse;
  9.             synchronized (bd.constructorArgumentLock) {
  10.                 // 获取bd.resolvedConstructorOrFactoryMethod已解析的构造器或工厂方法
  11.                 constructorToUse = (Constructor<?>) bd.resolvedConstructorOrFactoryMethod;
  12.                 // 如果为空
  13.                 if (constructorToUse == null) {
  14.                     final Class<?> clazz = bd.getBeanClass();
  15.                     // 如果是接口,抛出异常
  16.                     if (clazz.isInterface()) {
  17.                         throw new BeanInstantiationException(clazz, "Specified class is an interface");
  18.                     }
  19.                     try {
  20.                         else {
  21.                             //通过bean的类clazz来得到声明的构造函数
  22.                             constructorToUse =    clazz.getDeclaredConstructor((Class[]) null);
  23.                         }
  24.                         // 并赋值回给bd.resolvedConstructorOrFactoryMethod
  25.                         bd.resolvedConstructorOrFactoryMethod = constructorToUse;
  26.                     }
  27.                     catch (Throwable ex) {
  28.                         throw new BeanInstantiationException(clazz, "No default constructor found", ex);
  29.                     }
  30.                 }
  31.             }
  32.             // 通过BeanUtils方法实例化bean
  33.             return BeanUtils.instantiateClass(constructorToUse);
  34.         }
  35.         else {
  36.             // Must generate CGLIB subclass.
  37.             // 如果MethodOverrides不为空,生成cglib的子类
  38.             return instantiateWithMethodInjection(bd, beanName, owner);
  39.         }
  40.     }