上一篇分析了单实例bean创建过程中的属性赋值，接下来我们分析，单实例bean属性赋值之后的初始化**initializeBean()**。

1. initializeBean()

  1.     protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
  2.         /*检查当前bean是否实现了aware接口，再具体判断实现的哪个aware接口，做一些赋能操作。*/
  3.         invokeAwareMethods(beanName, bean);
  5.         Object wrappedBean = bean;
  6.         if (mbd == null || !mbd.isSynthetic()) {
  7.             /*初始化之前，后置处理器的调用点*/
  8.             wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
  9.         }
  11.         try {
  12.             /*执行初始化方法*/
  13.             invokeInitMethods(beanName, wrappedBean, mbd);
  14.         }
  15.         catch (Throwable ex) {
  16.             throw new BeanCreationException(
  17.                     (mbd != null ? mbd.getResourceDescription() : null),
  18.                     beanName, "Invocation of init method failed", ex);
  19.         }
  20.         if (mbd == null || !mbd.isSynthetic()) {
  21.             /*初始化后的后置处理器执行点*/
  22.             /*典型应用：AOP的具体实现*/
  23.             wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
  24.         }
  26.         return wrappedBean;
  27.     }

在初始化之前，把当前bean实现的所有Aware接口都执行一遍。**invokeAwareMethods()**
在初始化之前，调用后置处理器。**applyBeanPostProcessorsBeforeInitialization()**
执行初始化逻辑。**invokeInitMethods()**
执行后置处理器的调用点，典型的实现其实就是AOP。**applyBeanPostProcessorsAfterInitialization()**
返回包装对象。

2.invokeAwareMethods()

  1.     private void invokeAwareMethods(String beanName, Object bean) {
  2.         if (bean instanceof Aware) {
  3.             if (bean instanceof BeanNameAware) {
  4.                 ((BeanNameAware) bean).setBeanName(beanName);
  5.             }
  6.             if (bean instanceof BeanClassLoaderAware) {
  7.                 ClassLoader bcl = getBeanClassLoader();
  8.                 if (bcl != null) {
  9.                     ((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
  10.                 }
  11.             }
  12.             if (bean instanceof BeanFactoryAware) {
  13.                 ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
  14.             }
  15.         }
  16.     }

执行相关的Aware接口方法。

3.applyBeanPostProcessorsBeforeInitialization()

  1.     @Override
  2.     public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
  3.             throws BeansException {
  5.         Object result = existingBean;
  6.         /*beanPostProcessor的执行逻辑*/
  7.         for (BeanPostProcessor processor : getBeanPostProcessors()) {
  8.             Object current = processor.postProcessBeforeInitialization(result, beanName);
  9.             if (current == null) {
  10.                 return result;
  11.             }
  12.             result = current;
  13.         }
  14.         return result;
  15.     }

循环所有的后置处理器，执行前置方法，如果有一个返回结果为空，直接短路，后面的都不执行了。

4.invokeInitMethods()

  1.     protected void invokeInitMethods(String beanName, Object bean, @Nullable RootBeanDefinition mbd)
  2.             throws Throwable {
  3.         /*如果是实现了InitializingBean接口*/
  4.         boolean isInitializingBean = (bean instanceof InitializingBean);
  5.         if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
  6.             if (logger.isTraceEnabled()) {
  7.                 logger.trace("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
  8.             }
  9.             /*执行afterPropertiesSet方法*/
  10.             ((InitializingBean) bean).afterPropertiesSet();
  11.         }
  13.         if (mbd != null && bean.getClass() != NullBean.class) {
  14.             /*判断重写init方法没？*/
  15.             String initMethodName = mbd.getInitMethodName();
  16.             if (StringUtils.hasLength(initMethodName) &&
  17.                     !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
  18.                     !mbd.isExternallyManagedInitMethod(initMethodName)) {
  19.                 /*执行重写的init方法*/
  20.                 invokeCustomInitMethod(beanName, bean, mbd);
  21.             }
  22.         }
  23.     }

判断实现了**InitializingBean**接口的，执行里面的方法。
判断重写了初始化方法的，执行重写的方法。

4.1 invokeCustomInitMethod()

  1.     protected void invokeCustomInitMethod(String beanName, Object bean, RootBeanDefinition mbd)
  2.             throws Throwable {
  3.         /*从bd获取init方法*/
  4.         String initMethodName = mbd.getInitMethodName();
  5.         Assert.state(initMethodName != null, "No init method set");
  6.         /*
  7.         * isNonPublicAccessAllowed 非公开访问
  8.         *
  9.         * 这里完成之后就会获取到通过init方法定义的方法对象。
  10.         * */
  11.         Method initMethod = (mbd.isNonPublicAccessAllowed() ?
  12.                 BeanUtils.findMethod(bean.getClass(), initMethodName) :
  13.                 ClassUtils.getMethodIfAvailable(bean.getClass(), initMethodName));
  14.         /*如果init方法为空*/
  15.         if (initMethod == null) {
  16.             if (mbd.isEnforceInitMethod()) {
  17.                 throw new BeanDefinitionValidationException("Could not find an init method named '" +
  18.                         initMethodName + "' on bean with name '" + beanName + "'");
  19.             }
  20.             else {
  21.                 if (logger.isTraceEnabled()) {
  22.                     logger.trace("No default init method named '" + initMethodName +
  23.                             "' found on bean with name '" + beanName + "'");
  24.                 }
  25.                 // Ignore non-existent default lifecycle methods.
  26.                 return;
  27.             }
  28.         }
  30.         if (logger.isTraceEnabled()) {
  31.             logger.trace("Invoking init method  '" + initMethodName + "' on bean with name '" + beanName + "'");
  32.         }
  33.         /*将init方法转换成接口层面获取的initMethod*/
  34.         Method methodToInvoke = ClassUtils.getInterfaceMethodIfPossible(initMethod);
  36.         try {
  37.             /*反射执行方法*/
  38.             ReflectionUtils.makeAccessible(methodToInvoke);
  39.             methodToInvoke.invoke(bean);
  40.         }
  41.         catch (InvocationTargetException ex) {
  42.             throw ex.getTargetException();
  43.         }
  44.     }

经过一些列处理，反射调用初始化方法。

5.applyBeanPostProcessorsAfterInitialization()

    @Override
    public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
            throws BeansException {

        Object result = existingBean;
        for (BeanPostProcessor processor : getBeanPostProcessors()) {
            Object current = processor.postProcessAfterInitialization(result, beanName);
            /*注意：
            * 一旦某个后置处理器返回的结果为空
            * 就返回上一个后置处理器的结果，后面的后置处理器方法不在执行*/
            if (current == null) {
                return result;
            }
            result = current;
        }
        return result;
    }

初始化之后，遍历所有的后置处理器，执行后置处理器的后置方法，如果有一个返回结果是空，直接返回，后面的后置处理器都不执行了。

至此，整个ioc容器的刷新流程就都分析完了，重点就在于单实例bean的创建流程，首先会去**getBean() doGetBean() getSinglton() createBean() doCreateBean() populateBean() initializeBean()**。下一篇我们将会去分析Spring的三级缓存和循环依赖。