Spring Bean 的生命周期

最新推荐文章于 2024-09-10 21:13:10 发布
最新推荐文章于 2024-09-10 21:13:10 发布
阅读量419 收藏
点赞数 3
分类专栏： Spring Bean 文章标签： Spring Bean 生命周期
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_15329947/article/details/104552772
版权
Spring 同时被 2 个专栏收录
10 篇文章 0 订阅
订阅专栏
Bean
1 篇文章 0 订阅
订阅专栏

前言

本文主要介绍 Spring IoC 容器如何管理 Bean 的生命周期。
在应用开发中，常常需要执行一些特定的初始化工作，这些工作都是相对比较固定的，比如建立数据库连接，打开网络连接等，同时，在结束服务时，也有一些相对固定的销毁工作需要执行。为了便于这些工作的设计，Spring IoC 容器提供了相关的功能，可以让应用定制 Bean 的初始化和销毁过程。

Bean 生命周期

在这里插入图片描述
Bean 的生命周期可分为初始化阶段和销毁阶段

初始化阶段

  • 启动 Spring IoC 容器

  • 实例化
    调用 Bean 的构造方法创建一个对象，这个对象默认是单例的。

  • 设置属性
    调用 Bean 对象的 setter 方法设置属性值。

  • Aware 相关的属性，注入到 Bean 对象

    • 设置 Bean 名称
      如果 Bean 实现了 BeanNameAware 接口，调用其重写的 #setBeanName(String name) 方法，将 bean 标签中的 id 或 @Bean 注解的 name 属性（若没设置 name，则默认为方法名）设置为 Bean 的名称。
    • 设置 Bean 工厂
      如果 Bean 实现了 BeanFactoryAware 接口，调用其重写的 #setBeanFactory(BeanFactory factory) 方法，设置 Bean 工厂。
    • 设置上下文
      调用 ApplicationContextAware#setApplicationContext(ApplicationContext context) 方法。

  • 调用其他接口的方法，进一步初始化 Bean 对象

    • 如果存在与 Bean 关联的任何 BeanPostProcessor 实现类，则调用 #preProcessBeforeInitialization(Object bean, String beanName) 方法。
    • 如果 Bean 实现了 InitializingBean 接口，则会调用 #afterPropertiesSet() 方法。
      如果为 Bean 指定了 init 方法（例如 <bean /> 的 init-method 属性或 @Bean 注解的 initMethod 属性），那么将调用该方法。
    • 如果存在与 Bean 关联的任何 BeanPostProcessor 实现类，则将调用 #postProcessAfterInitialization(Object bean, String beanName) 方法。

销毁阶段

  • 如果 Bean 实现了 DisposableBean 接口，当 Spring 容器关闭时，会调用 #destroy() 方法。
  • 如果为 Bean 指定了 destroy 方法（例如 <bean /> 的 destroy-method 属性或 @Bean 注解的 destroyMethod 属性），那么将调用该方法。

代码实例

自定义 Bean

@Data
@Slf4j
public class Person implements BeanNameAware, BeanFactoryAware, InitializingBean, ApplicationContextAware, DisposableBean {

    private String name;

    public Person() {
        log.info("constructor: Instantiate");
    }

    public void setName(String name) {
        log.info("setter: populate property");
        this.name = name;
    }

    public String getName() {
        log.info("getter");
        return name;
    }

    @Override
    public void setBeanName(String beanName) {
        log.info("setBeanName: " + beanName);
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        log.info("setBeanFactory");
    }

    @Override
    public void afterPropertiesSet() {
        log.info("afterPropertiesSet");
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        log.info("setApplicationContext");
    }

    @Override
    public void destroy() {
        log.info("destroy");
    }

    public void customInit() {
        log.info("customInit");
    }

    public void customDestroy() {
        log.info("customDestroy");
    }
}

代码中自定义了一个 Bean 类 Person，实现以下接口并重写其中的方法：

interfacemethod
BeanNameAwaresetBeanName
BeanFactoryAwaresetBeanFactory
InitializingBeanafterPropertiesSet
ApplicationContextAwaresetApplicationContext
DisposableBeandestroy

