SpringBoot的生命周期

最新推荐文章于 2024-05-21 09:56:40 发布

手可摘鑫晨

最新推荐文章于 2024-05-21 09:56:40 发布

阅读量432

点赞数 5

本文链接：https://blog.csdn.net/m0_61562689/article/details/126093225

版权

本文详细介绍了Spring中Bean的生命周期，包括实例化、属性赋值、 Aware 接口调用、BeanPostProcessor前后处理、初始化方法执行、自定义初始化及销毁方法、 DisposableBean 回调等关键步骤，揭示了Spring如何管理和初始化Bean。

摘要由CSDN通过智能技术生成

1，实例化bean对象。

// 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，检查Aware的相关接口。

如果Bean类实现BeanNameAware接口，则将通过传递Bean的名称来调用setBeanName()方法。

如果Bean类实现BeanClassLoaderAware接口，则将通过传递加载此Bean的ClassLoader对象的实例来调用setBeanClassLoader()方法。

如果Bean类实现BeanFactoryAware接口，则将通过传递BeanFactory对象的实例来调用setBeanFactory()方法。

// 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);
        }
    }
}

4，BeanPostProcessor前置处理。

如果有类实现BeanPostProcessors接口，则将在初始化之前调用postProcessBeforeInitialization()方法。

4. BeanPostProcessor 前置处理 Object wrappedBean = bean;
if(mbd == null || !mbd.isSynthetic())
{
    wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
} //

5，是否实现InitializingBean接口。

如果Bean类实现了InitializingBean接口，将调用afterPropertiesSet()方法。

5. 若实现 InitializingBean 接口， 调用 afterPropertiesSet() 方法 //

6，是否配置自定义init-method

如果配置文件中的Bean定义包含init-method属性，则该属性的值将解析为Bean类中的方法名称，并将调用该方法。

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，BeanPostProcessor后置处理。

如果有类实现BeanPostProcessors接口，则将在初始化之后调用postProcessAfterInitialization()方法。

7. BeanPostProceesor 后置处理
if(mbd == null || !mbd.isSynthetic())
{
    wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}

8，注册DisposableBean相关回调接口。

如果Bean类实现DisposableBean接口，则当Application不再需要Bean引用时，将调用destroy()方法；

8. 若实现 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();
         }
     }
 }

9，是否配置自定义destroy-method。

如果配置文件中的Bean定义包含destroy-method属性，那么将调用Bean类中的相应方法定义。


 if(this.destroyMethod != null) {
     invokeCustomDestroyMethod(this.destroyMethod);
 } else if(this.destroyMethodName != null) {
     Method methodToInvoke = determineDestroyMethod(this.destroyMethodName);
     if(methodToInvoke != null) {                     
        invokeCustomDestroyMethod(ClassUtils.getInterfaceMethodIfPossible(methodToInvoke));
     }
 }