08-Spring中对象的生命周期（Bean的声明周期）

最新推荐文章于 2024-07-05 19:32:54 发布
最新推荐文章于 2024-07-05 19:32:54 发布
阅读量1.3w 收藏
点赞数
分类专栏： Spring 文章标签： spring bean生命周期
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fsjwin/article/details/109427737
版权

上一篇：07-Spring对象的创建次数 singleton|prototype https://blog.csdn.net/fsjwin/article/details/109427054

对象均有声明生命，而spring对对象的创建生命周期有spring控制，我们有必要其探究其对对象声明周期的创建，更有利于我们更为微观的掌握spring
生命周期：对象的创建、存活、消亡全过程

声明周期分为三个阶段

  • 创建
  • 初始化
  • 销毁

1.对象创建

Product.java代码交代

package base.lifecycle;

/**
 * @author yuhl
 * @Date 2020/11/1 15:18
 * @Classname Product
 * @Description 对象生命周期
 */
public class Product {
    String name;
    Double price;

    public Product() {
        System.out.println("*****************Product.Product");
    }

    public Product(String name, Double price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Double getPrice() {
        return price;
    }

    public void setPrice(Double price) {
        this.price = price;
    }
}

1.1单例模式对象的创建

  1. 配置文件
<!--生命周期-->
    <bean id="product" class="base.lifecycle.Product"/>
  1. 测试
@Test
    public void test16() {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("/applicationContext.xml");
    }
  1. 结果
*****************Product.Product

说明单例模式下，在创建工厂时创建了对象。调用了构造函数。

1.2非单例模式对象的创建

配置文件：

<!--生命周期-->
    <bean id="product" class="base.lifecycle.Product" scope="prototype"/>

测试：

 @Test
    public void test16() {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("/applicationContext.xml");
    }

结果：
在创建工厂的时候没有创建对象。

但是可以在获得对象的时候创建对象
测试：

 @Test
    public void test16() {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("/applicationContext.xml");
        Product product = (Product) ctx.getBean("product");
        //System.out.println(product);
        /*Account account2 = (Account) ctx.getBean("account");
        System.out.println(account1);
        System.out.println(account2);*/

    }

此时的结果为：

*****************Product.Product

说明在获得对象的时候创建了对象，而不是在创建工厂的时候创建的。

1.3单例模式对象的创建延时加载

那么单例模式可否不让其在创建工厂的时候创建对象呢？让他在获得对象的时候创建？可以的使用 lazy-init=“true”。
配置文件：

 <!--生命周期-->
    <bean id="product" class="base.lifecycle.Product" lazy-init="true"/>

测试：

 @Test
    public void test16() {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("/applicationContext.xml");
       // Product product = (Product) ctx.getBean("product");
        //System.out.println(product);
        /*Account account2 = (Account) ctx.getBean("account");
        System.out.println(account1);
        System.out.println(account2);*/

    }

结果：未调用构造器
在获取的再次测试：

@Test
    public void test16() {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("/applicationContext.xml");
       Product product = (Product) ctx.getBean("product");
        //System.out.println(product);
        /*Account account2 = (Account) ctx.getBean("account");
        System.out.println(account1);
        System.out.println(account2);*/

    }

结果：

*****************Product.Product

最终结论：在默认单例模式下，可以使用lazy-init="true"来延时加创建对象，待到真正使用的时候再去创建。

2.对象初始化

初始化就是spring给程序员以及机会，让我们有机会再对象创建完成后写一些自己的逻辑代码，比如多资源初始化、数据库、io网络等（但是实际开发中很少使用）。也就是说这个初始化方法我们程序员来定义，但是有spring框架去执行。

这里有两种写初始化的方法

2.1第一种：实现接口，重写方法

实现implements InitializingBean接口，重写：afterPropertiesSet（）方法

  1. 看代码：
package base.lifecycle;

import org.springframework.beans.factory.InitializingBean;

/**
 * @author yuhl
 * @Date 2020/11/1 15:18
 * @Classname Product
 * @Description 对象生命周期
 */
public class Product implements InitializingBean {
    String name;
    Double price;

    public Product() {
        System.out.println("*****************Product.Product");
    }

