Spring原理之Bean生命周期

 

Spring Bean的生命周期是指Bean从创建到销毁的整个过程，大致分为4个阶段：

• Bean的实例化阶段：Spring容器根据BeanDefinition信息，通过反射创建对象；
• Bean的初始化阶段：对Spring创建的Bean进行属性填充、Aware接口方法回调、执行Bean的后置处理器、执行初始化方法、AOP等
• Bean的完成阶段：将生成的Bean放到单例池（singletonObjects）中
• Bean的销毁阶段：Spring 容器关闭前，执行Bean的销毁方法。

 

Bean的实例化流程【加载Bean信息】

• 将Bean的信息封装成一个BeanDefinition对象

--org.springframework.beans.factory.support.BeanDefinitionReaderUtils#createBeanDefinition

public static AbstractBeanDefinition createBeanDefinition(
      String parentName, String className, ClassLoader classLoader) throws ClassNotFoundException {
   GenericBeanDefinition bd = new GenericBeanDefinition();
   bd.setParentName(parentName);
   if (className != null) {
      if (classLoader != null) {
         bd.setBeanClass(ClassUtils.forName(className, classLoader));
      }
      else {
         bd.setBeanClassName(className);
      }
   }
   return bd;
}

• 将所有的BeanDefinition存储到BeanDefinitionMap中

--org.springframework.beans.factory.support.BeanDefinitionReaderUtils#registerBeanDefinition

public static void registerBeanDefinition(
      BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
      throws BeanDefinitionStoreException {

   // Register bean definition under primary name.
   String beanName = definitionHolder.getBeanName();
   registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());

   // Register aliases for bean name, if any.
   String[] aliases = definitionHolder.getAliases();
   if (aliases != null) {
      for (String alias : aliases) {
         registry.registerAlias(beanName, alias);
      }
   }
}

• 通过BeanFactory的后置处理器对BeanDefinitionMap进行操作【详见 Spring之后置处理器】
• Spring框架(ApplicaitonContext)对BeanDefinitionMap进行遍历，利用反射创建Bean对象

public void preInstantiateSingletons() throws BeansException {
   
   List<String> beanNames = new ArrayList<String>(this.beanDefinitionNames);
   for (String beanName : beanNames) {
            //省略代码
      getBean(beanName);
   }
}

 

Bean的初始化阶段【生成Bean】

• 创建Bean的实例

--org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean

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

   //实例化Bean
   BeanWrapper instanceWrapper = null;
   if (mbd.isSingleton()) {
      instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
   }
   if (instanceWrapper == null) {
      instanceWrapper = createBeanInstance(beanName, mbd, args);
   }
   final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
   Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);

    //代码省略
        ...

   Object exposedObject = bean;
   try {
      //属性赋值（依赖注入）
      populateBean(beanName, mbd, instanceWrapper);
      if (exposedObject != null) {
         //初始化：包含Aware接口方法回调、BeanPostProcessor接口的回调、初始化方法的调用
         exposedObject = initializeBean(beanName, exposedObject, mbd);
      }
   }

   return exposedObject;
}

• 给Bean的属性赋值【依赖注入的方式详见 2. Spring IoC&DI】

--org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#populateBean

protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {
    PropertyValues pvs = mbd.getPropertyValues();
    //代码省略
    ...
    this.applyPropertyValues(beanName, mbd, bw, (PropertyValues)pvs);
}

• Aware接口方法回调

--org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#invokeAwareMethods

private void invokeAwareMethods(String beanName, Object bean) {
    if (bean instanceof Aware) {
        if (bean instanceof BeanNameAware) {
            ((BeanNameAware)bean).setBeanName(beanName);
        }

        if (bean instanceof BeanClassLoaderAware) {
            ((BeanClassLoaderAware)bean).setBeanClassLoader(this.getBeanClassLoader());
        }

        if (bean instanceof BeanFactoryAware) {
            ((BeanFactoryAware)bean).setBeanFactory(this);
        }
    }

}

• 调用BeanPostProcessor.postProcessBeforeInitialization方法【BeanPostProcessor接口的具体实现详见  Spring之后置处理器】
  • 如果用户没有编写自定义的BeanPostProcessor，则该步骤执行空方法

--org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsBeforeInitialization

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

   Object result = existingBean;
   for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
      result = beanProcessor.postProcessBeforeInitialization(result, beanName);
      if (result == null) {
         return result;
      }
   }
   return result;
}

• 调用Bean的初始化方法【详见 5. Bean的初始化方式】

--org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#invokeInitMethods

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

    //调用InitializingBean的实现类
   boolean isInitializingBean = (bean instanceof InitializingBean);
   if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
      if (System.getSecurityManager() != null) {
         try {
            AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {
               @Override
               public Object run() throws Exception {
                  ((InitializingBean) bean).afterPropertiesSet();
                  return null;
               }
            }, getAccessControlContext());
         }
         catch (PrivilegedActionException pae) {
            throw pae.getException();
         }
      }
      else {
         ((InitializingBean) bean).afterPropertiesSet();
      }
   }

    //调用init-method
   if (mbd != null) {
      String initMethodName = mbd.getInitMethodName();
      if (initMethodName != null && !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
            !mbd.isExternallyManagedInitMethod(initMethodName)) {
         invokeCustomInitMethod(beanName, bean, mbd);
      }
   }
}

• 调用BeanPostProcessor.postProcessAfterInitialization方法【详见  Spring之后置处理器】
  • 如果用户没有编写自定义的BeanPostProcessor，则该步骤执行空方法

--org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsAfterInitialization

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

   Object result = existingBean;
   for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
      result = beanProcessor.postProcessAfterInitialization(result, beanName);
      if (result == null) {
         return result;
      }
   }
   return result;
}

 

Bean的完成阶段【将Bean注入单例池】

• 创建好的Bean对象会存储到名为singletonObjects的Map中

--org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#addSingleton

protected void addSingleton(String beanName, Object singletonObject) {
   synchronized (this.singletonObjects) {
      this.singletonObjects.put(beanName, (singletonObject != null ? singletonObject : NULL_OBJECT));
      this.singletonFactories.remove(beanName);
      this.earlySingletonObjects.remove(beanName);
      this.registeredSingletons.add(beanName);
   }
}

• 获取Bean

--org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton(java.lang.String, boolean)

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
   Object singletonObject = this.singletonObjects.get(beanName);
   if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
      synchronized (this.singletonObjects) {
         singletonObject = this.earlySingletonObjects.get(beanName);
         if (singletonObject == null && allowEarlyReference) {
            ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
            if (singletonFactory != null) {
               singletonObject = singletonFactory.getObject();
               this.earlySingletonObjects.put(beanName, singletonObject);
               this.singletonFactories.remove(beanName);
            }
         }
      }
   }
   return (singletonObject != NULL_OBJECT ? singletonObject : null);
}

 

Bean的销毁阶段

• 调用Bean的销毁方法（在容器关闭的时候调用）

--org.springframework.context.support.AbstractApplicationContext#destroyBeans

protected void destroyBeans() {
    this.getBeanFactory().destroySingletons();
}