另外，为 Person 加入无参构造方法、getter/setter 方法。对这些方法全部加入日志，将当前方法名打印出来，便于在控制台观察顺序。

配置 Bean

@Configuration
public class PersonConfig {

    @Bean(initMethod = "customInit", destroyMethod = "customDestroy")
    public Person singletonPerson() {
        Person singletonPerson = new Person();
        singletonPerson.setName("Singleton Jake");
        return singletonPerson;
    }

    @Bean(initMethod = "customInit", destroyMethod = "customDestroy")
    @Lazy
    public Person lazySingletonPerson() {
        Person lazySingletonPerson= new Person();
        lazySingletonPerson.setName("Lazy Singleton Jake");
        return lazySingletonPerson;
    }

    @Bean(initMethod = "customInit", destroyMethod = "customDestroy")
    @Scope("prototype")
    public Person prototypePerson() {
        Person prototypePerson = new Person();
        prototypePerson.setName("Prototype Jake");
        return prototypePerson;
    }
}

上述代码为注册了三个 bean，则 IoC 容器中会存在三个类型相同，名称和作用范围不同的 bean。

classTypebeanNamescope
1PersonsingletonPersonsingleton
2PersonlazySingletonPersonsingleton
3PersonprototypePersonprototype

自定义 BeanPostProcessor

@Component
@Slf4j
public class MyBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if (bean instanceof Person) {
            log.info("postProcessBeforeInitialization, beanName = " + beanName);
        }
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if (bean instanceof Person) {
            log.info("postProcessAfterInitialization, beanName = " + beanName);
        }
        return bean;
    }
}

BeanPostProcessor 允许 IoC 容器在 bean 初始化前后进行处理

启动 Application

注意：想观察 IoC 容器关闭（Bean 销毁）后的打印内容，在 pom 文件中不要加上 spring-boot-starter-web 依赖。
运行 Application 类中的 main 方法，控制台的打印如下（仅截取关键部分）：

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::        (v2.2.4.RELEASE)

2020-03-02 17:41:22.111  INFO 406860 --- [           main] c.j.s.l.SpringLifecycleApplication       : Starting SpringLifecycleApplication on V12CNSSZ01MGRPE with PID 406860 (C:\wengzhengkai\idea-projects\spring-lifecycle\target\classes started by 60055807 in C:\wengzhengkai\idea-projects\spring-lifecycle)
2020-03-02 17:41:22.117  INFO 406860 --- [           main] c.j.s.l.SpringLifecycleApplication       : No active profile set, falling back to default profiles: default
2020-03-02 17:41:23.068  INFO 406860 --- [           main] com.jake.spring.lifecycle.domain.Person  : constructor: Instantiate
2020-03-02 17:41:23.068  INFO 406860 --- [           main] com.jake.spring.lifecycle.domain.Person  : setter: populate property
2020-03-02 17:41:23.069  INFO 406860 --- [           main] com.jake.spring.lifecycle.domain.Person  : setBeanName: singletonPerson
2020-03-02 17:41:23.069  INFO 406860 --- [           main] com.jake.spring.lifecycle.domain.Person  : setBeanFactory
2020-03-02 17:41:23.069  INFO 406860 --- [           main] com.jake.spring.lifecycle.domain.Person  : setApplicationContext
2020-03-02 17:41:23.069  INFO 406860 --- [           main] c.j.s.l.processor.MyBeanPostProcessor    : postProcessBeforeInitialization, beanName = singletonPerson
2020-03-02 17:41:23.069  INFO 406860 --- [           main] com.jake.spring.lifecycle.domain.Person  : afterPropertiesSet
2020-03-02 17:41:23.070  INFO 406860 --- [           main] com.jake.spring.lifecycle.domain.Person  : customInit
2020-03-02 17:41:23.070  INFO 406860 --- [           main] c.j.s.l.processor.MyBeanPostProcessor    : postProcessAfterInitialization, beanName = singletonPerson
2020-03-02 17:41:23.201  INFO 406860 --- [           main] c.j.s.l.SpringLifecycleApplication       : Started SpringLifecycleApplication in 1.921 seconds (JVM running for 3.17)
2020-03-02 17:41:23.209  INFO 406860 --- [extShutdownHook] com.jake.spring.lifecycle.domain.Person  : destroy
2020-03-02 17:41:23.209  INFO 406860 --- [extShutdownHook] com.jake.spring.lifecycle.domain.Person  : customDestroy

