Bean的生命周期

最新推荐文章于 2024-06-17 09:11:23 发布
最新推荐文章于 2024-06-17 09:11:23 发布
阅读量124 收藏
点赞数
分类专栏： JavaEE 文章标签： java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CXYCMY/article/details/127868486
版权

Bean的生命周期

1、 什么是Bean的生命周期

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

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

什么时候创建Bean对象？

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

Bean对象什么时候销毁？

Bean对象的销毁前后调用什么方法？

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

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

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

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

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

3、Bean的生命周期之5步

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

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

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

img

编写测试程序：

定义一个Bean

package com.powernode.spring6.bean;

/**
 * @author 动力节点
 * @version 1.0
 * @className User
 * @since 1.0
 **/
public class User {
    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("3.初始化Bean");
    }

    public void destroyBean(){
        System.out.println("5.销毁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">

    <!--
    init-method属性指定初始化方法。
    destroy-method属性指定销毁方法。
    -->
    <bean id="userBean" class="com.powernode.spring6.bean.User" init-method="initBean" destroy-method="destroyBean">
        <property name="name" value="zhangsan"/>
    </bean>

</beans>
package com.powernode.spring6.test;

import com.powernode.spring6.bean.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @author 动力节点
 * @version 1.0
 * @className BeanLifecycleTest
 * @since 1.0
 **/
public class BeanLifecycleTest {
    @Test
    public void testLifecycle(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
        User userBean = applicationContext.getBean("userBean", User.class);
        System.out.println("4.使用Bean");
        // 只有正常关闭spring容器才会执行销毁方法
        ClassPathXmlApplicationContext context = (ClassPathXmlApplicationContext) applicationContext;
        context.close();
    }
}

执行结果：

img

需要注意的：

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

4、Bean生命周期之7步

在以上的5步中，第3步是初始化Bean

如果你还想在初始化前和初始化后添加代码，可以加入“Bean后处理器”。

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

注意，在jdk8中，BeanPostProcessor中的before方法和after方法被修改为default方法了，不需要重写，这里重写只是为了更加明确的知道bean的生命周期的具体步骤

BeanPostProcessor的源码

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package org.springframework.beans.factory.config;

import org.springframework.beans.BeansException;
import org.springframework.lang.Nullable;

//Nullable表示可空的

public interface BeanPostProcessor {
    @Nullable
    default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }

    @Nullable
    default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }
}

具体的代码实现步骤：

package com.cxy.spring6.lifecycle.bean;

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

/**
 * @Title: LogPostProcesstor
 * @Package com.cxy.spring6.lifecycle.bean
 * @Author: CXY
 * @Copyright CXY
 * @CreateTime: 2022/11/15 16:12
 */

public class LogPostProcesstor implements BeanPostProcessor{
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("执行了before方法");
        return BeanPostProcessor.super.postProcessBeforeInitialization(bean, beanName);
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("执行了after方法");
        return BeanPostProcessor.super.postProcessAfterInitialization(bean, beanName);
    }
}

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

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

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

执行测试程序：

img

如果加上Bean后处理器的话，Bean的生命周期就是7步了：

img

5、 Bean生命周期之10步

如果根据源码跟踪，可以划分更细粒度的步骤，10步：

img

上图中检查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

代码如下：

package com.powernode.spring6.bean;

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

/**
 * @author 动力节点
 * @version 1.0
 * @className User
 * @since 1.0
 **/
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执行");
    }
}
package com.powernode.spring6.bean;

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

/**
 * @author 动力节点
 * @version 1.0
 * @className LogBeanPostProcessor
 * @since 1.0
 **/
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;
    }
}

执行结果：

img

通过测试可以看出来：

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

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

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

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

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

我们把之前User类的spring.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">

    <!--
    init-method属性指定初始化方法。
    destroy-method属性指定销毁方法。
    -->
    <bean id="userBean" class="com.powernode.spring6.bean.User" init-method="initBean" destroy-method="destroyBean" scope="prototype">
        <property name="name" value="zhangsan"/>
    </bean>

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

