实践出真知：理解Spring Bean生命周期

最新推荐文章于 2024-09-10 10:48:51 发布
最新推荐文章于 2024-09-10 10:48:51 发布
阅读量3k 收藏 15
点赞数 3
分类专栏： 个人总结 Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/programmer_at/article/details/82533396
版权

Bean的生命周期，尤其是Bean从实例化到可以使用，过程较为复杂，所以建议自己coding一遍来加深理解。
该周期中涵盖了Spring Aware接口，Spring PostProcessor后置处理器等等，首次接触时可能会觉得晦涩难懂，结合应用场景更有助于理解。

文章目录

生命周期

Spring容器将对其所管理的对象全部给予统一的生命周期管理，这些被管理的对象完全摆脱了原来那种“new完后被使用，脱离作用域后即被回收”的命运。
这里写图片描述

Q: Bean在什么时候会被创建？
A: 容器启动之后，并不会马上就实例化相应的bean定义。容器现在仅仅拥有所有对象的BeanDefinition来保存实例化阶段将要用的必要信息。只有当请求方通过BeanFactory的getBean()方法来请求某个对象实例的时候，才有可能触发Bean实例化阶段的活动。BeanFactory的getBean()方法可以被客户端对象显式调用，也可以在容器内部隐式地被调用。隐式调用有如下两种情况:

  • BeanFactory来说，对象实例化默认采用延迟初始化。通常情况下，当对象A被请求而需要第一次实例化的时候，如果它所依赖的对象B之前同样没有被实例化，那么容器会先实例化对象A所依赖的对象。这时容器内部就会首先实例化对象B，以及对象 A依赖的其他还没有实例化的对象。这种情况是容器内部调用getBean()，对于本次请求的请求方是隐式的。
  • ApplicationContext启动之后会实例化所有单例bean定义。但ApplicationContext在实现的过程中依然遵循Spring容器实现流程的两个阶段，只不过它会在启动阶段的活动完成之后，紧接着调用注册到该容器的所有bean定义的实例化方法getBean()。这就是为什么当你得到ApplicationContext类型的容器引用时，容器内所有对象已经被全部实例化完成。

之所以说getBean()方法是有可能触发Bean实例化阶段的活动，是因为只有当对应某个bean定义的getBean()方法第一次被调用时，不管是显式的还是隐式的，Bean实例化阶段的活动才会被触发，第二次被调用则会直接返回容器缓存的第一次实例化完的对象实例（prototype类型bean除外）。当getBean()方法内部发现该bean定义之前还没有被实例化之后，会通过createBean()方法来进行具体的对象实例化.

Bean Scope

scope用来声明容器中的对象所应该处的限定场景或者说该对象的存活时间，即容器在对象进入其相应的scope之前，生成并装配这些对象，在该对象不再处于这些scope的限定之后，容器通常会销毁Spring 的 IoC 容器这些对象。

如果你不指定bean的scope，singleton便是容器默认的scope.

  • singleton: 在Spring的IoC容器中只存在一个实例，所有对该对象的引用将共享这个实例。该实例从容器启动，并因为第一次被请求而初始化之后，将一直存活到容器退出，也就是说，它与IoC容器“几乎”拥有相同的“寿命”。

标记为singleton的bean是由容器来保证这种类型的bean在同一个容器中只存在一个共享实例；而Singleton模式则是保证在同一个Classloader中只存在一个这种类型的实例。

  • propertype: 针对声明为拥有prototype scope的bean定义，容器在接到该类型对象的请求的时候，会每次都重新生成一个新的对象实例给请求方。虽然这种类型的对象的实例化以及属性设置等工作都是由容器负责的，但是只要准备完毕，并且对象实例返回给请求方之后，容器就不再拥有当前返回对象的引用，请求方需要自己负责当前返回对象的后继生命周期的管理工作，包括该对象的销毁。
    对于那些请求方不能共享使用的对象类型，应该将其bean定义的scope设置为prototype。这样，每个请求方可以得到自己对应的一个对象实例。通常，声明为prototype的scope的bean定义类型，都是一些有状态的，比如保存每个顾客信息的对象。