    public Product(String name, Double price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Double getPrice() {
        return price;
    }

    public void setPrice(Double price) {
        this.price = price;
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("Product.afterPropertiesSet");
    }
}
  1. 配置文件：
    <bean id="product" class="base.lifecycle.Product"/>
  1. 测试：
 @Test
    public void test17() {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("/applicationContext.xml");
    }
  1. 结果：
*****************Product.Product
Product.afterPropertiesSet

说明在初始化后调用了Product.afterPropertiesSet（）方法

2.2第二种：自定义初始化方法，然后通过通配置文件告诉spring是那个方法

不实现spring提供的类，自定义一个初始化方法myInit()然后在配置文件中告诉spring即可。

  1. 实体类代码
package base.lifecycle;

import org.springframework.beans.factory.InitializingBean;

/**
 * @author yuhl
 * @Date 2020/11/1 15:18
 * @Classname Product
 * @Description 对象生命周期
 */
//public class Product implements InitializingBean {
public class Product  {
    String name;
    Double price;

    public Product() {
        System.out.println("*****************Product.Product");
    }

    public Product(String name, Double price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Double getPrice() {
        return price;
    }

    public void setPrice(Double price) {
        this.price = price;
    }

   /* @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("Product.afterPropertiesSet");
    }*/

    /**
     * 自定义的init方法，不在实现接口
     * @throws Exception
     */
    public void myInit() throws Exception {
        System.out.println("Product.myInit");
    }
}
  1. 配置文件：
<bean id="product" class="base.lifecycle.Product" init-method="myInit"/>

注意此处的init-method=“myInit”

  1. 运行结果：
*****************Product.Product
Product.myInit

2.3上面两个方式均调用了初始化方法，如果均有，则调用先后顺序怎样？

  1. 类代码：
package base.lifecycle;

import org.springframework.beans.factory.InitializingBean;

/**
 * @author yuhl
 * @Date 2020/11/1 15:18
 * @Classname Product
 * @Description 对象生命周期
 */
public class Product implements InitializingBean {
//public class Product  {
    String name;
    Double price;

    public Product() {
        System.out.println("*****************Product.Product");
    }

    public Product(String name, Double price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Double getPrice() {
        return price;
    }

    public void setPrice(Double price) {
        this.price = price;
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("Product.afterPropertiesSet");
    }

    /**
     * 自定义的init方法，不在实现接口
     * @throws Exception
     */
    public void myInit() throws Exception {
        System.out.println("Product.myInit");
    }
}
  1. 配置文件
<bean id="product" class="base.lifecycle.Product" init-method="myInit"/>
  1. 测试
*****************Product.Product
Product.afterPropertiesSet
Product.myInit
  1. 结论
    先调用afterPropertiesSet（） 再调用myInit（）方法。

2.4如果再加上对成员变量的注入，则先后顺序怎样呢？

先给出结论，afterPropertiesSet（） 从方法明上也能看出，实在propertie set之后diay9ong的，即，先setter注入，然后afterPropertiesSet（） 再调用myInit（）方法。
证明：

  1. Product.java对setter方法添加打印日志
package base.lifecycle;

import org.springframework.beans.factory.InitializingBean;

/**
 * @author yuhl
 * @Date 2020/11/1 15:18
 * @Classname Product
 * @Description 对象生命周期
 */
public class Product implements InitializingBean {
//public class Product  {
    String name;
    Double price;

    public Product() {
        System.out.println("*****************Product.Product");
    }

    public Product(String name, Double price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        System.out.println("Product.setName");
        this.name = name;
    }

    public Double getPrice() {
        return price;
    }

    public void setPrice(Double price) {
        System.out.println("Product.setPrice");
        this.price = price;
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("Product.afterPropertiesSet");
    }

    /**
     * 自定义的init方法，不在实现接口
     * @throws Exception
     */
    public void myInit() throws Exception {
        System.out.println("Product.myInit");
    }
}
  1. 测试据结果：
*****************Product.Product
Product.setName
Product.setPrice
Product.afterPropertiesSet
Product.myInit

印证了结论。

3.对象销毁

  • 销毁和初始化一样可以实现接口DisposableBean重写destroy（）方法，或者自定义销毁方法Mydestroy() ，通过配置文件告诉spring。
  • 那么在什么时候会调用这个销毁方法呢？在ClassPathXmlApplicationContext.close()的时候会调用销毁方法。
  • 注意因为ApplicationContext类中没有close()方法，所以需要声明为ClassPathXmlApplicationContext类，在嗲用close方法的时候先调用重写的销毁方法，还是先调用自己手写的销毁方法呢？
    先给出答案，现代用spring的方法，再调用自己重写的销毁方法。
  1. 查看Product.java 实现这个接口：DisposableBean
package base.lifecycle;

import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;

/**
 * @author yuhl
 * @Date 2020/11/1 15:18
 * @Classname Product
 * @Description 对象生命周期
 */
public class Product implements InitializingBean , DisposableBean {
//public class Product  {
    String name;
    Double price;

