Spring IOC源码解析

getBean()

ApplicationContext ac = new FileSystemXmlApplicationContext("classpath:spring.xml");
User user =	(User) ac.getBean("user");

ApplicationContext是接口，实现的方法是AbstractApplicationContext的getBean()

@Override
public Object getBean(String name) throws BeansException {
   assertBeanFactoryActive();  //判断AtomicBoolean类型的 active是否为true来确认ioc容器是否启动着
   return getBeanFactory().getBean(name);  //spring中真正做事的是do开头的方法。
}

接着我们去看getBeanFactory().getBean(name); 调用的是AbstractBeanFactory的getBean

public Object getBean(String name) throws BeansException {
   return doGetBean(name, null, null, false);
}

doGetBean()

真正做事的是doGetBean()方法 AbstractBeanFactory 这里详讲doGetBean()方法 （标题代表方法的位置）

transformedBeanName()

final String beanName = transformedBeanName(name);

protected String transformedBeanName(String name) {
   return canonicalName(BeanFactoryUtils.transformedBeanName(name));
}

BeanFactoryUtils.transformedBeanName()

进入transformedBeanName()方法，判断name是否是以"&"开头的

若不是以"&"开头的直接不做解析，直接返回bean的name。

若是以"&’'开头的name，会从解析过的transformedBeanNameCache中获取

如果获取到直接返回

如果缓存中没有则将开头的所有"&’'去掉，再存入map中（transformedBeanNameCache是一个ConcurrentHashMap对象），如图所示从"&&user"解析后是"user"。

public static String transformedBeanName(String name) {
   Assert.notNull(name, "'name' must not be null");
   if (!name.startsWith(BeanFactory.FACTORY_BEAN_PREFIX)) { 
      return name;
   }
   return transformedBeanNameCache.computeIfAbsent(name, beanName -> {
      do {
         beanName = beanName.substring(BeanFactory.FACTORY_BEAN_PREFIX.length());
      }
      while (beanName.startsWith(BeanFactory.FACTORY_BEAN_PREFIX));
      return beanName;
   });
}

canonicalName()

去掉"&"号后的name去aliasMap中查找是否有别名，如果有别名则返回别名。

public String canonicalName(String name) {
   String canonicalName = name;
   // Handle aliasing...
   String resolvedName;
   do {
      resolvedName = this.aliasMap.get(canonicalName);
      if (resolvedName != null) {
         canonicalName = resolvedName;
      }
   }
   while (resolvedName != null);
   return canonicalName;
}

Object bean; //定义返回对象bean

Object sharedInstance = getSingleton(beanName)

getSingleton()

• 进入getSingleton()方法内部

  public Object getSingleton(String beanName) {
     // 参数true 标识，允许获取早期的依赖
     return getSingleton(beanName, true);
  }
  

  再进入内部 重点 如何解决单例间的循环依赖

  protected Object getSingleton(String beanName, boolean allowEarlyReference) {
      //首先尝试用一级缓存中获取:
      //如果获取到了则直接返回。
      //如果没有获取到则判断该bean是否处于在创建的状态，如果不处于在创建的状态，则这个bean还没被加载过。
     Object singletonObject = this.singletonObjects.get(beanName);
     if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
         //进入这个if代表这个bean正在创建中，需要对这个对象加锁，防止其他线程进来创建。
        synchronized (this.singletonObjects) {
           //earlySingletonObjects代表二级缓存，也是一个cmap。
           //里面存放是未加载完的bean
           singletonObject = this.earlySingletonObjects.get(beanName);
           //如果二级缓存中也没有 并且运行提前曝光
           if (singletonObject == null && allowEarlyReference) {
              //当某些方法需要提前初始化的时候则会调用addSingletonFactory方法对应的ObjectFactory初始化策略并存储在singletonFactories中。
              ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
              if (singletonFactory != null) {
                  //从三级缓存中获取;
                 singletonObject = singletonFactory.getObject();
                  //将获取中的bean放入二级缓存，再移出三级缓存。  
                 this.earlySingletonObjects.put(beanName, singletonObject);
                 this.singletonFactories.remove(beanName);
              }
           }
        }
     }
     return singletonObject;
  }
  

