Spring-bean的生命周期

最新推荐文章于 2024-06-14 10:17:52 发布
最新推荐文章于 2024-06-14 10:17:52 发布
阅读量1.4k 收藏 51
点赞数 25
分类专栏： Spring 文章标签： spring java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53149124/article/details/132481546
版权

文章目录

初始化和销毁回调

在bean交由spring管理的过程中，bean从初始化到销毁之间经历许多过程，其中初始化回调方法会在bean实例化之后，属性赋值（set方法执行)之前被调用；销毁回调方法会在bean即将被销毁之前调用，可以在销毁回调中做一些资源的释放工作。

InitializingBean和DisposableBean接口

public interface InitializingBean {
	//属性初始化之前被调用
	void afterPropertiesSet() throws Exception;

}

public interface DisposableBean {
	//销毁bean之前被调用
	void destroy() throws Exception;

}

实现InitializingBean的bean，会在属性初始化之前被调用，实现DisposableBean的bean，会在bean即将被销毁时调用。

演示

@Component
public class InitAndDestroyBean implements InitializingBean, DisposableBean {
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("InitAndDestroyBean初始化...");
    }

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

@Configuration
@ComponentScan("com.vm")
public class SpringConfig {

}

public class InitAndDestroyBeanTest {
    public static ApplicationContext app;
    @BeforeClass
    public static void before(){
        app = new AnnotationConfigApplicationContext(SpringConfig.class);
    }
    @AfterClass
    public static void after(){
        if (app instanceof AbstractApplicationContext)
            ((AbstractApplicationContext)app).close();//关闭容器
    }

    @Test
    public void test(){
        InitAndDestroyBean bean = app.getBean(InitAndDestroyBean.class);
        System.out.println(bean);
    }
}

在这里插入图片描述

@PostConstruct和@PreDestroy注解

@Documented
@Retention (RUNTIME)
@Target(METHOD)
public @interface PostConstruct {
}

@Documented
@Retention (RUNTIME)
@Target(METHOD)
public @interface PreDestroy {
}

被@PostConstruct标注的方法将会被当初初始化回调，被@PreDestroy标注的方法将会被作为销毁回调执行。

演示

@Component
public class InitAndDestroyBean2 {
    @PostConstruct
    public void initMethod(){
        System.out.println("InitAndDestroyBean2初始化...");
    }

    @PreDestroy
    public void destoryMethod(){
        System.out.println("InitAndDestroyBean2销毁...");
    }
}

public class InitAndDestroyBeanTest {
    public static ApplicationContext app;
    @BeforeClass
    public static void before(){
        app = new AnnotationConfigApplicationContext(SpringConfig.class);
    }
    @AfterClass
    public static void after(){
        if (app instanceof AbstractApplicationContext)
            ((AbstractApplicationContext)app).close();//关闭容器
    }

    @Test
    public void test(){
        InitAndDestroyBean2 bean = app.getBean(InitAndDestroyBean2.class);
        System.out.println(bean);
    }
}

在这里插入图片描述

手动配置初始化和销毁回调

使用java配置类或xml配置一个bean到容器时，可以为这个bean指定初始化和调回的回调方法。如下：

public class InitAndDestroyBean3 {
    public void initMethod(){
        System.out.println("InitAndDestroyBean3初始化...");
    }

    public void destoryMethod(){
        System.out.println("InitAndDestroyBean3销毁...");
    }
}

使用Java配置类注入容器，配置如下

@Configuration
@ComponentScan("com.vm")
public class SpringConfig {

    @Bean(initMethod = "initMethod",destroyMethod = "destoryMethod")
    public InitAndDestroyBean3 getInitAndDestroyBean3(){
        return new InitAndDestroyBean3();
    }
}

initMethod 属性指定一个初始化回调的方法名，destroyMethod 指定一个销毁回调方法。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"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
    <context:component-scan base-package="com.vm"/>

    <bean id="initAndDestroyBean3" class="com.vm.pojo.InitAndDestroyBean3" init-method="initMethod" destroy-method="destoryMethod"/>