打印顺序总结如下：

  • 容器启动后

    • Person#Person() 实例化一个对象
    • Person#setName(String name)设置属性 name 的值
    • Person#setBeanName(String beanName) 设置 beanName，方法继承自 BeanNameAware 接口
    • Person#setBeanFactory(BeanFactory beanFactory) 设置 beanFactory，方法继承自 BeanFactoryAware 接口
    • Person#setApplicationContext(ApplicationContext context) 设置 applicationContext，方法继承自 ApplicationContextAware 接口
    • MyBeanPostProcessor#postProcessBeforeInitialization(Object bean, String beanName) 初始化前的后置处理，可以猜想后置的含义就是实例化和属性设置之后。
    • Person#afterPropertiesSet() 此时属性值已经被设置完毕，方法继承自 InitializingBean 接口
    • Person#customInit() 自定义初始化方法。

  • 容器关闭后

    • Person#destroy() 销毁 bean 之前的操作，方法继承自 DisposableBean 接口
    • Person#customDestroy() 自定义的销毁 bean 之前的操作

由打印内容 setBeanName: singletonPerson , postProcessBeforeInitialization, beanName = singletonPerson, postProcessAfterInitialization, beanName = singletonPerson 可知，只有 beanName 为 singletonPerson 的 Bean 才在 Spring 容器启动时被初始化。

单元测试

编写单元测试，注入ApplicationContext 对象，使用工厂方法 getBean(String beanName) 获取 PersonConfig 中注册的三种 Bean 实例。

@SpringBootTest
class SpringLifecycleApplicationTests {

    @Autowired
    private ApplicationContext applicationContext;

    @Test
    void getSingletonBean() {
        Person singletonPerson = (Person) applicationContext.getBean("singletonPerson");
        assertNotNull(singletonPerson);
        assertSame("Singleton Jake", singletonPerson.getName());
        assertSame(singletonPerson, applicationContext.getBean("singletonPerson"));
    }

    @Test
    void getLazySingletonBean() {
        Person lazySingletonPerson = (Person) applicationContext.getBean("lazySingletonPerson");
        assertNotNull(lazySingletonPerson);
        assertSame("Lazy Singleton Jake", lazySingletonPerson.getName());
        assertSame(lazySingletonPerson, applicationContext.getBean("lazySingletonPerson"));
    }

    @Test
    void getPrototypeBean() {
        Person prototypePerson = (Person) applicationContext.getBean("prototypePerson");
        assertNotNull(prototypePerson);
        assertSame("Prototype Jake", prototypePerson.getName());
        assertNotSame(prototypePerson, applicationContext.getBean("prototypePerson"));
    }

}

运行单元测试类，在控制台中输出结果如下：

  • 容器启动部分

      .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::        (v2.2.4.RELEASE)

