Spring bean的生命周期详解！

发表于 更新于 分类于 阅读次数： 本文字数： 3k 阅读时长 ≈ 3 分钟

你好，我是猿java。

Spring Bean 是 Spring 框架中最核心的概念之一，它代表了一个由 Spring 容器管理的对象。这篇文章，我们将分析 Spring bean的生命周期以及对应的源码分析。

Spring Bean 的生命周期

Spring bean 一个完整的生命周期包含下面 10个阶段：

  1. 实例化（Instantiation）

容器通过反射机制创建一个 Bean 的实例。

  1. 属性赋值（Populate Properties）：

    • 容器将 Bean 的属性值（包括依赖注入的其他 Bean）设置到新创建的实例中。

  2. BeanNameAware 接口回调：

    • 如果 Bean 实现了 BeanNameAware 接口，容器会调用 setBeanName(String name) 方法，传递当前 Bean 的名称。

  3. BeanFactoryAware 接口回调：

    • 如果 Bean 实现了 BeanFactoryAware 接口，容器会调用 setBeanFactory(BeanFactory beanFactory) 方法，传递当前的 BeanFactory 实例。

  4. ApplicationContextAware 接口回调：

    • 如果 Bean 实现了 ApplicationContextAware 接口，容器会调用 setApplicationContext(ApplicationContext applicationContext) 方法，传递当前的 ApplicationContext 实例。

  5. BeanPostProcessor 前置处理：

    • 容器调用所有注册的 BeanPostProcessor 的 postProcessBeforeInitialization(Object bean, String beanName) 方法。

  6. 初始化（Initialization）：

    • 如果 Bean 实现了 InitializingBean 接口，容器会调用 afterPropertiesSet() 方法。
    • 如果 Bean 在配置文件中通过 init-method 属性指定了初始化方法，容器会调用该方法。

  7. BeanPostProcessor 后置处理：

    • 容器调用所有注册的 BeanPostProcessor 的 postProcessAfterInitialization(Object bean, String beanName) 方法。

  8. 使用（Usage）：

    • 此时 Bean 已经完成初始化，可以被应用程序使用。

  9. 销毁（Destruction）：

    • 如果 Bean 实现了 DisposableBean 接口，容器会调用 destroy() 方法。
    • 如果 Bean 在配置文件中通过 destroy-method 属性指定了销毁方法，容器会调用该方法。

原理

Spring Bean 生命周期的管理主要依赖于 Spring 的 IoC（Inversion of Control，控制反转）容器。这个容器负责创建、初始化、配置和销毁 Bean。通过配置文件或注解，开发者可以定义 Bean 的依赖关系和生命周期回调方法。

Spring 通过 BeanFactory 和 ApplicationContext 接口提供了对 Bean 生命周期的控制。ApplicationContext 是 BeanFactory 的一个子接口，提供了更多高级特性，如事件发布、国际化等。

源码详解

Spring 框架的核心源码位于 org.springframework.beans 和 org.springframework.context 包中。以下是一些关键类和接口：

  1. BeanFactory：

    • BeanFactory 是 Spring 容器的核心接口，定义了 Bean 的创建和获取方法。
      1
      2
      3
      4
      5
      public interface BeanFactory {
          Object getBean(String name) throws BeansException;
          <T> T getBean(String name, Class<T> requiredType) throws BeansException;
          // 其他方法...
      }

  2. DefaultListableBeanFactory：

    • DefaultListableBeanFactory 是 Spring 中最常用的 BeanFactory 实现类，提供了完整的 Bean 定义和管理功能。
      1
      2
      3
      4
      5
      6
      7
      public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory implements ConfigurableListableBeanFactory {
          // 核心方法
          public Object getBean(String name) throws BeansException {
              // 实例化和初始化 Bean 的逻辑
          }
          // 其他方法...
      }

  3. AbstractAutowireCapableBeanFactory：

    • 此类实现了 Bean 的创建、属性注入、初始化和销毁等核心逻辑。
      1
      2
      3
      4
      5
      6
      7
      public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory {
          @Override
          protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {
              // 创建 Bean 的逻辑，包括调用 BeanPostProcessor
          }
          // 其他方法...
      }

  4. BeanPostProcessor：

    • BeanPostProcessor 是一个接口，允许在 Bean 初始化前后添加自定义逻辑。
      1
      2
      3
      4
      5
      6
      7
      8
      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;
          }
      }

  5. ApplicationContext：

    • ApplicationContext 是 BeanFactory 的子接口，提供了更多高级特性。
      1
      2
      3
      public interface ApplicationContext extends EnvironmentCapable, ListableBeanFactory, HierarchicalBeanFactory, MessageSource, ApplicationEventPublisher, ResourcePatternResolver {
          // 其他方法...
      }

通过阅读和理解这些核心类和接口的源码，可以深入了解 Spring Bean 生命周期的实现原理。希望这些信息对你理解 Spring Bean 的生命周期有所帮助。

学习交流

如果你觉得文章有帮助，请帮忙转发给更多的好友，或关注公众号：猿java，持续输出硬核文章。

drawing