</beans>

演示

public class InitAndDestroyBeanTest {
    public static ApplicationContext app;
    @BeforeClass
    public static void before(){
        app = new AnnotationConfigApplicationContext(SpringConfig.class);
    }
    @AfterClass
    public static void after(){
        if (app instanceof AbstractApplicationContext)
            ((AbstractApplicationContext)app).close();//关闭容器
    }

    @Test
    public void test(){
        InitAndDestroyBean3 bean = app.getBean(InitAndDestroyBean3.class);
        System.out.println(bean);
    }
}

在这里插入图片描述

执行顺序

如果一个bean同时使用上述三种方式配置，他的执行顺序如下：

注解->接口->配置

演示

public class InitAndDestroyBean4 implements InitializingBean, DisposableBean {
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("接口初始化...");
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("接口销毁...");
    }
    @PostConstruct
    public void initMethod(){
        System.out.println("注解初始化...");
    }

    @PreDestroy
    public void destoryMethod(){
        System.out.println("注解销毁...");
    }

    public void initMethod2(){
        System.out.println("配置初始化...");
    }

    public void destoryMethod2(){
        System.out.println("配置销毁...");
    }
}

@Configuration
@ComponentScan("com.vm")
public class SpringConfig {
    @Bean(initMethod = "initMethod2",destroyMethod = "destoryMethod2")
    public InitAndDestroyBean4 getInitAndDestroyBean4(){
        return new InitAndDestroyBean4();
    }
}

public class InitAndDestroyBeanTest {
    public static ApplicationContext app;
    @BeforeClass
    public static void before(){
        app = new AnnotationConfigApplicationContext(SpringConfig.class);
    }
    @AfterClass
    public static void after(){
        if (app instanceof AbstractApplicationContext)
            ((AbstractApplicationContext)app).close();//关闭容器
    }

    @Test
    public void test(){
        InitAndDestroyBean4 bean = app.getBean(InitAndDestroyBean4.class);
        System.out.println(bean);
    }
}

在这里插入图片描述

容器的启动和关闭

在容器的启动或关闭阶段，bean实现了相应的接口，可以被通知到（调用回调方法）

Lifecycle接口

public interface Lifecycle {
    void start();

    void stop();

    boolean isRunning();
}

start()方法在容器启动时被调用；stop()在容器被关闭时调用；isRunning()用来判断容器是否在运行；当isRunning()返回false时start()方法才能被执行，同理当isRunning()返回true时stop()方法才能被执行。

演示

@Component
public class LifecycleImpl implements Lifecycle {
    private boolean isRunning = false;
    @Override
    public void start() {
        System.out.println("LifecycleImpl.start...");
        isRunning = true;
    }

    @Override
    public void stop() {
        System.out.println("LifecycleImpl.stop...");
        isRunning = false;
    }

    @Override
    public boolean isRunning() {
        return isRunning;
    }
}

public class LifecycleTest {
    public static ApplicationContext app;
    @BeforeClass
    public static void before(){
        app = new AnnotationConfigApplicationContext(SpringConfig.class);
        if (app instanceof AbstractApplicationContext)
            ((AbstractApplicationContext)app).start();

    }
    @AfterClass
    public static void after(){
        if (app instanceof AbstractApplicationContext)
            ((AbstractApplicationContext)app).close();
    }

    @Test
    public void test(){
        LifecycleImpl bean = app.getBean(LifecycleImpl.class);
        System.out.println(bean);
    }
}

在这里插入图片描述
需要注意，start()和stop()方法要想被调用，必须手动调用容器的start()和close()方法，这是不智能的，大部分情况下我们希望这些方法能被自动调用。

SmartLifecycle接口

public interface SmartLifecycle extends Lifecycle, Phased {
    int DEFAULT_PHASE = 2147483647;

	/**
	*是否自动启动，当返回值为true，SmartLifecycle 的start()方法将会在容器启动时被调用，而不需要再去手动的调用容器的启动方法，反之则和Lifecycle接口类似
	*/
    default boolean isAutoStartup() {
        return true;
    }

