if (isPrototypeCurrentlyInCreation(beanName)) {
 throw new BeanCurrentlyInCreationException(beanName);
}

 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);
 }
 if (instanceWrapper == null) {
  //創(chuàng)建實(shí)例
  instanceWrapper = createBeanInstance(beanName, mbd, args);
 }
 final 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 {

   // Bean實(shí)例化完成后收集類中的注解（@PostConstruct，@PreDestroy，@Resource， @Autowired，@Value）
   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.
 // 單例bean提前暴露
 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");
  }
  //這里著重理解，對(duì)理解循環(huán)依賴幫助非常大，重要程度 5  添加三級(jí)緩存
  addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
 }

 // Initialize the bean instance.
 Object exposedObject = bean;
 try {
  //ioc di，依賴注入的核心方法，該方法必須看
  populateBean(beanName, mbd, instanceWrapper);

  //bean 實(shí)例化+ioc依賴注入完以后的調(diào)用，非常重要
  exposedObject = initializeBean(beanName, exposedObject, mbd);
 }
 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);
  }
 }

 if (earlySingletonExposure) {
  Object earlySingletonReference = getSingleton(beanName, false);
  if (earlySingletonReference != null) {
  if (exposedObject == bean) {
   exposedObject = earlySingletonReference;
  }
  else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
   String[] dependentBeans = getDependentBeans(beanName);
   Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
   for (String dependentBean : dependentBeans) {
   if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
    actualDependentBeans.add(dependentBean);
   }
   }
   if (!actualDependentBeans.isEmpty()) {
   throw new BeanCurrentlyInCreationException(beanName,
    "Bean with name '" + beanName + "' has been injected into other beans [" +
    StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
    "] in its raw version as part of a circular reference, but has eventually been " +
    "wrapped. This means that said other beans do not use the final version of the " +
    "bean. This is often the result of over-eager type matching - consider using " +
    "'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
   }
  }
  }
 }

 // Register bean as disposable.
 try {
  //注冊(cè)bean銷毀時(shí)的類DisposableBeanAdapter
  registerDisposableBeanIfNecessary(beanName, bean, mbd);
 }
 catch (BeanDefinitionValidationException ex) {
  throw new BeanCreationException(
   mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
 }

 return exposedObject;
 }

 protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
 Assert.notNull(singletonFactory, "Singleton factory must not be null");
 synchronized (this.singletonObjects) {
  // 一級(jí)緩存
  if (!this.singletonObjects.containsKey(beanName)) {
  System.out.println("========set value to 3 level cache->beanName->" + beanName + "->value->" + singletonFactory);
  // 三級(jí)緩存
  this.singletonFactories.put(beanName, singletonFactory);
  // 二級(jí)緩存
  this.earlySingletonObjects.remove(beanName);
  this.registeredSingletons.add(beanName);
  }
 }
 }

 //從緩存中拿實(shí)例
 Object sharedInstance = getSingleton(beanName);

 protected Object getSingleton(String beanName, boolean allowEarlyReference) {
 //根據(jù)beanName從緩存中拿實(shí)例
 //先從一級(jí)緩存拿
 Object singletonObject = this.singletonObjects.get(beanName);
 //如果bean還正在創(chuàng)建，還沒創(chuàng)建完成，其實(shí)就是堆內(nèi)存有了，屬性還沒有DI依賴注入
 if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
  synchronized (this.singletonObjects) {
  //從二級(jí)緩存中拿
  singletonObject = this.earlySingletonObjects.get(beanName);

  //如果還拿不到，并且允許bean提前暴露
  if (singletonObject == null && allowEarlyReference) {
   //從三級(jí)緩存中拿到對(duì)象工廠
   ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
   if (singletonFactory != null) {
   //從工廠中拿到對(duì)象
   singletonObject = singletonFactory.getObject();
   //升級(jí)到二級(jí)緩存
   System.out.println("======get instance from 3 level cache->beanName->" + beanName + "->value->" + singletonObject );
   this.earlySingletonObjects.put(beanName, singletonObject);
   //刪除三級(jí)緩存
   this.singletonFactories.remove(beanName);
   }
  }
  }
 }
 return singletonObject;
 }

 protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
 Object exposedObject = bean;
 if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
  for (BeanPostProcessor bp : getBeanPostProcessors()) {
  if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
   SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
   exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
  }
  }
 }
 return exposedObject;
 }

if (mbd.isSingleton()) {
 sharedInstance = getSingleton(beanName, () -> {
 try {
  return createBean(beanName, mbd, args);
 }
 catch (BeansException ex) {
  // Explicitly remove instance from singleton cache: It might have been put there
  // eagerly by the creation process, to allow for circular reference resolution.
  // Also remove any beans that received a temporary reference to the bean.
  destroySingleton(beanName);
  throw ex;
 }
 });
 // 該方法是FactoryBean接口的調(diào)用入口
 bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
else if (mbd.isPrototype()) {
 // It's a prototype -> create a new instance.
 Object prototypeInstance = null;
 try {
 beforePrototypeCreation(beanName);
 prototypeInstance = createBean(beanName, mbd, args);
 }
 finally {
 afterPrototypeCreation(beanName);
 }
 // 該方法是FactoryBean接口的調(diào)用入口
 bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
else {
 String scopeName = mbd.getScope();
 final Scope scope = this.scopes.get(scopeName);
 if (scope == null) {
 throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
 }
 try {
 Object scopedInstance = scope.get(beanName, () -> {
  beforePrototypeCreation(beanName);
  try {
  return createBean(beanName, mbd, args);
  }
  finally {
  afterPrototypeCreation(beanName);
  }
 });
 // 該方法是FactoryBean接口的調(diào)用入口
 bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
 }
}

 public AnnotationConfigApplicationContext(String... basePackages) {
 this();
 scan(basePackages);
 refresh();
 }

 public AnnotationConfigApplicationContext() {
 this.reader = new AnnotatedBeanDefinitionReader(this);
 this.scanner = new ClassPathBeanDefinitionScanner(this);
 }

 public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment) {
 Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
 Assert.notNull(environment, "Environment must not be null");
 this.registry = registry;
 this.conditionEvaluator = new ConditionEvaluator(registry, environment, null);
 AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
 }

 public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
  BeanDefinitionRegistry registry, @Nullable Object source) {

 DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
 if (beanFactory != null) {
  if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
  beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
  }
  if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
  beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
  }
 }

 Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);

 if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
  RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
  def.setSource(source);
  beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
 }

 if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
  RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
  def.setSource(source);
  beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
 }

 // Check for JSR-250 support, and if present add the CommonAnnotationBeanPostProcessor.
 if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
  RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
  def.setSource(source);
  beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
 }

 // Check for JPA support, and if present add the PersistenceAnnotationBeanPostProcessor.
 if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) {
  RootBeanDefinition def = new RootBeanDefinition();
  try {
  def.setBeanClass(ClassUtils.forName(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME,
   AnnotationConfigUtils.class.getClassLoader()));
  }
  catch (ClassNotFoundException ex) {
  throw new IllegalStateException(
   "Cannot load optional framework class: " + PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, ex);
  }
  def.setSource(source);
  beanDefs.add(registerPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME));
 }

 if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {
  RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);
  def.setSource(source);
  beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));
 }

 if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {
  RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);
  def.setSource(source);
  beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));
 }

 return beanDefs;
 }