另外三种scope类型，即request、session和global session类型,只有在支持Web应用的ApplicationContext中才能使用这三个scope。

  • request: 为每一个HTTP请求创建一个全新的bean，当请求结束之后，该对象的生命周期即告结束。
  • session: 为每一个独立的session创建一个全新的bean对象，session结束之后，该bean对象的生命周期即告结束。
  • global session: global session只有应用在基于portlet的Web应用程序中才有意义，它映射到portlet的global范围的 session。如果在普通的基于servlet的Web应用中使用了这个类型的scope，容器会将其作为普通的session
    类型的scope对待。

Q: Spring中的单例模式是否时线程安全的？
A: 关于单例bean的多线程行为，Spring框架没有做任何事情。开发人员有责任处理单例bean的并发问题和线程安全问题。 实际上，大多数Spring bean都没有可变状态，因此非常简单。但是如果你的bean具有可变状态，那么你需要确保线程安全。解决此问题最简单明了的方法是将可变bean的bean范围从“singleton”更改为“prototype".

Spring Aware接口

org.springframework.beans.factory.Aware使得自定义Bean可以识别利用Spring容器的资源，比如，

  • BeanNameAware.setBeanName(String)，可以在Bean中得到它在IOC容器中的Bean的实例的名字。
  • BeanFactoryAware.setBeanFactory(BeanFactory)，可以在Bean中得到Bean所在的IOC容器，从而直接在Bean中使用IOC容器的服务。
  • ApplicationContextAware.setApplicationContext(ApplicationContext)，可以在Bean中得到Bean所在的应用上下文，从而直接在Bean中使用上下文的服务。
  • MessageSourceAware，在Bean中可以得到消息源。
  • ApplicationEventPublisherAware，在bean中可以得到应用上下文的事件发布器，从而可以在Bean中发布应用上下文的事件。
  • ResourceLoaderAware，在Bean中可以得到ResourceLoader，从而在bean中使用ResourceLoader加载外部对应的Resource资源。

如非必要，Spring官方不推荐自定义Bean实现Aware接口，这会增加代码与Spring 框架的耦合性。

Spring PostProcessor

  • BeanFactoryPostProcessor可以对bean的配置信息进行操作。结合Bean的生命周期，Spring IOC容器允许BeanFactoryPostProcessor读取配置信息并且能够在容器实例化任何其他bean之前改变配置信息。
  • BeanPostProcessor可以在Spring完成Bean实例化，配置，初始化之后实现自己的业务逻辑。

BeanPostProcessor是存在于对象实例化阶段，而BeanFactoryPostProcessor则是存在于容器启动阶段

Spring Aware和PostProcessor都是提供了用户利用Spring IoC添加业务逻辑进一步定制Bean。

实例

这里写图片描述

public class MyBean implements BeanNameAware, BeanFactoryAware, ApplicationContextAware, BeanClassLoaderAware,
        InitializingBean, DisposableBean {
    private String name;
    private String description;

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

    @Override
    public void setBeanClassLoader(ClassLoader classLoader) {
        System.out.println("**MyBean** BeanClassLoaderAware.setBeanClassLoader: " + classLoader.getClass());
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("**MyBean** BeanFactoryAware.setBeanFactory: " + beanFactory.getClass());
    }

    @Override
    public void setBeanName(String s) {
        System.out.println("**MyBean** BeanNameAware.getBeanName: " + s);
    }

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

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

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        System.out.println("**MyBean** ApplicationContextAware.setApplicationContext");
    }

    @Override
    protected void finalize() throws Throwable {
        System.out.println("**MyBean** MyBean finalized.");
    }

    @PostConstruct
    public void springPostConstruct() {
        System.out.println("**MyBean** @PostConstruct");
    }

    // xml文件中的init-method
    public void myInitMethod() {
        System.out.println("**MyBean** init-method");
    }

    @PreDestroy
    public void springPreDestroy() {
        System.out.println("**MyBean** @PreDestroy");
    }
    
    // xml文件中的destroy-method
    public void mydestroyMethod() {
        System.out.println("**MyBean** destory-method");
    }

    @Autowired
    public void setName(String name) {
        this.name = name;
        System.out.println("**MyBean** setName");
    }

    @Autowired
    public void setDescription(String description) {
        this.description = description;
        System.out.println("**MyBean** setDescription");
    }

    @Override
    public String toString() {
        return "MyBean{" +
                "name='" + name + '\'' +
                ", description='" + description + '\'' +
                '}';
    }
}

