spring源码分析：bean的初始化

我们通过spring容器帮我们实例化并且维护bean的时候，有时候我们需要在bean在实例化完成的时候，帮我们做一些事情，这个时候我们就会使用到bean的初始化方法。举个例子，比如我们创建一个电脑，那么我们肯定就需要先安装系统，不然不能使用，此时我们就能把安装系统的过程封装到初始化方法中。我们今天主要来看我们常见的三种初始化的方法，并且分析一下他们的源码。

我们这里分析的三个初始化方法如下，如果已经比较了解如何使用以及原理，可以跳过该文章

1.实现InitializingBean接口

2.使用@PostConstruct

3.使用@Bean(initMethod = “xxx”)

这篇文章相对来说比较简单，但是还是希望大家对spring中的beanPostProcessor和bean创建的过程有了解。如果你不了解也没关系，相信这篇文章还是能给你带来收获

一.使用方式

使用方式就超级简单，下面简单的贴下代码

public class Computer implements InitializingBean {
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("调用afterPropertiesSet 完成初始化...安装系统");
    }


    @PostConstruct
    public void initByPostConstruct(){
        System.out.println("调用initByPostConstruct 完成初始化...安装系统");
    }


    public void init(){
        System.out.println("调用init 完成初始化...安装系统");
    }
}

另外，还有在config类里面通过@Bean实例化bean

@Configuration
@EnableAspectJAutoProxy
public class MainConfig {

    @Bean(initMethod = "init")
    public Computer computer(){
        return new Computer();
    }
}

上面同时使用了三种方式，正常情况下选择一种方式使用即可，我们看下执行打印的结果，顺便看下这三个是哪个先执行呢？

使用就到这里结束了，非常简单

二.源码分析

现在我们来分析他们三个实现的原理，第一可以更加深入的理解源码，第二万一面试被问到也不虚。这里就不再介绍bean创建的全过程了，如果感兴趣的可以参考我这篇文章（spring源码分析之如何解决循环依赖），这篇文章写的比较详细，我们直接从bean创建后，开始初始化的地方开始介绍

//AbstractAutowireCapableBeanFactory.java

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

   //....省略代码
   try {
       //属性赋值
      populateBean(beanName, mbd, instanceWrapper);
       //实现初始化的逻辑入口在这里
      exposedObject = initializeBean(beanName, exposedObject, mbd);
   }
   //省略代码
   
   return exposedObject;
}

上面直接从AbstractAutowireCapableBeanFactory.java开始分析，注释写的比较清楚，我们直接看initializeBean()

protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
   if (System.getSecurityManager() != null) {
      AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
         invokeAwareMethods(beanName, bean);
         return null;
      }, getAccessControlContext());
   }
   else {
      invokeAwareMethods(beanName, bean);
   }

   Object wrappedBean = bean;
    //1.这里实现了@PostConstruct原理
   if (mbd == null || !mbd.isSynthetic()) {
      wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
   }

   try {
       //2.这里调用初始化方法，这里实现了InitializingBean和@Bean(initMethod="xx")的原理
      invokeInitMethods(beanName, wrappedBean, mbd);
   }
   catch (Throwable ex) {
      throw new BeanCreationException(
            (mbd != null ? mbd.getResourceDescription() : null),
            beanName, "Invocation of init method failed", ex);
   }
   if (mbd == null || !mbd.isSynthetic()) {
      wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
   }

   return wrappedBean;
}

我们先来看注释2的invokeInitMethods，看看他是如何实现初始化方法的

protected void invokeInitMethods(String beanName, final Object bean, @Nullable RootBeanDefinition mbd)
      throws Throwable {

    //1.实现InitializingBean原理
   boolean isInitializingBean = (bean instanceof InitializingBean);
   if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
      if (logger.isTraceEnabled()) {
         logger.trace("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
      }
      if (System.getSecurityManager() != null) {
         try {
            AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {
                //1-1
               ((InitializingBean) bean).afterPropertiesSet();
               return null;
            }, getAccessControlContext());
         }
         catch (PrivilegedActionException pae) {
            throw pae.getException();
         }
      }
      else {
          //1-2
         ((InitializingBean) bean).afterPropertiesSet();
      }
   }
	//2.实现了@Bean(initMethod="xx")的原理
   if (mbd != null && bean.getClass() != NullBean.class) {
       //2-1这里会读取到initMethod方法，然后下面通过反射调用
      String initMethodName = mbd.getInitMethodName();
      if (StringUtils.hasLength(initMethodName) &&
            !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
            !mbd.isExternallyManagedInitMethod(initMethodName)) {
          //具体的调用过程看这里，不做过多的解释
         invokeCustomInitMethod(beanName, bean, mbd);
      }
   }
}

注释1通过实现InitializingBean方式来实现初始化的非常的简单，不做过多的介绍，注释2通过@Bean的方式稍微介绍一下。

当我们通过@Bean方式还是之前通过xml配置bean时都能够指定initMethod属性，此时就会将这个bean先封装成BeanDefinition，同时配置的属性也会设置到BeanDefinition中，所以在这里我们是可以取出initMethod属性对应的方法，拿到之后然后实例耶创建出来了，自然就能通过反射调用。bean创建的过程都是先封装成beanDefinition，如果这一块不了解的可以先阅读相关文章

上面我们已经知道InitializingBean和@Bean(initMethod=“xx”)来实现初始化方法的原理，下面我们来看注释1通过@PostConstruct，直接对应下面方法

public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
      throws BeansException {

   Object result = existingBean;
   for (BeanPostProcessor processor : getBeanPostProcessors()) {
       //beanPostProcessor调用方法
      Object current = processor.postProcessBeforeInitialization(result, beanName);
      if (current == null) {
         return result;
      }
      result = current;
   }
   return result;
}

这其实就是beanPostProcessor，我们知道在spring中使用了大量的beanPostProcessor（我们自己也可以实现），通过它达到在spring创建过程中拦截的作用，在某个动作之前/之后做一些感兴趣的事情，达到“增强”的目的

这里其实就是用到了一个InitDestroyAnnotationBeanPostProcessor来实现初始化和销毁的过程，一定会执行postProcessBeforeInitialization

public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
    //找到要执行的方法
   LifecycleMetadata metadata = findLifecycleMetadata(bean.getClass());
   try {
       //反射调用
      metadata.invokeInitMethods(bean, beanName);
   }
   catch (InvocationTargetException ex) {
      throw new BeanCreationException(beanName, "Invocation of init method failed", ex.getTargetException());
   }
   catch (Throwable ex) {
      throw new BeanCreationException(beanName, "Failed to invoke init method", ex);
   }
   return bean;
}

这里找到@PostConstruct的方法也很简单，无非就是获取方法的注释，并且判断是否是@PostConstruct，如果是则就算找到了，具体的细节感兴趣的可以自行阅读。

总的来说这篇文章还是比较简单，其实相对应的销毁方法也是一样的，感兴趣的可以自行阅读