Spring Bean的生命周期

目录

什么是Bean的生命周期？

为什么要知道Bean的生命周期 ？

Bean的生命周期——五步 

​编辑注意事项：

代码理解：

​编辑输出结果

Bean的生命周期——七步

 实现步骤：

 Bean的生命周期——十步

Bean的scop（作用域）不同，管理方式不同

什么是Bean的生命周期？

        Spring其实就是一个管理Bean对象的工厂。它负责对象的创建，对象的销毁等。

        所谓的生命周期就是：Bean对象从创建开始到最终销毁的整个过程。

为什么要知道Bean的生命周期 ？

        其实生命周期的本质是：在哪个时间节点上调用了哪个类的哪个方法。

        我们需要充分的了解在这个生命线上，都有哪些特殊的时间节点。只有我们知道了特殊的时间节点都在哪，到时我们才可以确定代码写到哪。我们可能需要在某个特殊的时间点上执行一段特定的代码，这段代码就可以放到这个节点上。当生命线走到这里的时候，自然会被调用。

---

Bean的生命周期——五步 

单例Bean生命周期可以粗略的划分为五大步：

        第一步：实例化（创建）Bean

        第二步：Bean属性赋值

        第三步：初始化（调用Bean的初始化方法）Bean

        第四步：使用（输出bean数据）Bean

        第五步：销毁（调用Bean的销毁方法）Bean

注意事项：

        第一：只有正常关闭spring容器，bean的销毁方法才会被调用。

        第二：ClassPathXmlApplicationContext类才有close()方法。

        第三：配置文件中的init-method指定初始化方法。destroy-method指定销毁方法。

代码理解：

package com.bjpowernode.spring.bean;
 
public class User {
    private String username;
 
    public User() {
        System.out.println("第一步：实例化Bean，无参数构造方法执行了");
    }


    public void setUsername(String username) {
        System.out.println("第二步：给对象的属性赋值");
        this.username = username;
    }
 
    // 初始化Bean，需要自己写，自己配，方法名随意
    public void initBean(){
        System.out.println("第三步：初始化Bean");
    }
 
    // 销毁Bean，需要自己写，自己配，方法名随意
    public void destroyBean(){
        System.out.println("第五步：销毁Bean");
    }
 
    @Override
    public String toString() {
        return "User{" +
                "username='" + username + '\'' +
                '}';
    }
}

需要在XML中调用init-method和destroy-method属性，手动指定初始化方法和销毁方法！ 

测试类：

        ①需要手动关闭Spring容器（调用close方法），这样Spring容器才会销毁Bean，才会去调用我们定义的destroyBean方法！
        ② 注意：只有ApplicationContext的实现类ClassPathXmlApplicationContext有close方法，ApplicationContext没有，所以需要强制类型转换；然后调用close方法

public class BeanLifecycleTest {
    @Test
    public void testBeanLifeCycleFive(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
        User user = applicationContext.getBean("user", User.class);
        System.out.println("第四步：使用Bean"+user);
 
        // 需要手动关闭Spring容器
        ClassPathXmlApplicationContext context = (ClassPathXmlApplicationContext) applicationContext;
        context.close();
    }
}

输出结果

---

Bean的生命周期——七步

 在以上的5步中，第3步是初始化Bean，如果你还想在初始化前和初始化后添加代码，可以加入“Bean后处理器”。

         一定要注意：在spring.xml文件中配置的Bean后处理器将作用于当前配置文件中所有的Bean，重写before和after方法的步骤不一定是在和其他几个步骤都在一个类中实现，实际上，只要设置了这个Bean后处理器，在当前配置文件中的所有的Bean进行调用都会执行一次这两个方法

• 第一步：实例化Bean
• 第二步：Bean属性赋值
• 第三步：执行“Bean后处理器”的before方法
• 第四步：初始化Bean
• 第五步：执行“Bean后处理器”的after方法
• 第六步：使用Bean
• 第七步：销毁Bean

 实现步骤：

        1. 编写一个类实现BeanPostProcessor类，并且重写before和after方法： 然后在配置文件中配置这个Bean后处理器

        ①第一个参数是创建的Bean对象！

        ②第二个参数是Bean的名字！

    2. 编写一个Bean

        

        3. 将Bean后处理器纳入Spring管理     

        4. 调用该Bean的输出结果

         

---

 Bean的生命周期——十步

（1）在“Bean后处理器”before方法之前干了什么事儿？
        检查Bean是否实现了Aware相关的接口，如果实现了接口则调用这些接口中的方法；调用这些方法的目的是为了给你传递一些数据，让你更加方便使用。

（2）在“Bean后处理器”before方法之后干了什么事儿？
        检查Bean是否实现了InitializingBean接口，如果实现了，则调用接口中的方法。

（3）使用Bean之后，或者说销毁Bean之前干了什么事儿？
        检查Bean是否实现了DisposableBean接口，如果实现了，则调用接口中的方法。

总结：添加的这三个点位的特点，都是在检查你这个Bean是否实现了某些特定的接口，如果实现了这些接口，则Spring容器会调用这个接口中的方法！

Aware相关的接口包括：BeanNameAware、BeanClassLoaderAware、BeanFactoryAware

        ①当Bean实现了BeanNameAware，Spring会将Bean的名字传递给Bean。

        ②当Bean实现了BeanClassLoaderAware，Spring会将加载该Bean的类加载器传递给Bean。

        ③当Bean实现了BeanFactoryAware，Spring会将Bean工厂对象传递给Bean。

测试以上10步，可以让User类实现5个接口，并实现所有方法：

        ①BeanNameAware

        ②BeanClassLoaderAware

        ③BeanFactoryAware

        ④InitializingBean

        ⑤DisposableBean

public class User implements BeanNameAware, BeanClassLoaderAware, BeanFactoryAware, InitializingBean, DisposableBean {
    private String name;

    public User() {
        System.out.println("1.实例化Bean");
    }
    public void setName(String name) {
        this.name = name;
        System.out.println("2.Bean属性赋值");
    }
    public void initBean(){
        System.out.println("6.初始化Bean");
    }
    public void destroyBean(){
        System.out.println("10.销毁Bean");
    }
    @Override
    public void setBeanClassLoader(ClassLoader classLoader) {
        System.out.println("3.类加载器：" + classLoader);
    }
    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("3.Bean工厂：" + beanFactory);
    }
    @Override
    public void setBeanName(String name) {
        System.out.println("3.bean名字：" + name);
    }
    @Override
    public void destroy() throws Exception {
        System.out.println("9.DisposableBean destroy");
    }
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("5.afterPropertiesSet执行");
    }
}

Bean后处理器：

public class LogBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("4.Bean后处理器的before方法执行，即将开始初始化");
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("7.Bean后处理器的after方法执行，已完成初始化");
        return bean;
    }
}

---

Bean的scop（作用域）不同，管理方式不同

        Spring 根据Bean的作用域来选择管理方式！

        对于singleton作用域的Bean，Spring 能够精确地知道该Bean何时被创建，何时初始化完成，以及何时被销毁；而对于 prototype 作用域的 Bean，Spring 只负责创建，当容器创建了 Bean 的实例后，Bean 的实例就交给客户端代码管理，Spring 容器将不再跟踪其生命周期。

就是说在使用了多列Bean后Spring 容器将不再跟踪其生命周期。就是说

这两步不再执行