Spring bean的生命周期

SeaDhdhdhdhdh

已于 2022-09-25 21:35:14 修改

阅读量484

点赞数

分类专栏： spring 文章标签： spring

于 2022-08-22 22:46:53 首次发布

本文链接：https://blog.csdn.net/weixin_43119856/article/details/126475176

版权

spring 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

Spring bean的生命周期：

Spring Bean的生命周期指的是Bean从创建到初始化再到销毁的过程，这个过程由IOC容器管理。一个完整的Bean生命周期可以参考Spring Bean生命周期。

Bean的初始化和销毁在整个生命周期过程中，我们可以自定义Bean的初始化和销毁函数，当Bean的生命周期到达相应的阶段的时候，Spring会调用我们自定义的Bean的初始化和销毁方法。自定义Bean初始化和销毁方法有多种方式，下面逐一介绍。

1生命周期的概要流程

Bean 的生命周期概括起来就是 4 个阶段：

实例化（Instantiation）
属性赋值（Populate）
初始化（Initialization）
销毁（Destruction）

实例化：第 1 步，实例化一个 bean 对象，在堆内存中申请空间，此时对象的属性值一般是默认值。反射中对应的是创建对象的过程。源码中的方法为：createBeanInstance()，该方法执行逻辑：获取Class对象；获取构造器；创建对象
自定义属性赋值：第 2 步，为 bean 设置相关属性和依赖；源码中的方法为populateBean()，
初始化：第 3~7 步，步骤较多，其中第 5、6 步为初始化操作，第 3、4 步为在初始化前执行，第 7 步在初始化后执行，该阶段结束，才能被用户使用；
1. 检查Aware接口设置相关依赖：aware在源码中是一个空接口，可以理解为给实现这个接口的类和继承这个接口的接口做一个标记，然后根据标记进行统一处理。一般来讲，spring bean对象按照使用者分为两类：自定义对象，容器对象。容器对象会实现aware接口，所以可以通过是否是aware接口的实例来判断是否是容器对象，从而给容器对象赋值。源码方法为：invokeAwareMethods()。
  执行完此步骤之后，对象的创建和复赋值都完成了，此时的对象是否可以直接拿来使用了？理论上是可以的，但是注意spring要考虑扩展性，此时考虑获得的普通对象是否需要扩展？
2. 执行前置处理方法：postProcessBeforeInitialization()，方法所在接口为BeanPostProcessor，此处会有AOP（面试经常问实现原理，动态代理这些）。
3. 执行初始化方法：invokeinitMethods()，检测bean是否实现了InitialiingBean()接口，然后调用afterPropertiesSet()方法，该方法内可以自定义一些处理逻辑。
4. 执行后置处理方法：postProcessAfterInitialization()，方法所在接口为BeanPostProcessor，此处会有AOP（面试经常问实现原理，动态代理这些）。
5. 此时bean对象可以使用了。
销毁：第 8~10步，第8步不是真正意义上的销毁（还没使用呢），而是先在使用前注册了销毁的相关调用接口，为了后面第9、10步真正销毁 bean 时再执行相应的方法。

结合代码来直观的看下，在 doCreateBean() 方法中能看到依次执行了这 4 个阶段：

// AbstractAutowireCapableBeanFactory.java
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
    throws BeanCreationException {
 
    // 1. 实例化
    BeanWrapper instanceWrapper = null;
    if (instanceWrapper == null) {
        instanceWrapper = createBeanInstance(beanName, mbd, args);
    }
   
    Object exposedObject = bean;
    try {
        // 2. 属性赋值
        populateBean(beanName, mbd, instanceWrapper);
        // 3. 初始化
        exposedObject = initializeBean(beanName, exposedObject, mbd);
    }
 
    // 4. 销毁-注册回调接口
    try {
        registerDisposableBeanIfNecessary(beanName, bean, mbd);
    }
 
    return exposedObject;
}

2 详细流程

由于初始化包含了第 3~7 步，较复杂，所以我们进到 initializeBean() 方法里具体看下其过程（注释的序号对应图中序号）：

// AbstractAutowireCapableBeanFactory.java protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) { //

// 3.检查 Aware 相关接口并设置相关依赖
if(System.getSecurityManager() != null)
{
    AccessController.doPrivileged((PrivilegedAction < Object > )() - >
    {
        invokeAwareMethods(beanName, bean);
        return null;
    }, getAccessControlContext());
}
else
{
    invokeAwareMethods(beanName, bean);
} 
// 4. BeanPostProcessor 前置处理 Object wrappedBean = bean;
if(mbd == null || !mbd.isSynthetic())
{
    wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
} 
// 5. 若实现 InitializingBean 接口， 调用 afterPropertiesSet() 方法 
// 6. 若配置自定义的 init - method方法， 则执行
try
{
    invokeInitMethods(beanName, wrappedBean, mbd);
}
catch(Throwable ex)
{
    throw new BeanCreationException((mbd != null ? mbd.getResourceDescription() : null), beanName, "Invocation of init method failed", ex);
} 
//7. BeanPostProceesor 后置处理
if(mbd == null || !mbd.isSynthetic())
{
    wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}

在 invokInitMethods() 方法中会检查 InitializingBean 接口和 init-method 方法，销毁的过程也与其类似：