</beans>

执行测试程序：

img

通过测试一目了然。只执行了前8步，第9和10都没有执行。

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

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

package com.powernode.spring6.bean;

/**
 * @author 动力节点
 * @version 1.0
 * @className User
 * @since 1.0
 **/
public class User {
}
package com.powernode.spring6.test;

import com.powernode.spring6.bean.User;
import org.junit.Test;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;

/**
 * @author 动力节点
 * @version 1.0
 * @className RegisterBeanTest
 * @since 1.0
 **/
public class RegisterBeanTest {

    @Test
    public void testBeanRegister(){
        // 自己new的对象
        User user = new User();
        System.out.println(user);

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

执行结果：

img

以上内容均来自于动力节点老杜的spring6的课程笔记
b站动力节点老杜spring6之Bean的生命周期

CXYCMY
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
谈谈我对Spring Bean 生命周期的理解
08-27
本文将详细介绍 Spring Bean 生命周期的概念、生命周期图、生命周期阶段、生命周期管理方式等相关知识点。 一、 Spring Bean 生命周期概述 Spring Bean 生命周期是指 Spring 容器中 Bean 的创建、初始化、销毁等...
bean的生命周期（最全最细讲解）
热门推荐
a910247的博客
06-14 4万+
其定义为：从对象的创建到销毁的过程。而Spring中的一个Bean从开始到结束经历很多过程，但总体可以分为六个阶段Bean定义、实例化、属性赋值、初始化、生存期、销毁。 2.SpringBean生命周期中的增强接口PostProcessor；postProcessBeforeInitialization方法执行前，会执行很多Aware类型的接口，这种类型接口作用是加载资源到Spring容器中。我们在创建一个MyBeanPost的类来实现BeanPostProcessor接口。 ​ ......
【Spring6】| Bean的生命周期（五步、七步、十步法剖析）
m0_61933976的博客
03-13 1万+
【Spring6】| Bean的生命周期（五步、七步、十步法剖析）
11、Spring之Bean生命周期~依赖注入（2）
最新发布
sproutBoy的博客
06-17 1390
11、Spring之Bean生命周期~依赖注入（2）依赖注入查找注入点对注入点进行赋值InjectionMetadata.inject()方法AutowiredFieldElement.inject()方法resolveFieldValue()方法resolveDependency方法createOptionalDependency()方法doResolveDependency()方法determineAutowireCandidate()方法resolveMultipleBeans()方法findAuto
spring bean的生命周期
weixin_34143774的博客
05-15 847
spring bean的生命周期 （1）实例化Bean： 对于BeanFactory容器，当客户向容器请求一个尚未初始化的bean时，或初始化bean的时候需要注入另一个尚未初始化的依赖时，容器就会调用createBean进行实例化。对于ApplicationContext容器，当容器启动结束后，通过获取BeanDefinition对象中的信息，实例化所有的bean。 （2）设置对象属性（依...
Bean 的生命周期总结
qq_62274623的博客
09-09 6812
Java 中的公共类称之为 Bean 或 Java Bean，而 Spring 中的 Bean 指的是将对象的生命周期，交个 Spring IoC 容器来管理的对象。所以 Spring 中的 Bean 对象在使用时，无需通过 new 来创建对象，只需要通过 DI（依赖注入），从 Spring 中取出要使用的对象即可。因为初始化的前置方法和后置方法是为所有 Bean 服务的，而非为某一个 Bean 服务的，所以这两个方法不能写在某个具体的 Bean 中，否则（这两个方法）不会执行。
浅谈Spring bean 生命周期验证
08-29
浅谈Spring bean 生命周期验证 Spring bean 生命周期验证是 Spring 框架中一个非常重要的概念，它描述了 bean 从创建到销毁的整个生命周期。了解 Spring bean 生命周期可以帮助开发者更好地理解 Spring 框架，并...
Spring bean生命周期配置过程解析
08-24
在Spring框架中，Bean的生命周期管理是其核心功能之一，它允许开发者控制Bean从创建到销毁的整个过程。本文将详细解析Spring Bean的生命周期配置过程。 首先，Bean的生命周期始于实例化。当Spring容器...
Spring bean生命周期demo
07-14
接下来，我们将深入探讨Spring Bean生命周期的各个阶段，并通过具体的示例来演示。 1. **配置阶段** 在Spring容器初始化时，它会读取配置文件（如XML或Java配置），解析Bean定义，包括其依赖关系、初始化方法、...
spring 中的IOC 操作 Bean 管理（bean 生命周期）
qq_34709784的博客
10-04 354
1、生命周期 （1）从对象创建到对象销毁的过程 2、bean 生命周期 （1）通过构造器创建 bean 实例（无参数构造） （2）为 bean 的属性设置值和对其他 bean 引用（调用 set 方法） （3）调用 bean 的初始化的方法（需要进行配置初始化的方法） （4）bean 可以使用了（对象获取到了） （5）当容器关闭时候，调用 bean 的销毁的方法（需要进行配置销毁的方法） 3、演示 bean 生命周期 package net.cybclass.sp.d
7、Bean的生命周期
qq_67720621的博客
11-11 3717
7、Bean的生命周期
JavaBean生命周期七个过程:
m0_70441480的博客
08-23 843
在JavaBean终止阶段完成后，容器将JavaBean的实例释放回给JVM，以便回收由JavaBean实例占用的内存资源。举例来说，通常情况下，一个JavaBean中可能会有多个属性和方法，如果这些方法或属性被错误地使用或设置，会导致JavaBean出现一些不可预见的问题。这个阶段是在容器中创建JavaBean的实例，并调用JavaBean的构造方法，将JavaBean实例化。一旦JavaBean被实例化，容器会开始设置JavaBean的属性，也就是调用JavaBean的set方法。
Spring中Bean的生命周期（五步）（七步）（十步）
refreshh的博客
01-29 2009
【代码】Spring中Bean的生命周期（五步）（七步）（十步）
深入理解 Java Bean 的生命周期及各个阶段解析
st200112266的博客
08-01 1万+
Java Bean是一个符合特定规范的Java类，通常具有私有的成员变量、公共的getter和setter方法，以及一个无参构造函数。这些特性使得Bean对象易于序列化和反序列化，并且被广泛应用于Java开发中，尤其在框架和应用程序中经常被用作数据封装和组件复用。创建阶段：当使用构造函数或者工厂方法创建Bean对象时，就进入了创建阶段。属性设置阶段：在Bean对象创建后，通过setter方法设置Bean的各个属性。
去字节面试，直接让人出门左拐：Bean 生命周期都不知道！
Candyz7的博客
09-06 1212
IoC，控制反转，想必大家都知道，所谓的控制反转，就是把 new 对象的权利交给容器，所有的对象都被容器控制，这就叫所谓的控制反转。IoC 很好地体现了面向对象设计法则之一 —— 好莱坞法则：“别找我们，我们找你”，即由 IoC 容器帮对象找相应的依赖对象并注入，而不是由对象主动去找。理解好 IoC 的关键是要明确 “谁控制谁，控制什么，为何是反转（有反转就应该有正转了），哪些方面反转了”。谁控制谁，控制什么？
Spring 中bean 生命周期过程中的各种接口
sushuiyuzhou的专栏
09-09 1438
Spring 中bean 的生命周期短暂吗? 在spring中，从BeanFactory或ApplicationContext取得的实例为Singleton，也就是预设为每一个Bean的别名只能维持一个实例，而不是每次都产生一个新的对象使用Singleton模式产生单一实例，对单线程的程序说并不会有什么问题，但对于多线程的程序，就必须注意安全(Thread-safe)的议题，防止多个线程同时存取共享资源所引发的数据不同步问题。 然而在spring中 可以设定每次从BeanFactory或Applicat
bean生命周期源码
08-29
下面是简化的Bean生命周期源码示例： ```java public class BeanLifecycle { // 构造函数 public BeanLifecycle() { System.out.println("1. BeanLifecycle构造函数"); } // 初始化方法 public void init...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值