Spring窥探系列之Bean生命周期(100%GPT生成版)

生命周期概览

Spring Bean 的生命周期可以分为以下阶段:

  1. 实例化:Spring 容器根据 Bean 的定义创建一个 Bean 的实例。这个阶段主要涉及 Bean 的实例化和依赖注入。

    相关类:InstantiationAwareBeanPostProcessor、BeanFactoryPostProcessor、BeanPostProcessor、BeanWrapper、DefaultListableBeanFactory 等。

  2. 属性赋值:所有的 Bean 属性被设置为配置值或者默认值,这个阶段主要涉及 Bean 的属性填充。

    相关类:InstantiationAwareBeanPostProcessor、BeanFactoryPostProcessor、BeanPostProcessor、BeanWrapper、DefaultListableBeanFactory 等。

  3. 初始化前:调用 @PostConstruct 和 InitializingBean 的实现方法,以及自定义的初始化方法。

    相关类:InstantiationAwareBeanPostProcessor、BeanFactoryPostProcessor、BeanPostProcessor、InitializingBean、AbstractAutowireCapableBeanFactory 等。

  4. 初始化后:调用 BeanPostProcessor 的 postProcessAfterInitialization 方法,以及自定义的初始化方法。

    相关类:InstantiationAwareBeanPostProcessor、BeanFactoryPostProcessor、BeanPostProcessor、AbstractAutowireCapableBeanFactory 等。

  5. 销毁前:调用 @PreDestroy 和 DisposableBean 的实现方法,以及自定义的销毁方法。

    相关类:DisposableBean、AbstractAutowireCapableBeanFactory 等。

  6. 销毁:Spring 容器销毁 Bean 对象,释放资源。

    相关类:DisposableBean、AbstractAutowireCapableBeanFactory 等。

其中,InstantiationAwareBeanPostProcessor、BeanFactoryPostProcessor、BeanPostProcessor 是 Spring Framework 中常用的扩展点,用于在 Bean 的生命周期中拦截和处理 Bean 对象。AbstractAutowireCapableBeanFactory 是 Spring Framework 中的一个重要实现类,实现了 Bean 对象的创建、属性注入、初始化和销毁等功能。DefaultListableBeanFactory 则是 AbstractAutowireCapableBeanFactory 的子类,实现了 Bean 的注册和查找等功能。

主要类的作用和常用方法的详细说明

  1. BeanFactoryPostProcessor 接口

该接口的作用是在 Spring 容器初始化之后,但是在 Bean 实例化之前,对 BeanFactory 进行修改。它提供了一个方法 postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory),该方法可以实现对 BeanFactory 的配置元数据进行修改,例如添加新的 BeanDefinition 等。

常用方法:

  • postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory): 该方法在 BeanFactory 标准初始化之后、任何 bean 被实例化之前被调用。可以通过该方法修改 BeanFactory 的配置元数据,例如添加新的 BeanDefinition 等。
  1. BeanPostProcessor 接口

该接口的作用是在 Spring 容器完成 Bean 实例化和属性注入之后,但是在调用 Bean 的初始化方法之前和之后,对 Bean 实例进行自定义的初始化和销毁操作。它提供了两个方法 postProcessBeforeInitialization(Object bean, String beanName)postProcessAfterInitialization(Object bean, String beanName),分别对应 Bean 初始化前和初始化后的操作。

常用方法:

  • postProcessBeforeInitialization(Object bean, String beanName): 该方法在 Bean 对象实例化后、依赖注入完成后、初始化方法调用之前被调用。可以在该方法中自定义 Bean 对象的初始化逻辑。

  • postProcessAfterInitialization(Object bean, String beanName): 该方法在 Bean 对象实例化后、依赖注入完成后、初始化方法调用之后被调用。可以在该方法中自定义 Bean 对象的销毁逻辑。

  1. InstantiationAwareBeanPostProcessor 接口

该接口继承了 BeanPostProcessor 接口,增加了对 Bean 实例化前的处理方法 postProcessBeforeInstantiation(Class beanClass, String beanName) 和对属性进行修改的方法 postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName)

常用方法:

  • postProcessBeforeInstantiation(Class beanClass, String beanName): 该方法在 Bean 对象实例化之前被调用,可以在该方法中返回一个代理对象来替代原始的 Bean 对象实例。

  • postProcessAfterInstantiation(Object bean, String beanName): 该方法在 Bean 对象实例化之后、依赖注入完成之后、初始化方法调用之前被调用。可以在该方法中告知 Spring 容器是否需要继续对该 Bean 对象进行属性注入和初始化等操作。

  • postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName): 该方法在 Bean 对象的属性填充之后、初始化方法调用之前被调用。可以在该方法中修改 Bean 对象的属性值。

  1. InitializingBean 接口

该接口提供了一个方法 afterPropertiesSet(),在 Bean 对象的所有属性被设置完毕之后调用。可以在该方法中自定义 Bean 对象的初始化逻辑。

