【Spring6】| Bean的生命周期(五步、七步、十步法剖析)

目录

一:Bean的生命周期

1. 什么是Bean的生命周期

2. Bean的生命周期之五步分析法

3. Bean生命周期之七步分析法

4. Bean生命周期之十步分析法

5. Bean的scop(作用域)不同,管理方式不同

6. 自己new的对象如何让Spring管理


文章来源地址https://www.uudwc.com/A/8dn39/

一:Bean的生命周期

1. 什么是Bean的生命周期

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

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

(3)为什么要知道Bean的生命周期?

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

(4)下面我会按照由浅入深,按照5步、7步、10步法,讲解Bean的生命周期!

2. Bean的生命周期之五步分析法

(1)Bean生命周期的管理,可以参考Spring的源码:AbstractAutowireCapableBeanFactory类的doCreateBean()方法

(2)Bean生命周期可以粗略的划分为五大步:

  • 第一步:实例化Bean
  • 第二步:Bean属性赋值
  • 第三步:初始化Bean
  • 第四步:使用Bean
  • 第五步:销毁Bean

编写测试程序:

Bean的生命周期按照粗略的五步的话:

第一步:实例化Bean(调用无参数构造方法)
第二步:给Bean属性赋值(调用set方法)
第三步:初始化Bean(会调用Bean的init方法。注意:这个init方法需要自己写)
第四步:使用Bean
第五步:销毁Bean(会调用Bean的destroy方法。注意:这个destroy方法需要自己写)

定义一个Bean

package com.bjpowernode.spring.bean;

public class User {
    private String username;

    public void setUsername(String username) {
        System.out.println("第二步:给对象的属性赋值");
        this.username = username;
    }

    public User() {
        System.out.println("第一步:实例化Bean,无参数构造方法执行了");
    }

    // 初始化Bean,需要自己写,自己配,方法名随意
    public void initBean(){
        System.out.println("第三步:初始化Bean");
    }

    // 销毁Bean,需要自己写,自己配,方法名随意
    public void destroyBean(){
        System.out.println("第五步:销毁Bean");
    }

    @Override
    public String toString() {
        return "User{" +
                "username='" + username + '\'' +
                '}';
    }
}

spring.xml配置

需要在<bean>标签中调用init-methoddestroy-method属性,手动指定初始化方法和销毁方法!

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="user" class="com.bjpowernode.spring.bean.User"
          init-method="initBean" destroy-method="destroyBean">
          <!--给属性赋值-->
         <property name="username" value="张三"/>
    </bean>
</beans>

 测试程序

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

package com.bjpowernode.spring.test;

import com.bjpowernode.spring.bean.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

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();
    }
}

执行结果:从这里我们也可看出执行的顺序

总结要点:

第一:只有正常关闭spring容器(调用close方法),bean的销毁方法才会被调用。

第二:ClassPathXmlApplicationContext类才有close()方法,ApplicationContext中没有。

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

3. Bean生命周期之七步分析法

(1)在以上的5步中,第3步是初始化Bean,如果你还想在初始化前初始化后添加代码,可以加入“Bean后处理器”需要编写一个类实现BeanPostproccessor接口重写里面的befor和after方法

(2)Bean生命周期可以细化为七大步:

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

编写一个类实现BeanPostProcessor类,并且重写before和after方法

注意:方法中有两个参数:

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

②第二个参数是Bean的名字

package com.bjpowernode.spring.test;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;

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

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

在spring.xml文件中配置“Bean后处理器”

注意:在spring.xml文件中配置的Bean后处理器将作用于当前配置文件中所有的Bean!

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="user" class="com.bjpowernode.spring.bean.User"
          init-method="initBean" destroy-method="destroyBean">
          <!--给属性赋值-->
         <property name="username" value="张三"/>
    </bean>

    <!--配置Bean后处理器。这个后处理器将作用于当前配置文件中所有的bean。-->
    <bean class="com.bjpowernode.spring.bean.LogBeanPostProcessor"/>
</beans>

执行测试程序:

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

User类

package com.bjpowernode.spring.bean;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.*;


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

    public void setUsername(String username) {
        System.out.println("第二步:给对象的属性赋值");
        this.username = username;
    }

    public User() {
        System.out.println("第一步:实例化Bean,无参数构造方法执行了");
    }

    // 初始化Bean,需要自己写,自己配,方法名随意
    public void initBean(){
        System.out.println("第四步:初始化Bean");
    }

    // 销毁Bean,需要自己写,自己配,方法名随意
    public void destroyBean(){
        System.out.println("第七步:销毁Bean");
    }

    @Override
    public String toString() {
        return "User{" +
                "username='" + username + '\'' +
                '}';
    }

    @Override
    public void setBeanClassLoader(ClassLoader classLoader) {
        System.out.println("类加载器:" + classLoader);
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("Bean工厂:" + beanFactory);
    }

    @Override
    public void setBeanName(String name) {
        System.out.println("Bean的名字:" + name);
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("DisposableBean destroy方法执行了");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("InitializingBean afterPropertiesSet方法执行了");
    }
}

执行结果:

总结:

①InitializingBean的方法早于init-method的执行。

②DisposableBean的方法早于destroy-method的执行。

5. Bean的scop(作用域)不同,管理方式不同

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

(1)对于singleton(单例)作用域的BeanSpring 能够精确地知道该Bean何时被创建,何时初始化完成,以及何时被销毁。

(2)而对于 prototype(多例/原型) 作用域的 Bean:Spring 只负责创建,当容器创建了 Bean 的实例后,Bean 的实例就交给客户端代码管理,Spring 容器将不再跟踪其生命周期

把spring.xml配置文件当中scop属性的singleton改成property

再次执行测试程序:

当是多例的实际上只有前8步了,对于后两步的:检查Bean是否实现了DisposableBean接口 和 销毁Bean就不管了!

6. 自己new的对象如何让Spring管理

有些时候可能会遇到这样的需求,某个java对象是我们自己手动new的,然后我们希望这个对象被Spring容器管理,怎么实现呢?

Student类

package com.bjpowernode.spring.bean;

public class Student {
}

进行测试:

第一步:创建DefaultListableBeanFactory对象!

第二步:注册Bean,调用这个对象的registerSingleton()方法把自己创建的对象传进去,并起一个名字!

第三步:根据名字,调用getBean方法从Spring容器当中获取Bean对象!

package com.bjpowernode.spring.test;

import com.bjpowernode.spring.bean.Student;
import com.bjpowernode.spring.bean.User;
import org.junit.Test;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class BeanLifecycleTest {

    @Test
    public void testBeanRegister(){
        // 自己new的对象,没有被Spring管理
        Student student = new Student();
        System.out.println(student);
        // 创建DefaultListableBeanFactory对象
        DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
        // 调用registerSingleton方法注册Bean
        factory.registerSingleton("studentBean",student);
        // 从Spring容器当中取出Bean
        Student studentBean = factory.getBean("studentBean", Student.class);
        System.out.println(studentBean);

    }
}

执行结果:

获取到的是同一个Bean对象,说明确实是把我们创建的对象放到Spring容器当中进行管理!

原文地址:https://blog.csdn.net/m0_61933976/article/details/128697003

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请联系站长进行投诉反馈,一经查实,立即删除!

h
上一篇 2023年11月02日 03:19
毫米波雷达的硬件架构与射频前端
下一篇 2023年11月02日 04:49