	/**
	*该方法会在容器关闭时被调用，入参callback一定要执行一下，相当于告诉容器stop（）方法逻辑执行完毕，这个接口的默认实现调用了父接口Lifecycle的stop()方法，所以实际的逻辑也可以写在stop()方法，或者重写该方法，但是别忘记执行callback.run()
	*/
    default void stop(Runnable callback) {
        this.stop();
        callback.run();
    }

	/**
	*用于确定执行顺序
	*/
    default int getPhase() {
        return 2147483647;
    }
}

public interface Phased {
    int getPhase();
}

SmartLifecycle继承了Lifecycle接口，同时还继承了Phased ，Phased 接口的作用是当我们同时向容器中注入多个SmartLifecycle类型的bean时，能指定它们的执行顺序，数值越小，优先级越高。

演示

@Component
public class SmartLifecycleImpl implements SmartLifecycle {
    private boolean isRunning = false;

    @Override
    public void start() {
        System.out.println("SmartLifecycleImpl.start...");
        isRunning = true;
    }

    @Override
    public void stop() {
        System.out.println("SmartLifecycleImpl.stop...");
        isRunning = false;
    }

    @Override
    public boolean isRunning() {
        return isRunning;
    }

    @Override
    public int getPhase() {
        return 1;
    }
}

@Component
public class SmartLifecycleImpl2 implements SmartLifecycle {
    private boolean isRunning = false;

    @Override
    public void start() {
        System.out.println("SmartLifecycleImpl2.start...");
        isRunning = true;
    }

    @Override
    public void stop() {
        System.out.println("SmartLifecycleImpl2.stop...");
        isRunning = false;
    }

    @Override
    public boolean isRunning() {
        return isRunning;
    }

    @Override
    public int getPhase() {
        return 2;
    }
}

public class LifecycleTest {
    public static ApplicationContext app;
    @BeforeClass
    public static void before(){
        app = new AnnotationConfigApplicationContext(SpringConfig.class);
        if (app instanceof AbstractApplicationContext)
            ((AbstractApplicationContext)app).registerShutdownHook();//向JVM注册一个关闭钩子函数，程序执行完毕由JVM关闭容器，无需我们调用容器的close()方法

    }

    @Test
    public void testSmartLifecycleImpl(){
        SmartLifecycleImpl bean1 = app.getBean(SmartLifecycleImpl.class);
        SmartLifecycleImpl2 bean2 = app.getBean(SmartLifecycleImpl2.class);
        System.out.println(bean1);
        System.out.println(bean2);
    }
}

在这里插入图片描述
方法被正确的调用，并且执行顺序也正确。

LifecycleProcessor接口

public interface LifecycleProcessor extends Lifecycle {
	/**
	*容器刷新时被调用
	*/
    void onRefresh();
    
	/**
	*容器关闭时被调用
	*/
    void onClose();
}

LifecycleProcessor也继承了Lifecycle 接口，同时还扩展了两个方法。
这个接口是一个很重要的接口，SmartLifecycle和Lifecycle 接口都依赖于spring提供的一个LifecycleProcessor的默认实现类DefaultLifecycleProcessor。
SmartLifecycle和Lifecycle被调用的逻辑实际在DefaultLifecycleProcessor中，AbstractApplicationContext的部分源码如下：
在这里插入图片描述

在这里插入图片描述
从第二张图可以看出，如果我们需要向容器中注入一个自定义的LifecycleProcessor实现类替换默认的DefaultLifecycleProcessor，那么bean的名字必须叫“lifecycleProcessor”，否则只能被当作一个普通的Lifecycle 接口的实现类了。
需要注意的时，如果我们替换了默认的DefaultLifecycleProcessor，那么实现SmartLifecycle和Lifecycle的接口的bean可能不会被调用了，除非我们自定义的LifecycleProcessor实现类有类似DefaultLifecycleProcessor的逻辑。

演示

@Component("lifecycleProcessor")
public class LifecycleProcessorImpl implements LifecycleProcessor {
    private boolean isRunning = false;