这边由于设置得是懒加载，所以只有在第一次执行getBean()的方法中获取的sharedInstance为null。如果没有设置懒加载的话在，FileSystemXmlApplicationContext(“spring.xml”)执行的过程中会将xml中定义的bean都解析完。

实例化bean的代码段

//如果从缓存中有获取到对象，args代表使用显式参数创建bean实例时使用的参数，前面的doGetBean()传入的是null;
if (sharedInstance != null && args == null) {
   if (logger.isTraceEnabled()) {
       //如果还在处于在创建的状态给出日志提示
      if (isSingletonCurrentlyInCreation(beanName)) {
         logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
               "' that is not fully initialized yet - a consequence of a circular reference");
      }
      else {
         logger.trace("Returning cached instance of singleton beanDefinitionMap '" + beanName + "'");
      }
   }
   //实例化bean 
   bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
else {
    //这边没有从缓存中获取到对象 
    //如果这bean是原型并且处于正在创建的状态 说明产生了循环依赖 spring不提供原型bean的循环依赖解决方案
   if (isPrototypeCurrentlyInCreation(beanName)) {
      throw new BeanCurrentlyInCreationException(beanName);
   }
    
    //如果在beanDefinitionMap中没有这个bean的定义，但这个bean有父工厂时，就递归交给父工厂继续处理
   BeanFactory parentBeanFactory = getParentBeanFactory();
   if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
       //解析回原来的beanName
      String nameToLookup = originalBeanName(name);
      if (parentBeanFactory instanceof AbstractBeanFactory) {
          // 递归到BeanFactory中寻找
         return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
               nameToLookup, requiredType, args, typeCheckOnly);
      }
      else if (args != null) {
          // 委派父级容器 根据指定名称和显式的参数查找
         return (T) parentBeanFactory.getBean(nameToLookup, args);
      }
      else if (requiredType != null) {
          // 委派父级容器 根据指定名称和类型查找
         return parentBeanFactory.getBean(nameToLookup, requiredType);
      }
      else {
          // 委派父级容器根据指定名称查找
         return (T) parentBeanFactory.getBean(nameToLookup);
      }
   }
    //对创建的bean进行类型验证
   if (!typeCheckOnly) {
      markBeanAsCreated(beanName);
   }

   try {
       //尝试着从合并的BeanDefinition中获取 如果没有获取到则从beanDefinitionMap里获取然后跟上面一样clone出mdb
      final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
       //进行校验bean不是abstract，如果是abstract则抛出异常
      checkMergedBeanDefinition(mbd, beanName, args);
       //去获取该bean所依赖的beanName
      String[] dependsOn = mbd.getDependsOn();
      if (dependsOn != null) {
         for (String dep : dependsOn) {
            if (isDependent(beanName, dep)) {
               throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                     "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
            }
             //往两个map里填充 一个是该bean依赖的 一个是依赖该bean的
            registerDependentBean(dep, beanName);
            try {
                //去加载bean
               getBean(dep);
            }
            catch (NoSuchBeanDefinitionException ex) {
               throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                     "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
            }
         }
      }
       //如果是单例的bean
      if (mbd.isSingleton()) {
         sharedInstance = getSingleton(beanName, () -> {
            try {
               //去创建bean
               return createBean(beanName, mbd, args);
            }
            catch (BeansException ex) {
               destroySingleton(beanName);
               throw ex;
            }
         });
         bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
      }
      else if (mbd.isPrototype()) {
         Object prototypeInstance = null;
         try {
            beforePrototypeCreation(beanName);
            prototypeInstance = createBean(beanName, mbd, args);
         }
         finally {
            afterPrototypeCreation(beanName);
         }
         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);
               }
            });
            bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
         }
         catch (IllegalStateException ex) {
            throw new BeanCreationException(beanName,
                  "Scope '" + scopeName + "' is not active for the current thread; consider " +
                  "defining a scoped proxy for this bean if you intend to refer to it from a singleton",
                  ex);
         }
      }
   }
   catch (BeansException ex) {
      cleanupAfterBeanCreationFailure(beanName);
      throw ex;
   }
}

