/**
   * Actually create the specified bean. Pre-creation processing has already happened
   * at this point, e.g. checking {@code postProcessBeforeInstantiation} callbacks.
   * <p>Differentiates between default bean instantiation, use of a
   * factory method, and autowiring a constructor.
   *
   * @param beanName the name of the bean
   * @param mbd      the merged bean definition for the bean
   * @param args     explicit arguments to use for constructor or factory method invocation
   * @return a new instance of the bean
   * @throws BeanCreationException if the bean could not be created
   * @see #instantiateBean
   * @see #instantiateUsingFactoryMethod
   * @see #autowireConstructor
   */
  protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
      throws BeanCreationException {

    // Instantiate the bean.
    // 这个BeanWrapper是用来持有创建出来的bean对象的
    BeanWrapper instanceWrapper = null;
    if (mbd.isSingleton()) {
      // 如果是单例对象，从factoryBean实例缓存中移除当前bean定义信息
      instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
    }
    if (instanceWrapper == null) {
      // 根据执行bean使用对应的策略创建新的实例，如工厂方法，构造函数主动注入、简单初始化
      instanceWrapper = createBeanInstance(beanName, mbd, args);
    }
    // 得到半成品的对象，只完成了实例化，未实现初始化
    Object bean = instanceWrapper.getWrappedInstance();
    Class<?> beanType = instanceWrapper.getWrappedClass();
    if (beanType != NullBean.class) {
      mbd.resolvedTargetType = beanType;
    }

    // Allow post-processors to modify the merged bean definition.
    synchronized (mbd.postProcessingLock) {
      if (!mbd.postProcessed) {
        try {

          applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);// 完成注解扫描，为后面的属性填充做准备
        } catch (Throwable ex) {
          throw new BeanCreationException(mbd.getResourceDescription(), beanName,
              "Post-processing of merged bean definition failed", ex);
        }
        mbd.postProcessed = true;
      }
    }

    // Eagerly cache singletons to be able to resolve circular references
    // even when triggered by lifecycle interfaces like BeanFactoryAware.
    boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
        isSingletonCurrentlyInCreation(beanName));
    if (earlySingletonExposure) {
      if (logger.isTraceEnabled()) {
        logger.trace("Eagerly caching bean '" + beanName +
            "' to allow for resolving potential circular references");
      }
      // 加入三级缓存，但加的不是对象，而是拉姆达表达式
      addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
    }

    // Initialize the bean instance.
    Object exposedObject = bean;
    try {
      // 对bean的属性进行填充，将各个属性值注入，其中，可能存在依赖于其他bean属性，则会递归初始化依赖的bean
      populateBean(beanName, mbd, instanceWrapper);
      //执行初始化逻辑
      exposedObject = initializeBean(beanName, exposedObject, mbd);//aop
    } catch (Throwable ex) {
      if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
        throw (BeanCreationException) ex;
      } else {
        throw new BeanCreationException(
            mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
      }
    }

    ……
  }

public class A{

  private int a = 10;
}

  public static void main(String[] args) {
    System.out.println("Hello world");
  }