public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    public MyBeanFactoryPostProcessor() {
        super();
        System.out.println("[MyBeanFactoryPostProcessor] constructor");
    }

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
        System.out.println("[MyBeanFactoryPostProcessor] postProcessBeanFactory");
    }
}

public class MyBeanPostProcessor implements BeanPostProcessor {
    public MyBeanPostProcessor() {
        super();
        System.out.println("[MyBeanPostProcessor] constructor.");
    }

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("[MyBeanPostProcessor] postProcessBeforeInitialization: " + bean.getClass() + ": " + beanName);
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("[MyBeanPostProcessor] postProcessAfterInitialization: " + bean.getClass() + ": " + beanName);
        return bean;
    }
}

public class MyInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor {
    public MyInstantiationAwareBeanPostProcessor() {
        super();
        System.out.println("[MyInstantiationAwareBeanPostProcessor] constructor.");
    }

    // 接口方法、实例化Bean之前调用
    @Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        System.out.println("[MyInstantiationAwareBeanPostProcessor] postProcessBeforeInstantiation");
        return null;
    }

    // 接口方法、实例化Bean之前调用
    @Override
    public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        System.out.println("[MyInstantiationAwareBeanPostProcessor] postProcessAfterInstantiation");
        return true;
    }

    // 接口方法、设置某个属性时调用
    @Override
    public PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {
        System.out.println("[MyInstantiationAwareBeanPostProcessor] postProcessPropertyValues");
        // 注意返回结果，否则会无法正确Bean的属性
        return pvs;
    }
}

public class LifeCycleApplication {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("lifecycle.xml");
        System.out.println("[Application] before get bean");
        MyBean bean = (MyBean) context.getBean("myBean");
        System.out.println("[Application] after get bean");
        System.out.println(bean);
        ((ClassPathXmlApplicationContext) context).registerShutdownHook();
    }
}

lifecycle.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.example.LifeCycle"/>
    <bean id="myBean" class="com.example.LifeCycle.MyBean" init-method="myInitMethod"
          destroy-method="mydestroyMethod">
    </bean>
    <bean class="com.example.LifeCycle.MyBeanPostProcessor"/>
    <bean class="com.example.LifeCycle.MyBeanFactoryPostProcessor"/>
    <bean class="com.example.LifeCycle.MyInstantiationAwareBeanPostProcessor"/>
</beans>

运行结果：

