1. Toy模板网首页
  2. >Toy博客

【spring】spring bean的生命周期

1年前作者：Ez4Sterben分类：Toy博客阅读(18)违法举报

这篇具有很好参考价值的文章主要介绍了【spring】spring bean的生命周期。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

spring bean的生命周期

简介

本文测试并且介绍了spring中bean的生命周期，如果只想知道结果可以跳到最后一部分直接查看。

一、bean的创建阶段

spring中的bean是何时创建的？

在spring中有一个非常重要的注解，叫做**@Scope**，这个注解是用来控制spring中的bean是否是单例的，一般情况下我们不用添加，默认是单例的即@Scope(“singleton”)。但其实还可以传递其他值让spring中的bean不为单例**@Scope(“prototype”)**。

而spring创建bean的时机就和这个注解有关。

现在我们创建两个类，一个类是TestBean用来当测试bean在构造方法中打印一些东西证明他被执行了。另外一个类是TestFactory这个类实现ApplicationContextAware让他成为自己的测试工厂，要注意这两个类都要交给spring来管理。

TestBean

package com.ez4sterben.spring;

import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

/**
 * 测试
 *
 * @author ez4sterben
 * @date 2023/07/27
 */
@Component
public class TestBean {

    public TestBean(){
        System.out.println("testBean实例化");
    }
}

TestFactory

package com.ez4sterben.spring;

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;

/**
 * 测试工厂
 *
 * @author ez4sterben
 * @date 2023/07/27
 */
@Component
public class TestFactory implements ApplicationContextAware {
    public ApplicationContext applicationContext;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }
}

接下来启动spring boot项目。
【spring】spring bean的生命周期,spring,java,bean,生命周期,源码,spring工厂

可以看到这个类在spring项目运行后就被实例化了，即这个bean随着spring项目启动而被创建，接下来我们对代码进行修改。

TestBean

package com.ez4sterben.spring;

import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

/**
 * 测试
 *
 * @author ez4sterben
 * @date 2023/07/27
 */
@Scope("prototype")
@Component
public class TestBean {

    public TestBean(){
        System.out.println("testBean实例化");
    }
}

TestFactory

package com.ez4sterben.spring;

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;

/**
 * 测试工厂
 *
 * @author ez4sterben
 * @date 2023/07/27
 */
@Component
public class TestFactory implements ApplicationContextAware {
    public ApplicationContext applicationContext;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }

    @PostConstruct
    public void init(){
        System.out.println("-------------------------测试工厂初始化-------------------------------");
        TestBean bean = applicationContext.getBean(TestBean.class);
    }
}

其中TestBean加入了@Scope(“prototype”)这个注解，而TestFactory中加入了一个@PostConstruct的初始化方法，这个注解会让其标记的方法在spring项目启动时默认执行。

方法中我们通过工厂来实例化这个bean，再次启动项目查看输出。

【spring】spring bean的生命周期,spring,java,bean,生命周期,源码,spring工厂

可以看到testBean的构造函数中的输出内容是在applicationContext调用了getBean方法后才输出的，也就是说在加入@Scope(“prototype”)注解后，bean被创建的时机其实是移动到了工厂执行getBean()之后才会创建，有点懒加载的意思。

但其实单例形式的bean也是可以懒加载的。我们只需要在TestBean上加入注解@Lazy即可。

【spring】spring bean的生命周期,spring,java,bean,生命周期,源码,spring工厂

二、bean的初始化阶段

Spring工厂在创建完对象后，调用方法的初始化方法，完成对应的初始化操作。

这里就有几个问题了：

  1. 这个初始化方法是谁提供的？
  2. 这个初始化方法又是由谁调用的？

其实这个初始化方法是发开者根据自己的业务需求来定义的，而这个初始化方法是由spring的工厂来调用的。

那么开发者又是怎么调用初始化方法的呢？

其实这里只需要让需要初始化的bean来实现InitializingBean这个接口即可，接下来我们来实现一下。

package com.ez4sterben.spring;

import org.springframework.beans.factory.InitializingBean;
import org.springframework.stereotype.Component;

/**
 * 测试
 *
 * @author ez4sterben
 * @date 2023/07/27
 */
@Component
public class TestBean implements InitializingBean {