常用方法:

  • afterPropertiesSet(): 该方法在 Bean 对象的所有属性被设置完毕之后调用。可以在该方法中自定义 Bean 对象的初始化逻辑。
  1. DisposableBean 接口

该接口提供了一个方法 destroy(),在 Bean 对象被销毁之前调用。可以在该方法中自定义 Bean 对象的销毁逻辑。

常用方法:

  • destroy(): 该方法在 Bean 对象被销毁之前调用。可以在该方法中自定义 Bean 对象的销毁逻辑。
  1. AbstractAutowireCapableBeanFactory

该类是 Spring Bean Factory 的一个抽象实现,提供了创建 Bean 对象、属性注入、初始化和销毁等方法的默认实现,可以用于定制自己的 Bean Factory 实现。

常用方法:

  • createBean(Class beanClass): 根据指定的类型创建一个 Bean 对象。

  • doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args): 根据指定的 BeanDefinition 和构造函数参数创建一个 Bean 对象。

  • applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName): 在 Bean 的初始化方法调用之前,对 Bean 进行后置处理。

  • applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName): 在 Bean 的初始化方法调用之后,对 Bean 进行后置处理。

  • destroyBean(Object bean): 销毁指定的 Bean 对象,包括调用 DisposableBean 接口的 destroy() 方法和自定义的销毁逻辑。

  1. AbstractBeanFactory

该类是 BeanFactory 接口的抽象实现,提供了创建 Bean 对象、获取 Bean 对象、Bean 的生命周期管理等方法的默认实现。

常用方法:

  • containsBean(String name): 判断是否存在指定名称的 Bean 对象。

  • getType(String name): 获取指定名称的 Bean 对象的类型。

  • getBean(String name): 根据指定名称获取一个 Bean 对象。

  • getBean(String name, Class requiredType): 根据指定名称和类型获取一个 Bean 对象。

  • getBeanDefinition(String beanName): 获取指定名称的 BeanDefinition 对象。

  • registerSingleton(String name, Object singletonObject): 注册一个单例 Bean 对象。

  • destroySingletons(): 销毁所有的单例 Bean 对象,包括调用 DisposableBean 接口的 destroy() 方法和自定义的销毁逻辑。

  1. ConfigurableBeanFactory 接口

该接口是 BeanFactory 接口的子接口,增加了对 Bean 的生命周期管理的方法,例如添加 BeanPostProcessor、添加 BeanFactoryPostProcessor 等。

常用方法:

  • addBeanPostProcessor(BeanPostProcessor beanPostProcessor): 添加一个 BeanPostProcessor。

  • addBeanFactoryPostProcessor(BeanFactoryPostProcessor beanFactoryPostProcessor): 添加一个 BeanFactoryPostProcessor。

  • registerAlias(String beanName, String alias): 注册一个 Bean 别名。

  1. ApplicationContext 接口

该接口是 Spring 应用上下文的核心接口,扩展了 BeanFactory 接口,提供了更多的应用上下文级别的功能,例如事件发布、国际化支持等。

常用方法:

  • getBean(String name): 根据指定名称获取一个 Bean 对象。

  • getBean(Class requiredType): 根据指定类型获取一个 Bean 对象。

  • publishEvent(ApplicationEvent event): 发布一个应用事件。

  • getMessage(String code, Object[] args, String defaultMessage, Locale locale): 获取国际化信息。

释疑

InstantiationAwareBeanPostProcessorBeanPostProcessor 接口的主要区别在于方法的调用时机和提供的回调方法的不同。

BeanPostProcessor 接口提供了两个回调方法 postProcessBeforeInitializationpostProcessAfterInitialization,用于在 Bean 初始化前和初始化后对 Bean 进行自定义的初始化和销毁操作。

InstantiationAwareBeanPostProcessor 接口继承了 BeanPostProcessor 接口,并且提供了三个额外的回调方法,用于在 Bean 实例化前、实例化后和属性填充后对 Bean 进行自定义的处理:

  • postProcessBeforeInstantiation: 在 Bean 实例化之前调用,可以返回一个代理对象来替代原始的 Bean 对象实例。

  • postProcessAfterInstantiation: 在 Bean 实例化之后、依赖注入完成之后、初始化方法调用之前被调用。可以在该方法中告知 Spring 容器是否需要继续对该 Bean 对象进行属性注入和初始化等操作。

  • postProcessPropertyValues: 在 Bean 对象的属性填充之后、初始化方法调用之前被调用。可以在该方法中修改 Bean 对象的属性值。

因此,相较于 BeanPostProcessor 接口,InstantiationAwareBeanPostProcessor 接口提供了更多的回调方法,使得我们可以在更多的时机进行自定义的处理。一般情况下,如果只需要在 Bean 的初始化前和初始化后进行自定义的处理,可以直接实现 BeanPostProcessor 接口;如果需要在更多的时机进行自定义处理,可以实现 InstantiationAwareBeanPostProcessor 接口。

你可能感兴趣的:(Java,Spring,spring,java,后端)