...
[MyBeanFactoryPostProcessor] constructor
...
MyBeanFactoryPostProcessor] postProcessBeanFactory
...
[MyBeanPostProcessor] constructor
...
[MyInstantiationAwareBeanPostProcessor] constructor
[MyInstantiationAwareBeanPostProcessor] constructor
...
16:18:06.149 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating instance of bean 'myBean'
**MyBean** construct.
16:18:06.154 [main] DEBUG org.springframework.context.annotation.CommonAnnotationBeanPostProcessor - Found init method on class [com.example.LifeCycle.MyBean]: public void com.example.LifeCycle.MyBean.springPostConstruct()
16:18:06.154 [main] DEBUG org.springframework.context.annotation.CommonAnnotationBeanPostProcessor - Found destroy method on class [com.example.LifeCycle.MyBean]: public void com.example.LifeCycle.MyBean.springPreDestroy()
16:18:06.154 [main] DEBUG org.springframework.context.annotation.CommonAnnotationBeanPostProcessor - Registered init method on class [com.example.LifeCycle.MyBean]: org.springframework.beans.factory.annotation.InitDestroyAnnotationBeanPostProcessor$LifecycleElement@21a44a0a
16:18:06.154 [main] DEBUG org.springframework.context.annotation.CommonAnnotationBeanPostProcessor - Registered destroy method on class [com.example.LifeCycle.MyBean]: org.springframework.beans.factory.annotation.InitDestroyAnnotationBeanPostProcessor$LifecycleElement@5caf49c4
16:18:06.176 [main] DEBUG org.springframework.beans.factory.annotation.InjectionMetadata - Registered injected element on class [com.example.LifeCycle.MyBean]: AutowiredMethodElement for public void com.example.LifeCycle.MyBean.setDescription(java.lang.String)
16:18:06.176 [main] DEBUG org.springframework.beans.factory.annotation.InjectionMetadata - Registered injected element on class [com.example.LifeCycle.MyBean]: AutowiredMethodElement for public void com.example.LifeCycle.MyBean.setName(java.lang.String)
...
[MyInstantiationAwareBeanPostProcessor] postProcessAfterInstantiation
[MyInstantiationAwareBeanPostProcessor] postProcessPropertyValues
...
[MyInstantiationAwareBeanPostProcessor] postProcessAfterInstantiation
[MyInstantiationAwareBeanPostProcessor] postProcessPropertyValues
16:18:06.177 [main] DEBUG org.springframework.beans.factory.annotation.InjectionMetadata - Processing injected element of bean 'myBean': AutowiredMethodElement for public void com.example.LifeCycle.MyBean.setDescription(java.lang.String)
16:18:06.177 [main] DEBUG org.springframework.beans.factory.annotation.InjectionMetadata - Processing injected element of bean 'myBean': AutowiredMethodElement for public void com.example.LifeCycle.MyBean.setName(java.lang.String)
*MyBean** setName
**MyBean** setDescription
**MyBean** BeanNameAware.getBeanName: myBean
**MyBean** BeanClassLoaderAware.setBeanClassLoader: class sun.misc.Launcher$AppClassLoader
**MyBean** BeanFactoryAware.setBeanFactory: class org.springframework.beans.factory.support.DefaultListableBeanFactory
**MyBean** ApplicationContextAware.setApplicationContext
[MyBeanPostProcessor] postProcessBeforeInitialization: class com.example.LifeCycle.MyBean: myBean
...
**MyBean** init-method
...
MyBean{name='Gigi', description='description'}
...
**MyBean** @PreDestroy
**MyBean** DisposableBean.destroy
**MyBean** destory-method

一些建议

不建议使用InitializingBean, DisposableBean，因为这个会增加代码与Spring框架的耦合性。
@PostConstruct，@PreDestroy是JavaX的标准，而非Java，Spring定义的注解，使用时应该注意。
将Bean从Spring IoC中移除之前需要释放持有的资源，建议在destroy-method中写释放资源的代码。

应用

了解Bean的生命周期有利于我们根据业务需要对Bean进行相关的拓展工作。
举个例子，在Bean初始化前希望用户名和密码。倘若将这些信息硬编码到工厂代码中显然是不安全的，一般地，公司会有一个统一的密码存储服务，通过调用开放的API获取用户名和密码。此时，我们可以在Bean的init-method中加入这样的逻辑：调用公司的密码存储服务API获取用户名和密码，加载至Bean的相关字段中。
再举个例子，在Bean被销毁之前，释放Bean与数据库的连接，那么我们可以把释放数据库连接这段逻辑放到destroy-method中。
Ref:

  1. https://www.concretepage.com/spring/spring-bean-life-cycle-tutorial
  2. XXXAware讲解：https://www.baeldung.com/spring-bean-name-factory-aware
  3. 后置处理器XXXPostProcessor讲解：
    http://wiki.jikexueyuan.com/project/spring/bean-post-processors.html
    https://www.jianshu.com/p/fb39f568cd5e