2020-03-03 11:42:25.950  INFO 312788 --- [           main] c.j.s.l.SpringLifecycleApplicationTests  : Starting SpringLifecycleApplicationTests on V12CNSSZ01MGRPE with PID 312788 (started by 60055807 in C:\wengzhengkai\idea-projects\spring-lifecycle)
2020-03-03 11:42:25.952  INFO 312788 --- [           main] c.j.s.l.SpringLifecycleApplicationTests  : No active profile set, falling back to default profiles: default
2020-03-03 11:42:26.626  INFO 312788 --- [           main] com.jake.spring.lifecycle.domain.Person  : constructor: Instantiate
2020-03-03 11:42:26.627  INFO 312788 --- [           main] com.jake.spring.lifecycle.domain.Person  : setter: populate property
2020-03-03 11:42:26.639  INFO 312788 --- [           main] com.jake.spring.lifecycle.domain.Person  : setBeanName: singletonPerson
2020-03-03 11:42:26.639  INFO 312788 --- [           main] com.jake.spring.lifecycle.domain.Person  : setBeanFactory
2020-03-03 11:42:26.639  INFO 312788 --- [           main] com.jake.spring.lifecycle.domain.Person  : setApplicationContext
2020-03-03 11:42:26.639  INFO 312788 --- [           main] c.j.s.l.processor.MyBeanPostProcessor    : postProcessBeforeInitialization, beanName = singletonPerson
2020-03-03 11:42:26.639  INFO 312788 --- [           main] com.jake.spring.lifecycle.domain.Person  : afterPropertiesSet
2020-03-03 11:42:26.640  INFO 312788 --- [           main] com.jake.spring.lifecycle.domain.Person  : customInit
2020-03-03 11:42:26.640  INFO 312788 --- [           main] c.j.s.l.processor.MyBeanPostProcessor    : postProcessAfterInitialization, beanName = singletonPerson
2020-03-03 11:42:26.783  INFO 312788 --- [           main] c.j.s.l.SpringLifecycleApplicationTests  : Started SpringLifecycleApplicationTests in 1.259 seconds (JVM running for 3.759)

  • getSingletonBean

    2020-03-03 11:42:27.208  INFO 312788 --- [           main] com.jake.spring.lifecycle.domain.Person  : getter

  • getLazySingletonBean

    2020-03-03 11:42:27.236  INFO 312788 --- [           main] com.jake.spring.lifecycle.domain.Person  : constructor: Instantiate
2020-03-03 11:42:27.236  INFO 312788 --- [           main] com.jake.spring.lifecycle.domain.Person  : setter: populate property
2020-03-03 11:42:27.236  INFO 312788 --- [           main] com.jake.spring.lifecycle.domain.Person  : setBeanName: lazySingletonPerson
2020-03-03 11:42:27.236  INFO 312788 --- [           main] com.jake.spring.lifecycle.domain.Person  : setBeanFactory
2020-03-03 11:42:27.236  INFO 312788 --- [           main] com.jake.spring.lifecycle.domain.Person  : setApplicationContext
2020-03-03 11:42:27.236  INFO 312788 --- [           main] c.j.s.l.processor.MyBeanPostProcessor    : postProcessBeforeInitialization, beanName = lazySingletonPerson
2020-03-03 11:42:27.236  INFO 312788 --- [           main] com.jake.spring.lifecycle.domain.Person  : afterPropertiesSet
2020-03-03 11:42:27.236  INFO 312788 --- [           main] com.jake.spring.lifecycle.domain.Person  : customInit
2020-03-03 11:42:27.237  INFO 312788 --- [           main] c.j.s.l.processor.MyBeanPostProcessor    : postProcessAfterInitialization, beanName = lazySingletonPerson
2020-03-03 11:42:27.237  INFO 312788 --- [           main] com.jake.spring.lifecycle.domain.Person  : getter

  • getPrototype

    2020-03-03 11:42:27.227  INFO 312788 --- [           main] com.jake.spring.lifecycle.domain.Person  : constructor: Instantiate