    @Override
    public void onRefresh() {
        System.out.println("LifecycleProcessorImpl.onRefresh...");
        isRunning = true;
    }

    @Override
    public void onClose() {
        System.out.println("LifecycleProcessorImpl.onClose...");
        isRunning = false;
    }

    @Override
    public void start() {
        System.out.println("LifecycleProcessorImpl.start...");
        isRunning = true;
    }

    @Override
    public void stop() {
        System.out.println("LifecycleProcessorImpl.stop...");
        isRunning = false;
    }

    @Override
    public boolean isRunning() {
        return isRunning;
    }
}

public class LifecycleTest {
    public static ApplicationContext app;
    @BeforeClass
    public static void before(){
        app = new AnnotationConfigApplicationContext(SpringConfig.class);
        if (app instanceof AbstractApplicationContext)
            ((AbstractApplicationContext)app).registerShutdownHook();//向JVM注册一个关闭钩子函数，程序执行完毕由JVM关闭容器，无需我们调用容器的close()方法

    }

    @Test
    public void testLifecycleProcessorImpl(){
        LifecycleProcessorImpl bean = app.getBean(LifecycleProcessorImpl.class);
        System.out.println(bean);
    }
}

在这里插入图片描述
onRefresh()方法会在容器刷新时被执行，onClose()方法会在容器关闭时被执行。start()和stop()方法需要手动调用容器的start()和stop()方法时才会被调用。