猪杂汤饭
关注
专栏目录
SpringBoot/Spring扩展点系列之初始化和销毁的3种办法 - 第438篇
悟纤学院
08-08 529
有时需要在 Bean 属性值 set 好之后和 Bean 销毁之前做一些事情，比如检查 Bean 中某个属性是否被正常的设置好值。Spring 框架提供了多种方法
Bean的生命周期介绍
11-07
Ben的创建初始化销毁的过程。 容器管理bean的生命周期，我们还可以自定义初始化和销毁方法，容器在bean进行到当前生命周期的时候来自定义的初始化和销毁。
【Spring】Bean生命周期以及应用场景（注解版）
张育嘉的博客
03-06 1590
前言 理清Spring容器管理Bean的过程有助于我们更好地根据需求制定更合理的设计方案，提升系统扩展性和执行效率。 正文 下面通过简单的示例来理清Bean在Spring容器中的生命周期。 我们从整体到细节，首先是启动容器加载Bean，这是一个整体的过程。 /** * 测试 Spring Bean 生命周期 * @author zyj */ public class LifeCycleTes...
Bean的生命周期
最新发布
weixin_45189070的博客
09-10 1151
Bean的生命周期
去字节面试，直接让人出门左拐：Bean 生命周期都不知道！
Candyz7的博客
09-06 1267
IoC，控制反转，想必大家都知道，所谓的控制反转，就是把 new 对象的权利交给容器，所有的对象都被容器控制，这就叫所谓的控制反转。IoC 很好地体现了面向对象设计法则之一 —— 好莱坞法则：“别找我们，我们找你”，即由 IoC 容器帮对象找相应的依赖对象并注入，而不是由对象主动去找。理解好 IoC 的关键是要明确 “谁控制谁，控制什么，为何是反转（有反转就应该有正转了），哪些方面反转了”。谁控制谁，控制什么？
解释一下spring中bean的生命周期
weixin_42610010的博客
02-19 203
Spring中的Bean有四个不同的生命周期：创建、初始化、销毁以及配置更改。在Bean创建期间，容器将为Bean实例化并为它们设置任何必要的属性值。在Bean初始化期间，容器将调用它们的初始化方法，如果它们有的话。在Bean销毁期间，容器将调用它们的销毁方法，如果它们有的话。最后，在配置更改期间，容器将根据配置更改来更改Bean的属性值。 ...
请解释Spring Bean 的生命周期？
Leon_Jinhai_Sun的博客
12-02 1168
Spring Bean 的生命周期简单易懂。在一个bean 实例被初始化时，需要执行一系列的初始化操作以达到可用的状态。同样的，当一个bean 不在被调用时需要进行相关的析构操作，并从bean 容器中移除。 Spring bean factory 负责管理在spring 容器中被创建的bean 的生命周期。Bean 的生命周期由两组回调（call back）方法组成。 1.初始化之后调用的回调方法。 2.销毁之前调用的回调方法。 Spring 框架提供了以下四种方式来管理bean 的生命周期事件：
Spring入门：详解applicationContext.xml配置细节
applicationContext.xml文件是Spring应用程序的初始化入口，它定义了所有bean的生命周期管理和依赖关系。通过这个文件，Spring容器可以自动创建、管理并配置对象，从而实现了松耦合和模块化。 7. **学习曲线与实践...
认证篇：Spring Security 自定义验证码登录（上）之验证码生成
小奇学编程的博客
09-26 966
概述 总所周知，验证码方式的登录模式十分的普遍，不过 Spring Security并没有提供比较好的原生解决方案，但是我们可以 do it by ourself！，本文的篇幅相对比较长，因此分上下篇分别来介绍。上篇主要介绍：验证码的生成，下篇对自定义验证码登录的流程进行讲解。 我们比较常见的验证码主要有两种：图形验证码以及短信验证码，相对来说不是特别的复杂。可能会有人有疑惑：为什么简单的验证码生成需要花费一整篇幅来介绍呢？原因当然是：身为菜鸟的我也有一个架构师的梦！验证码的生成会结合模板方法模式一起讲解.
逐行解读Spring（二） - 自定义标签解析与component-scan原理
github_37947909的博客
07-03 595
文章目录一、自定义标签是什么？1. 自定义标签的定义2. 关于`spring`内置的自定义标签`context:component-scan`二、源码解析1. 自定义标签解析过程2. `context:component-scan`标签工作原理3. Filter匹配流程三、实践1. 使用`context:component-scan`扫描自定义注解2. 自定义标签四、总结1. 自定义标签解析过程2. `@Component`，`@Service`等注解的实现原理五、其他 上一篇我们讲了默认标签-bean标签
【Java基础知识 1】Java入门级概述
热门推荐
学Java，找哪吒
09-25 15万+
CSDN最强Java专栏，包含全部Java基础知识点、Java8新特性、Java集合、Java多线程、Java代码实例，理论结合实战，实现Java的轻松学习。
Spring bean生命周期
izhuhf的专栏
02-22 141
在传统的Java应用中，Bean的生命周期非常简单。 Java的关键词new用来实例化Bean（或许他是非序列化的）。这样就够用了。 相反，Bean的生命周期在Spring容器中更加细致。 理解Spring Bean的生命周期非常重要，因为你或许要利用Spring提供的机会来订制Bean的创建过程。 1.容器寻找Bean的定义信息并且将其实例化。 2.受用依赖注入，Spring按...
如何记忆 Spring Bean 的生命周期
凡是过往，皆为序章
06-16 1825
我之前在准备面试时，去网上搜过答案，大多以下图给出的流程作为答案。 但是当我第一次看到该图时，就产生了很多困扰. “Aware，BeanPostProcessor......这些都是什么啊？而且这么多步骤，太多了，该怎么记啊？”。 其实要记忆该过程，还是需要我们先去理解. 本文将从以下两方面去帮助理解 Bean 的生命周期： 生命周期的概要流程：对 Bean 的生命周期进行概括，并且结合代码来理解； 扩展点的作用：详细介绍 Bean 生命周期中所涉及到的扩展点的作用。 3. 生命周期的概要流
Spring Bean 生命周期
如沐清风的博客
02-09 136
当一个bean被实例化时，他可能需要执行一些初始化使他转换成可用状态。同样，当bean不再需要，并且从容器中移除时，可能需要执行一些清除工作。 Spring Bean的生命周期分为四个阶段和多个扩展点。扩展点又可分为影响多个bean和影响单个bean。 四个阶段： 实例化Instantiation 属性赋值Populate 初始化Initialization 销毁Destruction...
简述bean的生命周期
你走过的路 风都是暖的
02-07 1793
Spring在我们日常开发中是必不可少的 那么Spring主要是做什么的? Spring 主要是为我们来管理对象, 解决对象之间的依赖关系, 有效的解决其之间的耦合性 对象与bean之间的关系又是怎样的呢 对象不一定全是bean, 相反, bean皆为对象 好了, 进入正题 bean的生命周期 .class BeanDefinition : 设置bean的属性, 如Lazy等注意: 在BeanFactory 完成bean创建时, Spring还为我们提供了BeanFacto..
Spring Bean 的生命周期
一入爬虫深似海
05-10 1726
1.Spring Bean生命周期概述传统java对象的生命开始于调用实例化对象的new运算符，并且在对象符合垃圾回收的条件时调用finalize()方法。与传统的java对象相比，Spring bean的生命周期不同。Spring框架提供了以下可用来控制Bean生命周期的方法： InitializingBean和DisposableBean回调接口； BeanName, BeanFactory和A
详细介绍：Bean的生命周期
qq_41277306的博客
11-24 440
Bean的生命周期 一个对象的生命周期包括创建（实例化与初始化）使用以及销毁等阶段，在Spring中，Bean对象周期也遵循这一过程，但是Spring提供了许多对外接口，允许开发者对3个过程（实例化，初始化，销毁）的前后做一些操作。在Spring Bean中，实例化是为Bean对象开辟空间，初始化则对属性初始化。 spring容器可以管理singleton的作用域Bean的生命周期，在此作用域下...
Bean的生命周期详解
m0_57237237的博客
01-10 476
第一步：启动ApplicationContext 第二步：创建BeanFactory工厂 第三步：初始化BeanFactory 1、解析配置类，得到BeanDefinition，并注册到BeanFactory中 i. 解析@ComponentScan，此时就会完成扫描 ii. 解析@Import iii. 解析@Bean 2、 因为ApplicationContext还支持国际化，所以还需要初始化MessageSource对象 3、 因为ApplicationContext
实践出真知：课程设计的挑战与收获
通过此次深入的课程设计，我对于专业知识的理解和实践经验有了显著提升。在这个过程中，我专注于某个特定领域的学习，例如软件开发、硬件配置、网络架构或者是数据分析等，具体的内容取决于课程的主题。在设计的过程...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值