2020-03-03 11:42:27.227  INFO 312788 --- [           main] com.jake.spring.lifecycle.domain.Person  : setter: populate property
2020-03-03 11:42:27.227  INFO 312788 --- [           main] com.jake.spring.lifecycle.domain.Person  : setBeanName: prototypePerson
2020-03-03 11:42:27.227  INFO 312788 --- [           main] com.jake.spring.lifecycle.domain.Person  : setBeanFactory
2020-03-03 11:42:27.227  INFO 312788 --- [           main] com.jake.spring.lifecycle.domain.Person  : setApplicationContext
2020-03-03 11:42:27.228  INFO 312788 --- [           main] c.j.s.l.processor.MyBeanPostProcessor    : postProcessBeforeInitialization, beanName = prototypePerson
2020-03-03 11:42:27.228  INFO 312788 --- [           main] com.jake.spring.lifecycle.domain.Person  : afterPropertiesSet
2020-03-03 11:42:27.228  INFO 312788 --- [           main] com.jake.spring.lifecycle.domain.Person  : customInit
2020-03-03 11:42:27.228  INFO 312788 --- [           main] c.j.s.l.processor.MyBeanPostProcessor    : postProcessAfterInitialization, beanName = prototypePerson
2020-03-03 11:42:27.228  INFO 312788 --- [           main] com.jake.spring.lifecycle.domain.Person  : getter
2020-03-03 11:42:27.228  INFO 312788 --- [           main] com.jake.spring.lifecycle.domain.Person  : constructor: Instantiate
2020-03-03 11:42:27.228  INFO 312788 --- [           main] com.jake.spring.lifecycle.domain.Person  : setter: populate property
2020-03-03 11:42:27.228  INFO 312788 --- [           main] com.jake.spring.lifecycle.domain.Person  : setBeanName: prototypePerson
2020-03-03 11:42:27.228  INFO 312788 --- [           main] com.jake.spring.lifecycle.domain.Person  : setBeanFactory
2020-03-03 11:42:27.229  INFO 312788 --- [           main] com.jake.spring.lifecycle.domain.Person  : setApplicationContext
2020-03-03 11:42:27.229  INFO 312788 --- [           main] c.j.s.l.processor.MyBeanPostProcessor    : postProcessBeforeInitialization, beanName = prototypePerson
2020-03-03 11:42:27.229  INFO 312788 --- [           main] com.jake.spring.lifecycle.domain.Person  : afterPropertiesSet
2020-03-03 11:42:27.229  INFO 312788 --- [           main] com.jake.spring.lifecycle.domain.Person  : customInit
2020-03-03 11:42:27.229  INFO 312788 --- [           main] c.j.s.l.processor.MyBeanPostProcessor    : postProcessAfterInitialization, beanName = prototypePerson

由单元测试的结果可知：

  • 运行 @SpringBootTest 注解的单元测试类和直接运行 Application 在容器启动部分是一致的，都是默认初始化单例 Bean。
  • @Lazy 或 @Scope("prototype") 注解的 @Bean 配置，都是在被 ApplicationContext#getBean(String beanName) 调用时才进行初始化。
  • @Lazy 注解的 Bean，仅仅做一次初始化，获取的单例，仅仅是延迟初始化而已。
  • @Scope("prototype") 注解的 Bean，基于原型模式，其背后原理是拷贝，每次都进行初始化。

参考博客

  • Spring Bean 生命周期 （实例结合源码彻底讲透）
  • https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/context/ApplicationContextAware.html
  • https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/beans/factory/InitializingBean.html
  • https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/beans/factory/config/BeanPostProcessor.html
  • https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/beans/factory/DisposableBean.html
  • https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/context/annotation/Bean.html
  • https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/context/annotation/Configuration.html
  • https://docs.spring.io/spring/docs/3.0.0.M3/reference/html/ch04s04.html