// DisposableBeanAdapter.java public void destroy() {     
// 9. 若实现 DisposableBean 接口， 则执行 destory() 方法
 if(this.invokeDisposableBean)
 {
     try
     {
         if(System.getSecurityManager() != null)
         {
             AccessController.doPrivileged((PrivilegedExceptionAction < Object > )() - >
             {
                 ((DisposableBean) this.bean).destroy();
                 return null;
             }, this.acc);
         }
         else
         {
             ((DisposableBean) this.bean).destroy();
         }
     }
 } 
 //10. 若配置自定义的 detory - method 方法， 则执行
 if(this.destroyMethod != null)
 {
     invokeCustomDestroyMethod(this.destroyMethod);
 }
 else if(this.destroyMethodName != null)
 {
     Method methodToInvoke = determineDestroyMethod(this.destroyMethodName);
     if(methodToInvoke != null)
     {
         invokeCustomDestroyMethod(ClassUtils.getInterfaceMethodIfPossible(methodToInvoke));
     }
 }
 }

3 扩展点

从 Spring 的源码我们可以直观的看到其执行过程，而我们记忆其过程便可以从这 4 个阶段出发，实例化、属性赋值、初始化、销毁。其中细节较多的便是初始化，涉及了 Aware、BeanPostProcessor、InitializingBean、init-method 的概念。这些都是 Spring 提供的扩展点。

1. Aware 接口
若 Spring 检测到 bean 实现了 Aware 接口，则会为其注入相应的依赖。所以通过让bean 实现 Aware 接口，则能在 bean 中获得相应的 Spring 容器资源。
Spring 中提供的 Aware 接口有：

BeanNameAware：注入当前 bean 对应 beanName；
BeanClassLoaderAware：注入加载当前 bean 的 ClassLoader；
BeanFactoryAware：注入当前BeanFactory容器的引用。

// AbstractAutowireCapableBeanFactory.java private void invokeAwareMethods(final String beanName, final Object bean) 
{
    if(bean instanceof Aware)
    {
        if(bean instanceof BeanNameAware)
        {
            ((BeanNameAware) bean).setBeanName(beanName);
        }
        if(bean instanceof BeanClassLoaderAware)
        {
            ((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
        }
        if(bean instanceof BeanFactoryAware)
        {
            ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
        }
    }
}

以上是针对 BeanFactory 类型的容器，而对于 ApplicationContext 类型的容器，也提供了 Aware 接口，只不过这些 Aware 接口的注入实现，是通过 BeanPostProcessor 的方式注入的，但其作用仍是注入依赖。

EnvironmentAware：注入 Enviroment，一般用于获取配置属性；
EmbeddedValueResolverAware：注入 EmbeddedValueResolver（Spring EL解析器），一般用于参数解析；
ApplicationContextAware（ResourceLoader、ApplicationEventPublisherAware、MessageSourceAware）：注入 ApplicationContext 容器本身。

其代码实现如下：

 // ApplicationContextAwareProcessor.java private void invokeAwareInterfaces(Object bean) 
 {
     if(bean instanceof EnvironmentAware)
     {
         ((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
     }
     if(bean instanceof EmbeddedValueResolverAware)
     {
         ((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver);
     }
     if(bean instanceof ResourceLoaderAware)
     {
         ((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);
     }
     if(bean instanceof ApplicationEventPublisherAware)
     {
         ((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);
     }
     if(bean instanceof MessageSourceAware)
     {
         ((MessageSourceAware) bean).setMessageSource(this.applicationContext);
     }
     if(bean instanceof ApplicationContextAware)
     {
         ((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
     }
 }

2.BeanPostProcessor

BeanPostProcessor 是 Spring 为修改 bean提供的强大扩展点，其可作用于容器中所有 bean，其定义如下：
public interface BeanPostProcessor { // 初始化前置处理 default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { return bean; } // 初始化后置处理 default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { return bean; } } 复制代码
常用场景有：

对于标记接口的实现类，进行自定义处理。例如3.1节中所说的ApplicationContextAwareProcessor，为其注入相应依赖；再举个例子，自定义对实现解密接口的类，将对其属性进行解密处理；
为当前对象提供代理实现。例如 Spring AOP 功能，生成对象的代理类，然后返回。

 // AbstractAutoProxyCreator.java public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) 
 {
     TargetSource targetSource = getCustomTargetSource(beanClass, beanName);
     if(targetSource != null)
     {
         if(StringUtils.hasLength(beanName))
         {
             this.targetSourcedBeans.add(beanName);
         }
         Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(beanClass, beanName, targetSource);
         Object proxy = createProxy(beanClass, beanName, specificInterceptors, targetSource);
         this.proxyTypes.put(cacheKey, proxy.getClass()); // 返回代理类 return proxy;     }      return null; }

3 InitializingBean 和 init-method
InitializingBean 和 init-method 是 Spring 为 bean 初始化提供的扩展点。
InitializingBean接口的定义如下：
public interface InitializingBean { void afterPropertiesSet() throws Exception; } 复制代码
在 afterPropertiesSet() 方法写初始化逻辑。
指定 init-method 方法，指定初始化方法：

<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"> <bean id="demo" class="com.chaycao.Demo" init-method="init()"/> </beans>

DisposableBean 和 destory-method 与上述类似，就不描述了。

最后总结下如何记忆 Spring Bean 的生命周期：

首先是实例化、属性赋值、初始化、销毁这 4 个大阶段；
再是初始化的具体操作，有 Aware 接口的依赖注入、BeanPostProcessor 在初始化前后的处理以及 InitializingBean 和 init-method 的初始化操作；
销毁的具体操作，有注册相关销毁回调接口，最后通过DisposableBean 和 destory-method 进行销毁。