    private String name;

    public TestBean(){
        System.out.println("testBean实例化");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        this.name = "testBean";
        System.out.println("afterPropertiesSet: " + this.name);
    }
}

这里我们去掉@Component之外的注解，这样的话我们的bean创建就是随着项目启动进行的，并且实现了初始化方法，给这个类中的name属性赋值并且打印他，接下来启动项目查看一下输出。

【spring】spring bean的生命周期,spring,java,bean,生命周期,源码,spring工厂

显然，这个输出结果表明，在spring项目启动时，testBean这个bean完成了创建，并且根据我们的初始化需求，完成了初始化方法，而我们是没有调用这个初始化方法的，说明由spring默认的工厂来帮我们执行了这个方法。

但是其实可以发现另外一件事，我们刚才是不是使用过一个注解叫做@PostConstruct，他是不是就是用来完成初始化的？

package com.ez4sterben.spring;

import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;

/**
 * 测试
 *
 * @author ez4sterben
 * @date 2023/07/27
 */
@Component
public class TestBean {

    private String name;

    public TestBean(){
        System.out.println("testBean实例化");
    }

    @PostConstruct
    public void init(){
        this.name = "testBean";
        System.out.println("init: " + this.name);
    }
}

那么这两种方式的区别是什么呢？

import org.springframework.beans.factory.InitializingBean;
import javax.annotation.PostConstruct;

其实@PostConstruct是由java本身提供的，如果我们使用这个注解可以脱离spring框架的限制，而实现InitializingBean接口就是把一切交给spring，这里我认为还是使用java提供的比较好一些，就如@Autowired与@Resource一样，脱离框架限制总是会更好一些。

可是如果我两个都选择了会怎么样？

package com.ez4sterben.spring;

import org.springframework.beans.factory.InitializingBean;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;

/**
 * 测试
 *
 * @author ez4sterben
 * @date 2023/07/27
 */
@Component
public class TestBean implements InitializingBean{

    private String name;

    public TestBean(){
        System.out.println("testBean实例化");
    }

    @PostConstruct
    public void init(){
        this.name = "testBeanInit";
        System.out.println("init: " + this.name);
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        this.name = "testBeanAfterPropertiesSet";
        System.out.println("afterPropertiesSet: " + this.name);
    }
}

实际上会先执行@PostConstruct中的内容，然后再执行实现方法中的内容。

【spring】spring bean的生命周期,spring,java,bean,生命周期,源码,spring工厂

再细致一些观察，这个方法的名字很有意思啊afterPropertiesSet，意思是在属性设置之前，什么意思？我们可以联想我们开发中经常用的，同时也是我们刚才提起的，注入。但注入也不仅仅有@Resource这种注入还有@Value这种的注入。

package com.ez4sterben.spring;

import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;

/**
 * 测试
 *
 * @author ez4sterben
 * @date 2023/07/27
 */
@Component
public class TestBean implements InitializingBean{

    @Value("testBeanSet")
    private String name;

    public TestBean(){
        System.out.println("testBean实例化");
    }

    @PostConstruct
    public void init(){
        System.out.println(getName());
        this.name = "testBeanInit";
        System.out.println("init: " + this.name);
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        this.name = "testBeanAfterPropertiesSet";
        System.out.println("afterPropertiesSet: " + this.name);
    }

    public String getName() {
        return name;
    }

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

这里通过@Value给name属性注入，并且在init方法中打印getName()，如果打印了testBeanSet，说明在这里其实已经是完成了注入了。
【spring】spring bean的生命周期,spring,java,bean,生命周期,源码,spring工厂

三、bean的销毁阶段

其实这里和初始化阶段类似，有两种实现方式，一个是实现DisposableBean接口，另一个是使用@PreDestroy注解来标记方法。

package com.ez4sterben.spring;

import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

/**
 * 测试
 *
 * @author ez4sterben
 * @date 2023/07/27
 */
@Component
public class TestBean implements InitializingBean, DisposableBean {

    @Value("testBeanSet")
    private String name;

    public String getName() {
        return name;
    }

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

    public TestBean(){
        System.out.println("testBean实例化");
    }

