spring的bean的生命周期

最新推荐文章于 2024-10-16 10:11:07 发布

莫得等待

最新推荐文章于 2024-10-16 10:11:07 发布

阅读量483

点赞数 4

分类专栏： spring 文章标签： spring java 后端

本文链接：https://blog.csdn.net/weixin_43924419/article/details/140086453

版权

spring 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

BeanFactory
1. BeanFactory是spring框架中的一个接口，他是一个工厂类，用来创建和管理spring中的Bean对象
2. Bean Factory实现类应该尽可能的支持标准的生命周期接口
Bean的生命周期
1. Bean的实例化阶段
2. Bean的设置属性阶段
3. Bean的初始化阶段
4. Bean的销毁阶段
Bean的实例化阶段
1. 在spring框架中，Bean的实例化是一个核心过程，他涉及了多个步骤以确保Bean能够正确地被创建并注入到应用上下文中
2. Bean定义注册
  1. 首先，你需要在spring的配置文件(如xml配置文件或java配置类)中定义Bean，这包括指定Bean的类名，作用域，初始化方法，销毁方法以及可能得依赖关系等
  2. spring容器会读取这些配置，并将Bean定义信息存储在其内部的数据结构中，通常是BeanDefinition对象
3. 实例化前的准备
  1. 在实例化Bean之前，spring会进行一些准备工作，如解析Bean定义中的属性，检查依赖关系等
  2. 如果Bean定义中引用了其他Bean，spring会尝试先解析并实例化这些依赖Bean
4. 实例化
  1. 实例化是创建Bean对象的过程，spring提供了多种实例化Bean的方式
  2. 构造器实例化：通过调用Bean的构造方法来创建实例，你可以在配置文件中指定要使用的构造方法，并提供相应的参数
  3. 静态工厂方法实例化：通过调用静态工厂方法来创建Bean实例，你需要在配置文件中指定工厂类的类名和工厂方法的名称
  4. 实例工厂方法实例化：首先实例化一个工厂Bean，然后调用该工厂Bean的某个静态方法来创建目标Bean实例
  5. 默认构造器实例化：如果Bean定义中没有指定其他实例化方式，并且Bean类有一个无参构造器，那么spring将使用默认构造器来实例化Bean
  6. 实例化完成之后，得到一个原始的对象，他还没有进行任何属性注入或初始化
5. 属性注入
  1. 在Bean实例化之后，spring会进行属性注入(也被称为依赖注入)，这包括将Bean定义中指定的属性值或对其他Bean的引用注入到Bean的相应属性中
  2. spring支持多种属性注入方法，如基于字段的注入，基于setter方法的注入和基于构造器的注入等
6. BeanPostProcessor处理
  1. 在Bean的属性住入完成后，但Bean的初始化方法执行之前，spring会调用已注册的BeanPostProcessor接口的postProcessBeforeInitialization方法，这是一个可选的步骤，可以通过实现该接口并注册相应的BeanPostProcessor来在Bean初始化前后执行自定义的逻辑
7. 初始化
  1. 接下来，spring会调用Bean定义中指定的初始化方法(如果有的话)，这通常是在Bean类中定义的某个方法，并用特定的注解(如@PostConstruct)或XML配置中的元素的init-method属性来指定
  2. 初始化方法是Bean在准备好接受请求之前进行必要设置或执行特定任务的地方
8. BeanPostProcessor再处理
  1. 在Bean初始化方法执行之后，spring会再次调用已经注册的BeanPostProcessor接口的postProcessAfterInitialization方法，这是另一个可选的步骤，可以在这里执行一些清理或后处理操作
9. Bean就绪
  1. 经过上述步骤之后，Bean就已经被完全创建并初始化了，现在他可以被应用上下文中的其他组件使用或注入到其他Bean中
Bean的设置属性阶段
1. Bean的设置属性阶段(也称为属性注入或依赖注入)是Bean生命周期中的一个重要环节，这个阶段发生在spring容器创建Bean的实例之后，但在Bean被实际使用之前
2. 当spring容器创建一个Bean的实例后，他会检查该Bean是否有需要注入属性，这些属性可能是其他的Bean，基本数据类型，集合，Map等
3. spring会查找与这些属性对应的配置信息，(可能是XML中的标签，注解中的值或其他配置方式)，并将他们注入到Bean的相应字段或setter方法中
注入方式
1. 字段注入：通过直接在字段上使用@Autowire或其他相关注解来实现，但请注意，字段注入在某些情况下可能导致测试困难或难以遵循良好的封装原则
2. 构造函数注入：在构造函数参数上使用@Autowired或其他相关注解，这是推荐的方式之一，因为他确保了Bean在创建时就已经拥有所有必须得依赖项，并且这些依赖项是不可变的
3. setter方法注入：在setter方法上使用@Autowired或其他相关注解，这种方式允许Bean在创建后的某个时间点接受其依赖项
Bean的初始化
1. Bean Aware接口回调
2. Bean初始化前操作
3. Bean初始化操纵
4. Bean初始化后操作
5. Bean初始化完成操作

BeanAware接口回调

 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(getBeanClassLoader());
   }
   if (bean instanceof BeanFactoryAware) {
    ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
   }
  }
 }

Bean初始化前操作

@Override
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初始化操作

调用InitializingBean接口的afterPropertiesSet方法调用定义Bean的时候指定的初始化方法

 public interface InitializingBean {

 /**
  * Invoked by the containing {@code BeanFactory} after it has set all bean properties
  * and satisfied {@link BeanFactoryAware}, {@code ApplicationContextAware} etc.
  * <p>This method allows the bean instance to perform validation of its overall
  * configuration and final initialization when all bean properties have been set.
  * @throws Exception in the event of misconfiguration (such as failure to set an
  * essential property) or if initialization fails for any other reason
  */
 void afterPropertiesSet() throws Exception;

}

Bean初始化后操作

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

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

Bean初始化完成操作

public interface SmartInitializingSingleton {

 /**
  * Invoked right at the end of the singleton pre-instantiation phase,
  * with a guarantee that all regular singleton beans have been created
  * already. {@link ListableBeanFactory#getBeansOfType} calls within
  * this method won't trigger accidental side effects during bootstrap.
  * <p><b>NOTE:</b> This callback won't be triggered for singleton beans
  * lazily initialized on demand after {@link BeanFactory} bootstrap,
  * and not for any other bean scope either. Carefully use it for beans
  * with the intended bootstrap semantics only.
  */
 void afterSingletonsInstantiated();

}

当完成了初始化之后，使用完成，最后Bean就要走到销毁阶段了

Bean的销毁

 @Override
 public void destroyBean(Object existingBean) {
  new DisposableBeanAdapter(
    existingBean, getBeanPostProcessorCache().destructionAware, getAccessControlContext()).destroy();
 }