Spring6 - （09） Bean 的生命周期

最新推荐文章于 2024-05-24 02:08:26 发布

Julissa.

最新推荐文章于 2024-05-24 02:08:26 发布

阅读量156

点赞数 1

分类专栏： Spring6学习之路文章标签： java spring servlet

本文链接：https://blog.csdn.net/chenyouchang/article/details/129783286

版权

Spring6学习之路专栏收录该内容

18 篇文章 2 订阅

订阅专栏

在这里插入图片描述

文章目录

Spring6 -（09）Bean的生命周期

Spring6 -（09）Bean的生命周期

1. Bean的生命周期

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

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

对应Bean的生命周期，我们需要掌握以下几点：

什么时候创建Bean对象？
创建Bean对象的前后会调用什么方法？
Bean对象什么时候销毁？
Bean对象的销毁前后调用什么方法？

2. 知道Bean的生命周期的作用

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

我们需要充分的了解在这个生命线上，都有哪些特殊的时间节点。

只有我们知道了特殊的时间节点都在哪，到时我们才可以确定代码写到哪。

我们可能需要在某个特殊的时间点上执行一段特定的代码，这段代码就可以放到这个节点上。当生命线走到这里的时候，自然会被调用。

3. Bean的生命周期之5步

Bean生命周期的管理，可以参考Spring的源码：AbstractAutowireCapableBeanFactory类的doCreateBean()方法**。**

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

第一步：实例化Bean（调用无参构造方法）
第二步：Bean属性赋值（调用set方法）
第三步：初始化Bean（调用Bean的init方法，这个init方法需要自己写，自己配）
第四步：使用Bean
第五步：销毁Bean（调用Bean的destroy方法，这个destroy方法需要自己写，自己配）

创建一个Bean类：User

package com.julissa.spring.bean;

/**
 * bean类
 */
public class User {
    //bean对象属性
    private String name;
    //无参构造方法
    public User() {
        System.out.println("第一步：调用无参构造方法");
    }
    //set方法
    public void setName(String name) {
        System.out.println("第二步：调用set方法");
        this.name = name;
    }
    //init方法
    public void initBean(){
        System.out.println("第三步：调用init方法");
    }
    //destroy方法
    public void destroyBean(){
        System.out.println("第五步：调用destroy方法");
    }
}

配置beans.xml

<?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">

    <!-- 配置User -->
    <!-- init-method 属性指定init方法 -->
    <!-- destroy-method 属性指定destroy方法 -->
    <bean id="user" class="com.julissa.spring.bean.User" init-method="initBean" destroy-method="destroyBean">
       <property name="name" value="julissa"/>
    </bean>
</beans>

编写测试程序

@Test
public void test5(){
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
    User user = applicationContext.getBean("user", User.class);
    System.out.println("第四步：使用Bean  " + user);

    //注意：必须手动关闭spring容器，这样才会销毁bean对象
    ClassPathXmlApplicationContext context = (ClassPathXmlApplicationContext) applicationContext;
    context.close();
}

运行测试程序

需要注意的：

第一：只有正常关闭spring容器，bean的销毁方法才会被调用。
第二：ClassPathXmlApplicationContext类才有close()方法。
第三：配置文件中的init-method指定初始化方法。destroy-method指定销毁方法。

4. Bean的生命周期之7步

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

Bean生命周期可以粗略的划分为七步：

第一步：实例化Bean（调用无参构造方法）
第二步：Bean属性赋值（调用set方法）
第三步：执行“Bean处理器”的before方法
第四步：初始化Bean（调用Bean的init方法，这个init方法需要自己写，自己配）
第五步：执行“Bean处理器”的after方法
第六步：使用Bean
第七步：销毁Bean（调用Bean的destroy方法，这个destroy方法需要自己写，自己配）

在上一节的程序基础上，编写一个类实现BeanPostProcessor类，并且重写before和after方法：

package com.julissa.spring.bean;

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

public class BeanProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) {
        System.out.println("3.Bean后处理器的before方法执行，即将开始初始化");
        return bean;
    }
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        System.out.println("5.Bean后处理器的after方法执行，已完成初始化");
        return bean;
    }
}

修改User类