西丽沙河尚
关注
专栏目录
SpringBean生命周期详解
weixin_43244698的博客
10-28 9616
SpringBean生命周期详解 一、简述： Spring是我们每天都在使用的框架，Bean是被Spring管理的Java对象，是Spring框架最重要的部分之一，那么让我们一起了解一下Spring中Bean的生命周期是怎样的吧 二、流程图 我们先从宏观的角度看一下Spring的生命周期： ![在这里插入图片描述](https://img-blog.csdnimg.cn/20201028174058916.png?x-oss-process=image/watermark,t ype_ZmFuZ3poZW5
Spring Bean生命周期详解
热门推荐
weixin_45723046的博客
04-10 1万+
站在设计者的角度考虑设计IOC容器 加载Bean的配置（比如xml配置） 比如不同类型资源的加载，解析成生成统一Bean的定义 根据Bean的定义加载生成Bean的实例，并放置在Bean容器中 比如Bean的依赖注入，Bean的嵌套，Bean存放（缓存）等 除了基础Bean外，还有常规针对企业级业务的特别Bean 比如国际化Message，事件Event等生成特殊的类结构去支撑 对容器中的Bean提供统一的管理和调用 比如用工厂模式管理，提供方法根据名字/类的类型等从容器中获取Bea
SpringBoot Bean的生命周期demo.zip
09-17
一般情况下，我们只是关心如何正确地将Bean装配到容器中，并不关心Ioc容器是如何装配和销毁Bean的过程。但是恰恰有时候，我们需要自定义初始化或销毁Bean的过程，以满足一些“特殊的”需求。比如，数据源在关闭的时候调用其close方法，这是项目开发过程中很常见的需求。
springboot bean生命周期
weixin_44207827的博客
12-16 272
bean生命周期分为4个部分 1. 定义 2. 初始化 3. 生存期 4. 销毁
spring boot Bean的生命周期
最新发布
2301_79694645的博客
09-10 999
一.Bean 实例化的基本流程Bean 实例化的基本流程Spring容器在进行初始化时，会将xml配置的的信息封装成一个BeanDefinition对象，所有的BeanDefinition存储到一个名为beanDefinitionMap的Map集合中去，Spring框架在对该Map进行遍历，使用反射创建Bean实例对象，创建好的Bean对象存储在一个名为singletonObjects的Map集合中，当调用getBean方法时则最终从该Map集合中取出Bean实例对象返回。
Spring Bean的生命周期。
看不过的黑工坊
08-19 333
转自：http://www.2cto.com/kf/201405/301843.html 一、生命周期流程图：   　　Spring Bean的完整生命周期从创建Spring容器开始，直到最终Spring容器销毁Bean，这其中包含了一系列关键点。 若容器注册了以上各种接口，程序那么将会按照以上的流程进行。下面将仔细讲解各接口作用。 二、各种接
SpringBean生命周期
Kris的博客
06-25 149
补习一下Spring的生命周期。 经过总结网上各个博主的解释，我总结的Bean生命周期简述为： 1、Bean实例化，对Spring容器所管理的Bean进行实例化 2、Bean的属性注入，将Bean所需要的引用和值注入 3、查看Bean是否实现了XXXAware接口(分别是BeanNameAware、BeanFactoryAware、ApplicationContextAware)，如果实现了，那调用相关的实现方法(分别对应setBeanName、setBeanFact...
spring bean生命周期
weixin_34192993的博客
10-08 183
2019独角兽企业重金招聘Python工程师标准>>> ...
谈谈我对Spring Bean 生命周期的理解
08-27
Spring Bean 生命周期是 Spring 框架中的一个核心概念，了解 Spring Bean 的生命周期对我们了解整个 Spring 框架会有很大的帮助。本文将详细介绍 Spring Bean 生命周期的概念、生命周期图、生命周期阶段、生命周期...
spring bean的生命周期
01-16
- **XML配置**：在传统的Spring应用中，Bean的定义通常写在XML配置文件中，如`springbean-xml`中的配置。 - **注解配置**：使用`@Component`，`@Service`，`@Repository`和`@Controller`注解标记类，配合`@...
SpringBean的生命周期
sunshineKay的博客
07-07 145
本文主要讨论， 从工厂类将xml文件中配置的Bean标签封装成的BeanDefinition对象后，Bean从创建到销毁的整个执行过程 以下为声明Bean的作用范围为默认即：singleton 单例 情况下，SpringBean的执行顺序（单例bean的创建和管理、销毁由Spring统一负责）; 而prototype多例情况下，spring框架只负责创建，不负责销毁；且在外部通过getBean调用时才会创建 1. 单例下SpringBean的生命周期及执行顺序 代码验证 1.1. 定义实体类T.
Spring Bean生命周期详解与示例
在Spring框架中，Bean的生命周期管理是至关重要的，它涉及到从Bean的创建、初始化到销毁的整个过程。...对于学习Spring框架或进行Spring项目开发的人员来说，深入理解Bean生命周期是必不可少的知识。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值