getObjectForBeanInstance()

protected Object getObjectForBeanInstance(
      Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {
    //beanInstance是已经获取到的对象，现在需要根据name来判断 如果name是以&开头的 则beanInstance应该是一个工厂。
    //判断name是否以&为前缀，FactoryBean的解引用
    //Dereference(解引用)： 一个在C/C++中应用的比较多术语，在C++中，“*”是解引用符号，“&”是引用符号。
    //解引用：变量所指向的是所引用对象的本身数据，而不是对象的内存地址。
   if (BeanFactoryUtils.isFactoryDereference(name)) {
      if (beanInstance instanceof NullBean) {
         return beanInstance;
      }
       //如果不是工厂类型，无法调用getObject()获得实例，所以这边直接抛出异常
      if (!(beanInstance instanceof FactoryBean)) {
         throw new BeanIsNotAFactoryException(beanName, beanInstance.getClass());
      }
   }
   
    //但是如果用户想要直接获取工厂实例而不是工厂的getObject方法对应的实例，那么传入的name应该加入前缀&
   if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
      return beanInstance;
   }

   Object object = null;
   if (mbd == null) {
       //从factoryBeanObjectCache中取获取这个bean。
       //由factory创建的bean都会被加入这个缓存中。
       //在上个方法中mbd传入为null mbd就是RootBeanDefinition 解析xml后的对象定义信息会存储在这里面 比如一些是否是单例 解析的类信息等等
      object = getCachedObjectForFactoryBean(beanName);
   }
    //如果factory没有创建过该bean
   if (object == null) {
       //在上面都做完判断 不是factory的话要么直接return 要么报异常，所以在这边可以确定该实例的类型为FactoryBean
      FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
       //从beanDefinitionMap中取查找关于这个bean的定义。
       //beanDefinitionMap是一个cmap。key为beanName，val为beanDefinition。在解析文件的时候会包装成beanDefinition对象存入
      if (mbd == null && containsBeanDefinition(beanName)) {
          //通过beanName合并对象。就是通过clone去复制一个mbd给这边用，防止修改原生的bean定义。
         mbd = getMergedLocalBeanDefinition(beanName);
      }
       //如果从容器得到Bean定义信息，判断该bean是不是合成的
      boolean synthetic = (mbd != null && mbd.isSynthetic());
       //调用FactoryBeanRegistrySupport类的getObjectFromFactoryBean方法，实现工厂Bean生产Bean对象实例的过程
      object = getObjectFromFactoryBean(factory, beanName, !synthetic);
   }
   return object;
}

getObjectFromFactoryBean()

protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
    //执行到这个方法 可以确认的是要获取的bean是在工厂里的bean
    //如果这个工厂创建的对象是单例的 这边再确保一级缓存中还存在这个对象
   if (factory.isSingleton() && containsSingleton(beanName)) {
       //对一级缓存加锁
      synchronized (getSingletonMutex()) {
          //再次尝试用factory创建的Cache中去获取这个对象
          //这里可能是因为有可能另外一个线程执行到由工厂创建完bean并存入缓存，但还没来的及存入IOC的一级缓存中
         Object object = this.factoryBeanObjectCache.get(beanName);
         if (object == null) {
             //这里去调用工厂的getObject()获取实例
            object = doGetObjectFromFactoryBean(factory, beanName);
             //再一次去factory中的Cache中去获取对象 
             //有可能当执行doGetObjectFromFactoryBean函数时，Bean正在创建，所以此时再获取一下
            Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
            if (alreadyThere != null) {
               object = alreadyThere;
            }
            else {
                //如果是自己定义创建的bean 则不需要后置处理
                //如果是系统创建的bean shouldPostProcess=true
               if (shouldPostProcess) {
                  if (isSingletonCurrentlyInCreation(beanName)) {
                     return object;
                  }
                  beforeSingletonCreation(beanName);
                  try {
                      //子类可以调用去重写后置处理器
                     object = postProcessObjectFromFactoryBean(object, beanName);
                  }
                  catch (Throwable ex) {
                     throw new BeanCreationException(beanName,
                           "Post-processing of FactoryBean's singleton object failed", ex);
                  }
                  finally {
                      //创建完的后置处理 在正在创建该bean的容器中移除
                     afterSingletonCreation(beanName);
                  }
               }
               if (containsSingleton(beanName)) {
                  this.factoryBeanObjectCache.put(beanName, object);
               }
            }
         }
         return object;
      }
   }
   else {
      Object object = doGetObjectFromFactoryBean(factory, beanName);
      if (shouldPostProcess) {
         try {
            object = postProcessObjectFromFactoryBean(object, beanName);
         }
         catch (Throwable ex) {
            throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex);
         }
      }
      return object;
   }
}

doGetObjectFromFactoryBean()

private Object doGetObjectFromFactoryBean(final FactoryBean<?> factory, final String beanName)
      throws BeanCreationException {

    //这个方法主要是调用个Factory.getObject();
   Object object;
   try {
       /*
       这是JAVA安全管理器SecurityManager当运行未知的Java程序的时候，该程序可能有恶意代码（删除系统文件、重启系统等），为了防		止运行恶意代码对系统产生影响，需要对运行的代码的权限进行控制，这时候就要启用Java安全管理器。
       */
      if (System.getSecurityManager() != null) {
         AccessControlContext acc = getAccessControlContext();
         try {
            object = AccessController.doPrivileged((PrivilegedExceptionAction<Object>) factory::getObject, acc);
         }
         catch (PrivilegedActionException pae) {
            throw pae.getException();
         }
      }
      else {
         object = factory.getObject();
      }
   }
   catch (FactoryBeanNotInitializedException ex) {
      throw new BeanCurrentlyInCreationException(beanName, ex.toString());
   }
   catch (Throwable ex) {
      throw new BeanCreationException(beanName, "FactoryBean threw exception on object creation", ex);
   }

   if (object == null) {
      if (isSingletonCurrentlyInCreation(beanName)) {
         throw new BeanCurrentlyInCreationException(
               beanName, "FactoryBean which is currently in creation returned null from getObject");
      }
      object = new NullBean();
   }
   return object;
}

createBean()

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

   if (logger.isTraceEnabled()) {
      logger.trace("Creating instance of bean '" + beanName + "'");
   }
   RootBeanDefinition mbdToUse = mbd;
    
    //解析出对应的class对象
   Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
   if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
      mbdToUse = new RootBeanDefinition(mbd);
      mbdToUse.setBeanClass(resolvedClass);
   }
    
	// 验证及准备覆盖的方法
   try {
      mbdToUse.prepareMethodOverrides();
   }
   catch (BeanDefinitionValidationException ex) {
      throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
            beanName, "Validation of method overrides failed", ex);
   }

   try {
       //应用实例化前的后处理程序，解析指定bean是否有实例化前的快捷方式。
      Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
       // 如果这里bean已经被处理了，则直接返回。不进行下面的处理，短路操作
      if (bean != null) {
         return bean;
      }
   }
   catch (Throwable ex) {
      throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
            "BeanPostProcessor before instantiation of bean failed", ex);
   }

   try {
       //doCreateBean将会返回Bean对象的实例
      Object beanInstance = doCreateBean(beanName, mbdToUse, args);
      if (logger.isTraceEnabled()) {
         logger.trace("Finished creating instance of bean '" + beanName + "'");
      }
      return beanInstance;
   }
   catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
      throw ex;
   }
   catch (Throwable ex) {
      throw new BeanCreationException(
            mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
   }
}