    @PostConstruct
    public void init(){
        System.out.println(getName());
        this.name = "testBeanInit";
        System.out.println("init: " + this.name);
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        this.name = "testBeanAfterPropertiesSet";
        System.out.println("afterPropertiesSet: " + this.name);
    }

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

    @PreDestroy
    public void preDestroy(){
        System.out.println("PreDestroy");
    }
}

而这整个阶段是发生在工厂关闭之后。关闭工厂的方法在ClassPathXmlApplicationContext中的close()，一般用于关闭资源等操作，这里我们就不具体测试了，另外这个销毁是只适用于@Scope(“singleton”)的bean而且@PreDestory是在重写的destory()之前执行的（最后一部分会有展示）。

四、spring bean的生命周期总述

其实通过我们上面的测试可以发现，spring的声明周期其实是分为四个阶段的，并不只是三个，Spring IOC 中 Bean 的生命周期大致分为四个阶段：实例化（Instantiation）、属性赋值（Populate）、初始化（Initialization）、销毁（Destruction）。

而其中具体的操作也是很复杂的，并不只是我们测试的这些内容。

这里给大家附上详细的图片（来源java程序员进阶之路）

【spring】spring bean的生命周期,spring,java,bean,生命周期,源码,spring工厂

我们来完整的测试这一整套生命周期

首先改写TestBean

package com.ez4sterben.spring;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.*;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

/**
 * 测试
 *
 * @author ez4sterben
 * @date 2023/07/27
 */
@Component
public class TestBean implements InitializingBean, BeanFactoryAware, BeanNameAware, DisposableBean {

    @Value("testBeanSet")
    private String name;

    public String getName() {
        return name;
    }

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

    public TestBean(){
        System.out.println("1.testBean实例化");
    }

    @PostConstruct
    public void init(){
        this.name = "testBeanInit";
        System.out.println("6.init: " + this.name);
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        this.name = "testBeanAfterPropertiesSet";
        System.out.println("7.afterPropertiesSet: " + this.name);
    }

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

    @PreDestroy
    public void preDestroy(){
        System.out.println("9.PreDestroy");
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("4.setBeanFactory");
    }

    @Override
    public void setBeanName(String s) {
        System.out.println("2.setName: "+ getName());
        System.out.println("3.setBeanName");
    }
}

创建一个TestBeanPostProcessor实现BeanPostProcessor接口

package com.ez4sterben.spring;

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

/**
 * 测试bean后置处理程序
 *
 * @author ez4sterben
 * @date 2023/07/27
 */
@Component
public class TestBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("8.postProcessAfterInitialization");
        return bean;
    }

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("5.postProcessBeforeInitialization");
        return bean;
    }
}

重启项目查看输出，其实配置自己的TestBeanPostProcessor 后可以发现还有好多bean都会完成这个过程

【spring】spring bean的生命周期,spring,java,bean,生命周期,源码,spring工厂

结束项目，查看输出，我们的bean都被销毁了。

【spring】spring bean的生命周期,spring,java,bean,生命周期,源码,spring工厂

这样就完成了整个bean的生命周期。文章来源地址https://www.toymoban.com/news/detail-612834.html

到了这里，关于【spring】spring bean的生命周期的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

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

分享到：
领支付宝红包赞助服务器费用