304学Java
关注
  • 25
    点赞
  • 踩
  • 51
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring bean的生命周期
01-16
spring bean 的生命周期，把运行结果的日志，用sublime打开对比查看，你会有比较清晰的认识
谈谈我对Spring Bean 生命周期的理解
08-27
Spring Bean 的生命周期在整个 Spring 中占有很重要的位置，掌握这些可以加深对 Spring 的理解。这篇文章主要介绍了Spring Bean 生命周期,需要的朋友可以参考下
SpringBean的生命周期.mdj
06-09
SpringBean的生命周期.mdj
Spring bean生命周期配置过程解析
08-24
主要介绍了Spring bean生命周期配置过程解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Spring Bean 的生命周期
12-22
本文主要介绍 Spring IoC 容器如何管理 Bean 的生命周期。 在应用开发中，常常需要执行一些特定的初始化工作，这些工作都是相对比较固定的，比如建立数据库连接，打开网络连接等，同时，在结束服务时，也有一些相对...
6、Spring之Bean生命周期~创建Bean（2）
sproutBoy的博客
06-10 688
【代码】6、Spring之Bean生命周期~创建Bean（2）
SpringBoot3 整合 Mybatis 完整版
最新发布
northcastle的博客
06-14 279
SpringBoot3 整合 MyBatis 的步骤详细记录
Spring AI 第三讲Embeddings（嵌入式） Model API 第一讲OpenAI 嵌入
qq_25137131的博客
06-09 880
Spring AI 支持 OpenAI 的文本嵌入模型。OpenAI 的文本嵌入测量文本字符串的相关性。嵌入是一个浮点数向量（列表）。两个向量之间的距离可以衡量它们之间的相关性。距离小表示关联度高，距离大表示关联度低。
springboot与flowable（2）：流程部署
游王子的博客
06-10 292
选择建模器应用程序选择要导出的建模点击导出按钮。将导出的文件复制到项目中。
SpringBoot内置数据源
2303_79546217的博客
06-11 427
在我们之前学习在配置文件当中配置对应的数据源的时候, 我们设置的数据源其实都是Druid的数据源, 并且其配置有两种方式, 当然这两种方式都需要我们导入对应的有关 德鲁伊 的依赖才行代码如上, 我们已经将对应的数据库的信息都设置完成了, 但是并没有使用哪两种方式, 来设置其数据源具体是什么。
JavaSpringboot+vur前后端分离党员信息管理系统（源码+sql+论文）
u014445459的博客
06-11 772
简化系统开发和维护。它做的事情越多，就封装了常见的JavaScript功能和代码，并提供了一个简单的JavaScript设计相关的模式，用于优化HTML文档操作、事件处理、CSS样式化、动画设计和Ajax请求交互。在互联网技术高速发展的今天，通过互联网的传播会让企业更容易的创造更多的经济效益，利用互联网的传播党建信息管理、通过网页版党建信息管理平台的实现 ，让更多人了解到党建新闻、组织风采等相关信息、得到了更大的宣传，在这样一个大环境下把资源统筹规化起来，就会获得高效的党建党员信息和推广。
SpringCloud之Zuul源码解析
qq_36851469的博客
06-10 247
Zuul 是在云平台上提供动态路由，监控，弹性，安全等边缘服务的框架。Zuul 相当于是设备和 Netflix 流应用的 Web 网站后端所有请求的前门。Zuul 可以适当的对多个 Amazon Auto Scaling Groups 进行路由请求。其架构如下图所示：Zuul提供了一个框架，可以对过滤器进行动态的加载，编译，运行。过滤器之间没有直接的相互通信。他们是通过一个RequestContext的静态类来进行数据传递的。
SpringCloud-OpenFeign拓展-连接池、最佳使用方法、日志输出
Charles_Clark的博客
06-08 1124
OpenFeign拓展 - 连接池、最佳使用方法、日志输出
SpringBoot中实现一个通用Excel导出功能
qq_45525848的博客
06-10 822
SpringBoot中实现一个通用Excel导出功能
SpringBoot+layui实现商品打标
m0_46590717的博客
06-11 440
Springboot+layui实现商品打标
springboot-自动配置
qq_44895567的博客
06-11 971
根据条件注解（如 @ConditionalOnClass、@ConditionalOnMissingBean 等），决定是否加载对应的配置类或 Bean。：在主类上添加 @SpringBootApplication 注解，该注解包含 @EnableAutoConfiguration，开启自动配置功能。@ConditionalOnProperty：当指定的配置属性存在并符合预期时，才会实例化相应的 Bean。@ConditionalOnClass：当类路径上存在指定的类时，才会实例化相应的 Bean。
spring最常用的注解
qq_35469691的博客
06-10 522
这些注解帮助开发者简化了配置和开发过程，使 Spring 应用程序更易于管理和维护。根据具体的应用需求和场景，可能会使用到其他特定的注解，但这些是最常用且最基础的注解。
基于springboot实现问卷调查系统项目【项目源码+论文说明】计算机毕业设计
ybigbear1的博客
06-13 402
结合先进的互联网技术，开发符合需求的软件，让数据内容管理不管是从录入的及时性，查看的及时性还是汇总分析的及时性，都能让正确率达到最高，管理更加的科学和便捷。系统的开发离不开前期的需求分析，这个阶段就是让程序员知道自己该做什么事情，在进行需求分析的时候，着重点就是用户对系统的功能要求，这个阶段要是分析得很到位，系统开发出来投入使用时，用户就会发现系统的功能跟用户需求保持一致，程序稳定性也是达标的，可以说需求分析是决定系统开发成败的关键，它主要就是把现实世界进行抽象化，然后把抽象化的对象用来构建模型。
springboot与flowable（1）：介绍、Flowable-ui使用
游王子的博客
06-10 648
工作流在企业管理系统中是高频使用的功能，一个最常见的例子是请假加班申请与审批的过程。事实上，工作流引擎能支持的业务场景远远不止单据审批，几乎所有涉及到业务流转、多人按流程完成工作的场景背后都可以通过工作流引擎作为支撑。基于工作流引擎，可以搭建客户关系管理系统（CRM）、运输管理系统（TMS）、仓储管理系统（WMS）、财务费用系统等多种复杂业务系统。
spring 的bean生命周期
08-12
对于Spring的Bean生命周期，Spring在容器中有5个生命周期阶段，它们分别是：实例化、属性设置、初始化、销毁以及单例实例化，每个阶段的bean都会触发一个对应的回调事件，让开发者能够在每个阶段做一些额外的处理。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值