第一章 对象的生命周期

1.1 什么是对象的生命周期

Spring 对象的生命周期是指从对象创建到销毁的整个过程，包含了对象的实例化、初始化、使用和销毁等阶段。Spring 对象的生命周期可以分为以下几个阶段：

1. 实例化：当Spring容器接收到创建对象的请求时，它会创建一个对象的实例。
2. 属性设置：对象实例化后，Spring 容器会根据配置文件或注解将相关属性设置到对象中。
3. 初始化：对象的所有依赖关系都被设置后，Spring容器会调用对象的初始化方法，如定义的init-method。
4. 使用：对象初始化完成后，可以被使用于业务逻辑中。
5. 销毁：当 Spring 容器不再需要此对象实例时，会自动调用对象的销毁方法，如定义的destroy-method。

在整个Spring对象的生命周期中，开发人员可以通过编写相应的初始化和销毁方法来控制对象的行为，使其更好地满足业务需求。

1.2 为什么要学习对象的生命周期

理解对象生命周期对于开发人员来说非常重要，因为它有助于开发人员更好地掌握应用程序的状态和行为。

具体来说，了解对象生命周期可以帮助开发人员：

1. 确定何时初始化对象并设置其属性，在正确的时间点执行必要的操作。
2. 理解Spring框架如何管理bean，并掌握使用缓存技术以提高性能。
3. 诊断问题和调试代码。例如，当对象未按预期进行实例化或销毁时，开发人员可以通过追踪Spring容器中的对象生命周期来找到问题所在。
4. 技术评估和优化。了解对象生命周期可以帮助开发人员优化并设计我们的应用程序，有效减少内存、CPU和磁盘I/O的使用。
5. 避免可能出现的资源泄漏等问题。在很多情况下，如果一个对象的生命周期不被合理地管理，将会导致内存泄漏等问题。

1.3 生命周期的 3 个阶段

1.3.1 创建阶段

Spring⼯⼚何时创建对象?

• scope="singleton"

  单例模式下,Spring ⼯⼚创建的同时，就创建对象

  注意：设置scope=singleton 时,不想在工厂创建的同时去创建，而是在获取对象的同时才创建对象加如下配置就行（懒加载）

  <bean lazy-init="true"/>
  

• scope="prototype"

  多例模式下, Spring ⼯⼚在获取对象(java ctx.getBean("") )的时候，才创建对象

  ---

  注解的方式

  @scope =" singleton / prototype " 来控制单例/多例（默认是单例）

  ---

1.3.2 初始化阶段

Spring⼯⼚在创建完对象后，调⽤对象的初始化⽅法，完成对应的初始化操作

初始化⽅法提供：程序员根据需求，提供初始化⽅法，最终完成初始化操作

初始化⽅法调⽤：Spring⼯⼚进⾏调⽤

提供初始化方法有两种方式：

• 方式1：实现 InitializingBean 接⼝，并实现如下方法

  // 程序员根据需求，实现该⽅法，完成初始化操作

• 方式2：对象中提供⼀个普通的⽅法, 然后采取下面两种方式之一告知容器

  • 配置方式

    publicvoidmyInit(){
        
    }
    
    <beanid="product" class="xxx.Product" init-method="myInit"/>
    

  • 注解方式

  

• 细节分析

  （1）

  问题：如果⼀个对象即实现 InitializingBean 同时⼜提供的 普通的初始化⽅法顺序

  答案：实现 InitializingBean 接口方式 优先于 普通初始化⽅法

  （2）注⼊⼀定发⽣在初始化操作的前⾯

1.3.3 销毁阶段

Spring销毁对象前，会调⽤对象的销毁⽅法，完成销毁操作

销毁时机：工厂关闭的时候

销毁方法：程序员定义(有2种方式)，Spring调用

方式1 ：实现 DisposableBean 接口，并实现其 destroy() 方法。

public void destroy()throws Exception{
 
}

方式2：定义⼀个普通的⽅法, 然后采取下面两种方式之一告知容器

public void myDestroy()throws Exception{
}

• 配置方式

  <bean id="" class="" init-method="" destroy-method="myDestroy"/>
  

• 注解方式

  @PreDestroy
  public void myDestroy()throws Exception{
  }
  

细节分析

销毁⽅法的操作只适⽤于 scope="singleton"

适用场景：对于一些资源的销毁

1.4 总结

第二章 后置处理Bean

BeanPostProcessor 作⽤：对Spring⼯⼚所创建的对象，进⾏再加⼯。

AOP 底层有用到这个。

2.1 后置处理Bean的运⾏原理分析

程序员实现BeanPostProcessor规定接⼝中的⽅法：

Object  postProcessBeforeInitiallization(Object bean, String beanName) {}

作⽤：Spring创建完对象，并进⾏注⼊后，可以运⾏Before⽅法进⾏加⼯

获得Spring创建好的对象 ：通过⽅法的参数

最终通过返回值交给Spring框架

Object  postProcessAfterInitiallization(Object bean, String beanName) {}

作⽤：Spring执⾏完对象的初始化操作后，可以运⾏After⽅法进⾏加⼯

获得Spring创建好的对象 ：通过⽅法的参数

最终通过返回值交给Spring框架

实战中:

很少处理Spring的初始化操作：没有必要区分Before After。只需要实现其中的⼀个After ⽅法即可

注意： postProcessBeforeInitiallization return bean对象

2.2 BeanPostProcessor的开发步骤

1. 自定义类 实现 BeanPostProcessor接⼝

public class MyBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        Categroy categroy = (Categroy) bean;
        categroy.setName("露娜");
        return categroy;
    }
}

2. 相关配置

   • 配置方式1：

     <bean id="myBeanPostProcessor" class="xxx.MyBeanPostProcessor"/>
     

   • 配置方式2 注解：

     在配置类中：

     @Configuration
     public class AppConfig{
         @Bean
         public MyBeanPostProcessor myBeanPostProcessor() {
             return new MyBeanPostProcessor();
         }
         
         // ... other beans
     }
     

3. BeanPostProcessor 细节

   BeanPostProcessor 会对 Spring ⼯⼚中所有创建的对象进⾏加⼯ 。