resolveBeanClass()

@Nullable
protected Class<?> resolveBeanClass(final RootBeanDefinition mbd, String beanName, final Class<?>... typesToMatch)
      throws CannotLoadBeanClassException {

   try {
       //如果mbd指定了bean类则直接返回
      if (mbd.hasBeanClass()) {
         return mbd.getBeanClass();
      }
      if (System.getSecurityManager() != null) {
         return AccessController.doPrivileged((PrivilegedExceptionAction<Class<?>>) () ->
            doResolveBeanClass(mbd, typesToMatch), getAccessControlContext());
      }
      else {
         return doResolveBeanClass(mbd, typesToMatch);
      }
   }
   catch (PrivilegedActionException pae) {
      ClassNotFoundException ex = (ClassNotFoundException) pae.getException();
      throw new CannotLoadBeanClassException(mbd.getResourceDescription(), beanName, mbd.getBeanClassName(), ex);
   }
   catch (ClassNotFoundException ex) {
      throw new CannotLoadBeanClassException(mbd.getResourceDescription(), beanName, mbd.getBeanClassName(), ex);
   }
   catch (LinkageError err) {
      throw new CannotLoadBeanClassException(mbd.getResourceDescription(), beanName, mbd.getBeanClassName(), err);
   }
}

doResolveBeanClass()

@Nullable
private Class<?> doResolveBeanClass(RootBeanDefinition mbd, Class<?>... typesToMatch)
      throws ClassNotFoundException {

    //获取该工厂的类加载器
   ClassLoader beanClassLoader = getBeanClassLoader();
    //作为临时类加载器
   ClassLoader dynamicLoader = beanClassLoader;
   boolean freshResolve = false;

   if (!ObjectUtils.isEmpty(typesToMatch)) {
       //获取一个临时类加载器用来解析
      ClassLoader tempClassLoader = getTempClassLoader();
      if (tempClassLoader != null) {
         dynamicLoader = tempClassLoader;
         freshResolve = true;
         if (tempClassLoader instanceof DecoratingClassLoader) {
             //如果tempClassLoader属于DecoratingClassLoader实例,会对tempClassLoader进行强转为DecoratingClassLoader 【变量 dcl】，然后对typeToMatch在dcl中的排除，使其交由其父classLoader【默认情况下父classLoader是线程上下文类加载器】 进行常规方式处理
            DecoratingClassLoader dcl = (DecoratingClassLoader) tempClassLoader;
            for (Class<?> typeToMatch : typesToMatch) {
               dcl.excludeClass(typeToMatch.getName());
            }
         }
      }
   }

    //尝试去获取类名
   String className = mbd.getBeanClassName();
   if (className != null) {
       //如果className是可解析表达式，会对其进行解析，否则直接返回className:
      Object evaluated = evaluateBeanDefinitionString(className, mbd);
       //如果解析后的对象跟原来的不一致
      if (!className.equals(evaluated)) {
          //如果evaluated对象是类则直接返回解析后的类
         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);
         }
      }
      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);
               }
            }
         }
        //使用classLoader加载name对应的Class对象,该方式是Spring用于代替Class.forName()的方法，支持返回原始的类实例(如'int')
		// 和数组类名 (如'String[]')。此外，它还能够以Java source样式解析内部类名(如:'java.lang.Thread.State')
		// 而不是'java.lang.Thread$State')
         return ClassUtils.forName(className, dynamicLoader);
      }
   }

   // 定期解析，将结果缓存到BeanDefinition中
   return mbd.resolveBeanClass(beanClassLoader);
}

resolveBeforeInstantiation()

@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.
      // 如果还没被解析则进来解析
      /*
         isSynthetic默认为false 代表用户创建的程序
         hasInstantiationAwareBeanPostProcessors判断是否有后置处理器
       */
      if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
         Class<?> targetType = determineTargetType(beanName, mbd);
         if (targetType != null) {
            // [实例化前 的后处理器应用] 应用所有getBeanPostProcessors的  postProcessBeforeInstantiation
            bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
            if (bean != null) {
               // [实例化后 的后处理器应用] 后置处理器  after
               bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
            }
         }
      }
      mbd.beforeInstantiationResolved = (bean != null);
   }
   return bean;
}