    public Product() {
        System.out.println("*****************Product.Product");
    }

    public Product(String name, Double price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        System.out.println("Product.setName");
        this.name = name;
    }

    public Double getPrice() {
        return price;
    }

    public void setPrice(Double price) {
        System.out.println("Product.setPrice");
        this.price = price;
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("Product.afterPropertiesSet");
    }

    /**
     * 自定义的init方法，不在实现接口
     * @throws Exception
     */
    public void myInit() throws Exception {
        System.out.println("Product.myInit");
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("Product.destroy");
    }

    public void Mydestroy() throws Exception {
        System.out.println("Product.Mydestroy");
    }
}
  1. 配置文件
<!--生命周期-->
    <bean id="product" class="base.lifecycle.Product" init-method="myInit" destroy-method="Mydestroy" scope="singleton">
        <property name="name" value="张三"/>
        <property name="price" value="5.00"/>
    </bean>
  1. 测试
@Test
    public void test18() {
        ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("/applicationContext.xml");
        ctx.close();
    }
  1. 测试结果
*****************Product.Product
Product.setName
Product.setPrice
Product.afterPropertiesSet
Product.myInit
2020-11-01 20:05:48 DEBUG ClassPathXmlApplicationContext:987 - Closing org.springframework.context.support.ClassPathXmlApplicationContext@2d6a9952, started on Sun Nov 01 20:05:48 CST 2020
Product.destroy
Product.Mydestroy

从这个结果可看出先调用springg的销毁方法，再调用自定义的方法。
5. 注意：对于销毁的方法，仅对于singleton对象有效，对于prototype无效，因为prototype对象有jvm控制其销毁过程spring生命周期不管他。

4.总结

通过上面的分析我们知道spring对象的声明周期分为三个阶段