package com.julissa.spring.bean;

/**
 * bean类
 */
public class User {
    //bean对象属性
    private String name;
    //无参构造方法
    public User() {
        System.out.println("1.调用无参构造方法");
    }
    //set方法
    public void setName(String name) {
        System.out.println("2.调用set方法");
        this.name = name;
    }
    //init方法
    public void initBean(){
        System.out.println("4.调用init方法");
    }
    //destroy方法
    public void destroyBean(){
        System.out.println("7.调用destroy方法");
    }
}

配置beans.xml

<?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后处理器。这个后处理器将作用于当前配置文件中所有的bean。-->
    <bean id="beanProcessor" class="com.julissa.spring.bean.BeanProcessor"/>

    <!-- 配置User -->
    <!-- init-method 属性指定init方法 -->
    <!-- destroy-method 属性指定destroy方法 -->
    <bean id="user" class="com.julissa.spring.bean.User" init-method="initBean" destroy-method="destroyBean">
       <property name="name" value="julissa"/>
    </bean>
</beans>

一定要注意：在spring.xml文件中配置的Bean后处理器将作用于当前配置文件中所有的Bean。

运行测试程序

5. Bean的生命周期之10步

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

上图中检查Bean是否实现了Aware的相关接口是什么意思？

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类，让User实现上面五个接口

package com.julissa.spring.bean;

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

/**
 * bean类
 */
public class User implements BeanNameAware,BeanClassLoaderAware, BeanFactoryAware,InitializingBean,DisposableBean{
    //bean对象属性
    private String name;
    //无参构造方法
    public User() {
        System.out.println("1.调用无参构造方法");
    }
    //set方法
    public void setName(String name) {
        System.out.println("2.调用set方法");
        this.name = name;
    }
    //init方法
    public void initBean(){
        System.out.println("6.调用init方法");
    }
    //destroy方法
    public void destroyBean(){
        System.out.println("10.调用destroy方法");
    }

    @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处理器

package com.julissa.spring.bean;

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

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

修改测试程序

@Test
public void test5(){
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
    User user = applicationContext.getBean("user", User.class);
    System.out.println("8.使用Bean  " + user);

    //注意：必须手动关闭spring容器，这样才会销毁bean对象
    ClassPathXmlApplicationContext context = (ClassPathXmlApplicationContext) applicationContext;
    context.close();
}

运行测试程序

通过测试可以看出来：

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

对于SpringBean的生命周期，掌握之前的7步即可。够用。

6. Bean的作用域不同，管理方式不同

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

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

把之前User类的beans.xml文件中的配置scope设置为prototype：

<?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后处理器。这个后处理器将作用于当前配置文件中所有的bean。-->
    <bean id="beanProcessor" class="com.julissa.spring.bean.BeanProcessor"/>

    <!-- 配置User -->
    <!-- init-method 属性指定init方法 -->
    <!-- destroy-method 属性指定destroy方法 -->
    <bean id="user" class="com.julissa.spring.bean.User" init-method="initBean" destroy-method="destroyBean" scope="prototype">
       <property name="name" value="julissa"/>
    </bean>
</beans>

运行测试程序

只执行了前8步，第9和10都没有执行。

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

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

第一步：创建Student类

package com.julissa.spring.bean;

public class Student {
}

第二步：将new出来的Student对象交给Spring管理

@Test
public void test6(){
    // 自己new的对象
    Student student = new Student();
    System.out.println(student);

    // 创建 默认可列表BeanFactory 对象
    DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
    // 注册Bean
    factory.registerSingleton("student",student);
    //从Spring容器中获取bean
    Object student1 = factory.getBean("student");
    System.out.println(student1);
}

第三步：运行测试程序

Julissa.

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring6 - （09） Bean 的生命周期

Spring其实就是一个管理Bean对象的工厂。它负责对象的创建，对象的销毁等。所谓的生命周期就是：对象从创建开始到最终销毁的整个过程。对应Bean的生命周期，我们需要掌握以下几点：- 什么时候创建Bean对象？- 创建Bean对象的前后会调用什么方法？- Bean对象什么时候销毁？- Bean对象的销毁前后调用什么方法？
复制链接

扫一扫