doCreateBean()

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
      throws BeanCreationException {
   BeanWrapper instanceWrapper = null;
   if (mbd.isSingleton()) {
      instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
   }
   //如果缓存中没有该bean  也就是该bean还没被加载过
   if (instanceWrapper == null) {
      //用来创建bean实例 （这个时候执行bean的构造方法）;
      // 这步执行，就完成了bean的实例化操作
      // 根据指定bean 使用对应的策略创建新的实例， 如· 工厂方法、构造函数自动注入、简单初始化
      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.
   // 允许后处理程序修改合并后的bean定义。
   synchronized (mbd.postProcessingLock) {
      if (!mbd.postProcessed) {
         try {
            // 将MergedBeanDefinitionPostProcessors应用到指定的bean定义，
            // 调用它们的postProcessMergedBeanDefinition方法
            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.
   // 快速缓存单例 以便能够解决循环引用
   // 即使被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");
      }
      //上面完成bean的实例化（初始化之前）， 向三级缓存中放入一个实例化对象（匿名处理类）
      //aop就是在这里动态的将advice织入bean中
      addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
   }

   /*
      初始化bean实例
      下面调用populateBean方法，对bean进行填充，注入相关依赖
    */
   // 【初始化bean】 Initialize the bean instance.
   Object exposedObject = bean;
   try {
      // 【填充】
      // 填充Bean，该方法就是 发生依赖注入的地方
      populateBean(beanName, mbd, instanceWrapper);
      // 再调用方法initializeBean（如init-method），进行相关初始化工作
      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 {
      registerDisposableBeanIfNecessary(beanName, bean, mbd);
   }
   catch (BeanDefinitionValidationException ex) {
      throw new BeanCreationException(
            mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
   }

   return exposedObject;
}

createBeanInstance()

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
   // Make sure bean class is actually resolved at this point.
   // 解析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());
   }

   Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
   if (instanceSupplier != null) {
      return obtainFromSupplier(instanceSupplier, beanName);
   }

   // 如果工厂方法不为空，则使用工厂方法初始化策略
   if (mbd.getFactoryMethodName() != null) {
      return instantiateUsingFactoryMethod(beanName, mbd, args);
   }

   // Shortcut when re-creating the same bean...
   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) {
         // 构造函数自动注入
         return autowireConstructor(beanName, mbd, null, null);
      }
      else {
         // 使用默认构造函数 构造
         return instantiateBean(beanName, mbd);
      }
   }

   // Candidate constructors for autowiring?
   // 需要根据参数解析构造函数
   Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
   if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
         mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
      //构造函数自动注入
      return autowireConstructor(beanName, mbd, ctors, args);
   }

   // Preferred constructors for default construction?
   ctors = mbd.getPreferredConstructors();
   if (ctors != null) {
      return autowireConstructor(beanName, mbd, ctors, null);
   }

   // No special handling: simply use no-arg constructor.
   // 无需特殊处理:只需使用无参数的构造函数。
   return instantiateBean(beanName, mbd);
}

类型转换代码段

//9. 类型转换、将返回的bean的类型进行检查 可以是将返回的bean 转换为requiredType 所指定的类型 对创建的Bean实例对象进行类型检查，是否符合实际类型
if (requiredType != null && !requiredType.isInstance(bean)) {
   try {
      T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
      if (convertedBean == null) {
         throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
      }
      return convertedBean;
   }
   catch (TypeMismatchException ex) {
      if (logger.isTraceEnabled()) {
         logger.trace("Failed to convert bean '" + name + "' to required type '" +
               ClassUtils.getQualifiedName(requiredType) + "'", ex);
      }
      throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
   }
}
return (T) bean;