  • 创建
  • 初始化
  • 销毁
    具体调用的方法如下图。便于记忆和理解。
    在这里插入图片描述

由来这幅图，妈妈再也不用担心我记不住bean的声明周期了。哈哈哈！

下一篇：09-Spring配置文件参数化，抽取properties文件https://blog.csdn.net/fsjwin/article/details/109440615

前路无畏
关注
专栏目录
Spring系列- - -spring bean生命周期
退役复学在校大学生，目光所至，皆为华夏
09-17 7265
再次渡入繁世，人潮汹涌，眼里茫然，信仰永恒，皆为华夏 目录Spring篇11、解释一下spring bean的生命周期12、解释Spring支持的几种bean的作用域？ 本期分享到此为止，关注博主不迷路，叶秋学长带你上高速~~首先说一下Servlet的生命周期：实例化，初始init，接收请求service，销毁destroy；Spring上下文中的Bean生命周期也类似，如下：（1）实例化Bean：对于BeanFactory容器，当客户向容器请求一个尚未初始化的bean时，或初始化bean的时候需要注入
spring bean的生命周期
01-16
Spring Bean的生命周期是Spring框架中的核心概念，它涵盖了Bean从创建到销毁的全过程。了解这一过程对于优化应用程序的性能和管理资源至关重要。在Spring中，Bean的生命周期主要分为以下几个阶段： 1. **初始化阶段...
Spring对象生命周期
12-22
一、spring对象生命周期 首先创建一个UserInfo类，其中包含属性name，无参构造方法，静态与非静态构造方法，get和set方法，init和destroy方法，并且每一个方法都有相应的输出： package club.affengkuang.vo; public class UserInfo { private String name; public UserInfo() { System.out.println("构造方法"); } { System.out.println("非静态代码块"); } static { System.out.println(
java对象声明周期
HEAT
05-18 254
JVM中对象的生命周期 在JVM运行空间中，对象的整个生命周期大致可以分为7个阶段：创建阶段（Creation）、应用阶段（Using）、不可视阶段 （Invisible）、不可到达阶段（Unreachable）、可收集阶段（Collected）、终结阶段（Finalized）与释放阶段 （Free）。上面的这7个阶段，构成了JVM中对象的完整的生命周期。下面分别介绍对象在处于这7个阶段时的...
Spring 对象的生命周期管理
最新发布
qq_31532979的博客
07-05 771
Spring框架提供了一种强大的对象生命周期管理机制，通过其核心组件——IoC（控制反转）容器，来管理对象的创建、配置和使用。Spring容器不仅能够自动管理对象之间的依赖关系，还能在适当的时机调用对象的生命周期方法，从而简化了对象的管理和维护。
spring对象生命周期
文盲青年的博客
08-26 182
https://www.jianshu.com/p/d1dfdb240617
spring中bean的生命周期详解
08-26
"Spring中Bean的生命周期详解" Spring框架是当前Java EE开发中最流行的框架之一，Spring框架中Bean的生命周期是指从创建到销毁的整个过程。在这个过程中，Spring IOC容器对Bean的生命周期进行管理，使得开发者可以...
谈谈我对Spring Bean 生命周期的理解
08-27
Spring Bean 生命周期是 Spring 框架中的一个核心概念，了解 Spring Bean 的生命周期对我们了解整个 Spring 框架会有很大的帮助。本文将详细介绍 Spring Bean 生命周期的概念、生命周期图、生命周期阶段、生命周期...
详解Spring中Bean的生命周期和作用域及实现方式
08-31
Spring中Bean的生命周期和作用域及实现方式 Spring是一个非常流行的Java应用程序框架，它提供了一个灵活的机制来管理Bean的生命周期和作用域。Bean的生命周期和作用域是Spring框架中两个非常重要的概念，它们决定了...
Spring对象的生命周期
梦想也许遥不可及，但重要的是追梦的过程，用博客记录自己的成长，记录自己一步一步向上攀登的印记
04-21 1963
对象的生命周期1.对象的生命周期的定义2.为什么要学习对象的生命周期3.生命周期的三个阶段3.1创建阶段3.2初始化阶段3.3销毁阶段 对象的生命周期 1.对象的生命周期的定义 对象的生命周期指的是一个对象的创建、存活、消亡的一个完整过程 2.为什么要学习对象的生命周期 以前我们写代码的时候，都是自己来new对象 User user=new User(); 当对象被虚拟机的垃圾回收机制回收，它就销毁了 但是现在是由Spring来复杂对象的创建、存活、销毁，了解生命周期，有利于我们使用好Spring为我们创.
spring之对象的生命周期
weixin_41377877的博客
04-09 721
1、什么是对象的生命周期？ - 指的是一个对象的创建、存活、消亡的一个完整的过程。 由Spring负责对象的创建、存活、销毁，了解生命周期，有利于我们使用好Spring为我们创建的对象 2、生命周期的三个阶段： - 创建阶段： - scope="singlenton " Spring工厂创建的同时，对象的创建 注意：设置scope="singlenton" 这种情况下，也需要在获取对象的同时，创建对象 <bean lazy-init="true"> 懒加载 ...
Spring中，对象的生命周期
Liuxiaoyang1999的博客
02-25 387
为验证，我们写一个类，包括如下几个元素： public class UserInfo { static { System.out.println("静态代码块"); } { System.out.println("非静态代码块"); } private String name; public UserInfo() { System.out.println...
Java-spring对象生命周期
WangLi1201的博客
09-17 440
包括bean的生命周期、解除循环依赖方法和构造器注入的选择
【Spring】详述spring对象生命周期
Kp_2000的博客
03-15 292
<bean id = "userInfo" class="com.jd.vo.UserInfo" lazy-init="true" scope="singleton" init-method="init" destroy-method="destroy"> Spring对象（bean）的生命周期： 静态代码块——非静态代码块——构造方法——setter方法——init方法——dest...
【Spring】对象的生命周期（创建、初始化、销毁）
See_Star的博客
09-11 2717
文章目录一、生命周期二、创建阶段三、初始化阶段3.1 InitializingBean接口3.2 配置init-method3.3 分析四、销毁阶段4.1 DisposableBean 接口：4.2 配置 destroy-method五、总结 一、生命周期 什么是对象的生命周期？ ⼀个对象创建、存活、消亡的⼀个完整过程。 为什么要学习对象的生命周期？ 由 Spring 负责对象的创建、存活、销毁，了解生命周期，有利于我们使用好 Spring 为我们创建的对象。 生命周期的 3 个阶段： 创建阶段
深入理解Spring Bean生命周期及其实现
Spring中的Bean遵循特定的步骤，类似于其他编程环境中的对象生命周期管理。 1. **Bean的创建**：首先，Spring容器（如BeanFactory或ApplicationContext）根据配置文件或注解自动创建Bean实例。在这个阶段，实现了`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值