相关文章

  • Spring源码：bean的生命周期（一）

    Spring源码：bean的生命周期（一）

    本节将正式介绍Spring源码细节，将讲解Bean生命周期。请注意，虽然我们不希望过于繁琐地理解Spring源码，但也不要认为Spring源码很简单。在本节中，我们将主要讲解Spring 5.3.10版本的源代码。如果您看到的代码与我讲解的不同，也没有关系，因为其中的原理和业务逻辑基本相

    2024年02月02日
    浏览(10)

  • Spring源码：Bean的生命周期（二）

    让我们继续讲解Spring的Bean实例化过程。在上一节中，我们已经讲解了Spring是如何将Bean定义加入到IoC容器中，并使用合并的Bean定义来包装原始的Bean定义。接下来，我们将继续讲解Spring的 getBean() 方法，特别是针对 FactoryBean 的解析。 在 getBean() 方法中，Spring还支持对 FactoryBea

    2024年02月02日
    浏览(14)

  • 【Spring】Spring之Bean生命周期源码解析

    什么是bean的生命周期 是指bean在spring中是如何生成，如何销毁的； spring创建对象的过程，就是IOC（控制反转）的过程； JFR Java Flight Record，java飞行记录，类似于飞机的黑匣子，是JVM内置的基于事件的JDK监控记录框架，主要用于问题定位和持续监控； 入口代码： Spring启动的时

    2024年02月15日
    浏览(12)
  • 【框架源码】Spring源码解析之Bean生命周期流程

    【框架源码】Spring源码解析之Bean生命周期流程

    观看本文前，我们先思考一个问题，什么是Spring的bean的生命周期？这也是我们在面试的时候，面试官常问的一个问题。 在没有Spring之前，我们创建对象的时候，采用new的方式，当对象不在被使用的时候，由Java的垃圾回收机制回收。 而 Spring 中的对象是 bean，bean 和普通的 J

    2024年02月09日
    浏览(15)

  • 【深入Spring源码解析：解密Bean的生命周期】

    Spring是Java企业级应用开发领域的一颗明星，它提供了很多方便开发人员的工具和思想。在分布式系统中，Spring的分布式远程协作方案，比如REST、Web服务以及消息传递等，也是不可或缺的。 你知道吗？在我们使用Spring时，容器中存放的所有对象，在Spring启动的时候就完成了实

    2024年02月05日
    浏览(16)
  • 【Spring专题】Spring之Bean的生命周期源码解析——上（扫描生成BeanDefinition）

    【Spring专题】Spring之Bean的生命周期源码解析——上（扫描生成BeanDefinition）

    由于Spring源码分析是一个前后联系比较强的过程，而且这边分析，也是按照代码顺序讲解的，所以不了解前置知识的情况下，大概率没办法看懂当前的内容。所以，特别推荐看看我前面的文章（自上而下次序）： Spring底层核心原理解析——引导篇【学习难度： ★★☆☆☆ 】

    2024年02月13日
    浏览(13)
  • 【Spring专题】Spring之Bean的生命周期源码解析——阶段一（扫描生成BeanDefinition）

    【Spring专题】Spring之Bean的生命周期源码解析——阶段一（扫描生成BeanDefinition）

    由于Spring源码分析是一个前后联系比较强的过程，而且这边分析，也是按照代码顺序讲解的，所以不了解前置知识的情况下，大概率没办法看懂当前的内容。所以，特别推荐看看我前面的文章（自上而下次序）： Spring底层核心原理解析——引导篇【学习难度： ★★☆☆☆ 】

    2024年02月13日
    浏览(13)
  • 【Spring专题】Spring之Bean的生命周期源码解析——阶段二（IOC之实例化）

    【Spring专题】Spring之Bean的生命周期源码解析——阶段二（IOC之实例化）

    由于Spring源码分析是一个前后联系比较强的过程，而且这边分析，也是按照代码顺序讲解的，所以不了解前置知识的情况下，大概率没办法看懂当前的内容。所以，特别推荐看看我前面的文章（自上而下次序）： Spring底层核心原理解析——引导篇【学习难度： ★★☆☆☆ 】

    2024年02月13日
    浏览(16)
  • 【Spring专题】Spring之Bean的生命周期源码解析——阶段二（二）（IOC之属性填充/依赖注入）

    【Spring专题】Spring之Bean的生命周期源码解析——阶段二（二）（IOC之属性填充/依赖注入）

    由于Spring源码分析是一个前后联系比较强的过程，而且这边分析，也是按照代码顺序讲解的，所以不了解前置知识的情况下，大概率没办法看懂当前的内容。所以，特别推荐看看我前面的文章（自上而下次序）： Spring底层核心原理解析【学习难度： ★★☆☆☆ 】 手写简易

    2024年02月12日
    浏览(10)
  • Spring bean 生命周期

    Spring bean 生命周期

    在互联网领域中，Spring框架扮演着重要的角色。作为一个开源的Java应用程序开发框架，Spring提供了一种灵活而强大的方式来构建可扩展的应用程序。Spring框架中的一个重要概念是Bean，它是Spring应用程序的基本构建块之一。了解Spring Bean的生命周期对于充分利用Spring框架的功能

    2024年02月11日
    浏览(13)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包