请介绍一下Spring框架中Bean的生命周期

SpringBean的⽣命周期⼀、引⾔ 要想理解Spring框架，那么Spring Bean的⽣命周期就是必须要了解的⼀环，关于Spring Bean的⽣命周期，就是⼀个Bean在IOC容器中从创建到销毁的过程，下⾯就开始梳理⼀下⼀个Bean的创建过程。

⼆、⽣命周期概要流程 简单的来说，⼀个Bean的⽣命周期分为四个阶段： 1、实例化（Instantiation） 2、属性设置（populate） 3、初始化（Initialization） 4、销毁（Destruction）如下图： 具体逻辑位于AbstractAutowireCapableBeanFactory类doCreateBean⽅法中，代码较多，只放出了重要的部分，如下：protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {BeanWrapper instanceWrapper = null;if (instanceWrapper == null) {//实例化instanceWrapper = this.createBeanInstance(beanName, mbd, args);}try {//属性赋值this.populateBean(beanName, mbd, instanceWrapper);//初始化exposedObject = this.initializeBean(beanName, exposedObject, mbd);} catch (Throwable var18) {//...}try {//注册销毁回调接⼝this.registerDisposableBeanIfNecessary(beanName, bean, mbd);return exposedObject;} catch (BeanDefinitionValidationException var16) {//...}} 上⾯是的步实例化、属性赋值、初始化都是Spring容器启动时的步骤，销毁是在容器关闭时的操作，容器销毁时会调⽤容器的close()⽅法去销毁容器。

spring中bean的⽣命周期详解1.Spring IOC容器可以管理bean的⽣命周期，Spring允许在bean⽣命周期内特定的时间点执⾏指定的任务。

2.Spring IOC容器对bean的⽣命周期进⾏管理的过程：①通过构造器或⼯⼚⽅法创建bean实例②为bean的属性设置值和对其他bean的引⽤③调⽤bean的初始化⽅法④ bean可以使⽤了⑤当容器关闭时，调⽤bean的销毁⽅法3.在配置bean时，通过init-method和destroy-method 属性为bean指定初始化和销毁⽅法4.bean的后置处理器① bean后置处理器允许在调⽤初始化⽅法前后对bean进⾏额外的处理② bean后置处理器对IOC容器⾥的所有bean实例逐⼀处理，⽽⾮单⼀实例。

其典型应⽤是：检查bean属性的正确性或根据特定的标准更改bean的属性。

③ bean后置处理器时需要实现接⼝：org.springframework.beans.factory.config.BeanPostProcessor。

在初始化⽅法被调⽤前后，Spring将把每个bean实例分别传递给上述接⼝的以下两个⽅法：postProcessBeforeInitialization(Object, String)postProcessAfterInitialization(Object, String)5.添加bean后置处理器后bean的⽣命周期①通过构造器或⼯⼚⽅法创建bean实例②为bean的属性设置值和对其他bean的引⽤③将bean实例传递给bean后置处理器的postProcessBeforeInitialization()⽅法④调⽤bean的初始化⽅法⑤将bean实例传递给bean后置处理器的postProcessAfterInitialization()⽅法⑥bean可以使⽤了⑦当容器关闭时调⽤bean的销毁⽅法总结以上就是这篇⽂章的全部内容了，希望本⽂的内容对⼤家的学习或者⼯作具有⼀定的参考学习价值，谢谢⼤家对的⽀持。

Spring中Bean的作⽤域与⽣命周期详解⽬录⼀、Bean的作⽤域1、单实例Bean声明2、多实例Bean声明⼆、Bean的⽣命周期1、bean的初始和销毁2、bean的后置处理器总结⼀、Bean的作⽤域⾸先我们来讲⼀下有关于bean的作⽤域，⼀般情况下，我们书写在IOC容器中的配置信息，会在我们的IOC容器运⾏时被创建，这就导致我们通过IOC容器获取到bean对象的时候，往往都是获取到了单实例的Bean对象，这样就意味着⽆论我们使⽤多少个getBean()⽅法，获取到的同⼀个JavaBean都是同⼀个对象，这就是单实例Bean，整个项⽬都会共享这⼀个bean对象。

在Spring中，可以在<bean>元素的scope属性⾥设置bean的作⽤域，以决定这个bean是单实例的还是多实例的。

Scope属性有四个参数，具体的使⽤可以看下图：1、单实例Bean声明默认情况下，Spring只为每个在IOC容器⾥声明的bean创建唯⼀⼀个实例，整个IOC容器范围内都能共享该实例：所有后续的getBean()调⽤和bean引⽤都将返回这个唯⼀的bean实例。

该作⽤域被称为singleton，它是所有bean的默认作⽤域。

也就是单实例。

为了验证这⼀说法，我们在IOC中创建⼀个单实例的bean，并且获取该bean对象进⾏对⽐：<!-- singleton单实例bean1、在容器创建时被创建2、只有⼀个实例--><bean id="book02" class="com.spring.beans.Book" scope="singleton"></bean>测试获取到的单实例bean是否是同⼀个：@Testpublic void test09() {// 单实例创建时创建的两个bean相等Book book03 = (Book)iocContext3.getBean("book02");Book book04 = (Book)iocContext3.getBean("book02");System.out.println(book03==book04);}得到的结果是true；2、多实例Bean声明⽽既然存在单实例，那么就⼀定存在多实例。

SpringBean的⽣命周期总结除了使⽤阶段外，Spring 将 bean 的⽣命周期定义为实例化、属性填充、初始化和销毁四个阶段，并为每个阶段提供了多个拓展点⽤于⾃定义 bean 的创建过程。

这篇⽂章介绍了 bean 的⽣命周期和其各个拓展点，通过图⽰⽣动的展⽰、并结合⼀个实例来演⽰全过程。

Spring ⽣命周期拓展点的类型Spring 提供的拓展点可以分为：⽤于单个 bean 的专⽤拓展点：编写 bean 类时通过实现这些接⼝、重写其中的函数来实现拓展点。

Spring 容器会在适当的时候调⽤这些接⼝中定义的函数。

诸多 Aware 接⼝的⼦接⼝ InitializingBean 接⼝和 DisposableBean 接⼝⽤于所有普通 bean 初始化的通⽤拓展点：这些接⼝中定义了多个拓展点，使⽤时需要定义⼀个专门的类实现接⼝、重写必要的函数。

Spring 容器初始化时会将这些类优先注册为 bean，待它们初始化完成之后再初始化普通的 bean。

在其他每个普通 bean 注册时，Spring 容器都会尝试调⽤所有已注册的通⽤拓展点。

BeanPostProcessor InstantiationAwareBeanPostProcessorDestructionAwareBeanPostProcessor下⽅出现的图⽰中，菱形表⽰通⽤拓展点，⽽圆形表⽰专⽤拓展点，矩形就是 bean 的⽣命周期中的某⼀步骤。

实例化创建 bean 对象实例的过程，包括使⽤⼯⼚模式创建和调⽤构造函数。

Spring 通过InstantiationAwareBeanPostProcessor接⼝在实例化前和后各提供了两个通⽤拓展点，加上对象实例化的过程，执⾏顺序如下：1. postProcessBeforeInstantiation：在普通 bean 对象实例化开始之前调⽤2. 对象实例化3. postProcessAfterInstantiation：在普通 bean 对象实例化完成之后调⽤属性填充如果对象中有 setter 函数，并通过配置元数据指定了注⼊的属性，Spring 容器会在这⼀步为其注⼊配置的值。

Spring bean生命周期在传统的Java应用中，Bean的生命周期非常简单。

Java的关键词new用来实例化Bean（或许他是非序列化的）。

这样就够用了。

相反，Bean的生命周期在Spring容器中更加细致。

理解Spring Bean的生命周期非常重要，因为你或许要利用Spring提供的机会来订制Bean的创建过程。

1.容器寻找Bean的定义信息并且将其实例化。

2.受用依赖注入，Spring按照Bean定义信息配置Bean的所有属性。

3.如果Bean实现了BeanNameAware接口，工厂调用Bean的setBeanName()方法传递Bean 的ID。

4.如果Bean实现了BeanFactoryAware接口，工厂调用setBeanFactory()方法传入工厂自身。

5.如果BeanPostProcessor和Bean关联，那么它们的postProcessBeforeInitialzation()方法将被调用。

6.如果Bean指定了init-method方法，它将被调用。

7.最后，如果有BeanPsotProcessor和Bean关联，那么它们的postProcessAfterInitialization()方法将被调用。

到这个时候，Bean已经可以被应用系统使用了，并且将被保留在Bean Factory中知道它不再需要。

有两种方法可以把它从Bean Factory中删除掉。

1.如果Bean实现了DisposableBean接口，destory()方法被调用。

2.如果指定了订制的销毁方法，就调用这个方法。

Bean在Spring应用上下文的生命周期与在Bean工厂中的生命周期只有一点不同，唯一不同的是，如果Bean实现了ApplicationContextAwre接口，setApplicationContext()方法被调用。

只有singleton行为的bean接受容器管理生命周期。

non-singleton行为的bean，Spring容器仅仅是new的替代，容器只负责创建。

Spring注解开发02--------bean的⽣命周期概述什么是bean的⽣命周期？bean的⽣命周期是指⼀个bean,从创建，再到初始化，最后到销毁的过程！1. 构造（对象创建）：单实例，默认容器启动时创建对象多实例，在每次获取的时候创建对象2. 初始化：对象创建完毕并赋值好，调⽤初始化⽅法。

3. 销毁:单实例,在容器关闭时调⽤销毁⽅法多实例,创建之后容器就不会管理这个bean了，容器不会调⽤销毁⽅法。

4. 我们还可以通过BeanPostProcessor来进⾏初始化⽅法前后的⼀些操作！在Spring中是容器来管理bean的⽣命周期，但是我们可以使⽤⼀些我们⾃定义的⽅法，来使得容器进⾏到当前bean的⽣命周期时来调⽤我们⾃定义的初始化与销毁⽅法。

Spring实现⽣命周期的⼏种⽅式1.指定init-method=""与destroy-method=""2.3.@PostConstruct: 在bean创建完成并且属性赋值完成，来执⾏初始化@PreDestroy：在容器销毁bean之前通知我们清理⼯作4.在bean初始化前后进⾏⼀些处理⼯作postProcessBeforeInitialization:在任意初始化调⽤之前（包括我们指定任意初始化⽅法之前）postProcessAfterInitialization:在任意初始化⽅法调⽤之后@Bean⽅式实现概述@Bean注解为我们提供了两个属性initMethod与destroyMethod，我们使⽤使⽤时最直接赋值⽅法名即可。

测试1.编写实体类person，编写构造⽅法，init(初始化⽅法)与destory(销毁⽅法)package com.xdw.pojo;public class Person {private Integer age;private String name;public void init() {System.out.println("person init。

spring之Bean的⽣命周期详解Bean的⽣命周期：Bean的定义——Bean的初始化——Bean的使⽤——Bean的销毁Bean的定义Bean 是 spring 装配的组件模型，⼀切实体类都可以配置成⼀个 Bean ，进⽽就可以在任何其他的 Bean 中使⽤，⼀个 Bean 也可以不是指定的实体类，这就是抽象 Bean 。

Bean的初始化Spring中bean的初始化回调有两种⽅法⼀种是在配置⽂件中声明init-method="init"，然后在⼀个实体类中⽤init()⽅法来初始化另⼀种是实现InitializingBean接⼝，覆盖afterPropertiesSet()⽅法。

第⼀种：配置⽂件：<?xml version="1.0" encoding="UTF-8"?><beansxmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:p="/schema/p"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-3.0.xsd"><bean id="init-one" class="org.spring.test.BeanInitDemo1" init-method="init"><property name="message" value="这⾥是配置⽂件中为message赋值"></property></bean></beans>BeanInitDemo1类：package org.spring.test;public class BeanInitDemo1 {private String message;public String getMessage() {return message;}public void setMessage(String message) {this.message = message;}public void init(){this.setMessage("这⾥是init()⽅法初始化设值");}}测试类：package org.spring.test;import org.springframework.context.ApplicationContext;import org.springframework.context.support.ClassPathXmlApplicationContext;public class Test {public static void main(String[] args) {ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");BeanInitDemo1 bid = (BeanInitDemo1) context.getBean("init-one");System.out.println(bid.getMessage());}}运⾏结果：这⾥是init()⽅法初始化设值原因：init()初始化⽅法的调⽤是在配置⽂件的Bean初始化之后执⾏的，所以改变了配置⽂件中对message的赋值。

Spring中bean的⽣命周期详解（⾯试说辞）链接：Spring中bean的⽣命周期（详解）1.四个主要阶段2.常⽤的扩展点3.影响多个bean的接⼝4.只调⽤⼀次的接⼝5.与aware有关的接⼝6.两个⽣命周期接⼝7.总结：四个主要阶段Spring bean的⽣命周期只有四个主要阶段，其他都是在这四个主要阶段前后的扩展点，这四个阶段是：1.实例化 Instantiation2.属性赋值 Populate3.初始化 Initialization4.销毁 Destruction其中实例化和属性赋值分别对应构造⽅法和setter⽅法的注⼊，初始化和销毁是⽤户能⾃定义扩展的两个阶段。

可通过查源码的⽅式发现，他们都在doCreate()⽅法中，// 忽略了⽆关代码protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)throws BeanCreationException {// Instantiate the bean.BeanWrapper instanceWrapper = null;if (instanceWrapper == null) {// 实例化阶段！instanceWrapper = createBeanInstance(beanName, mbd, args);}// Initialize the bean instance.Object exposedObject = bean;try {// 属性赋值阶段！populateBean(beanName, mbd, instanceWrapper);// 初始化阶段！exposedObject = initializeBean(beanName, exposedObject, mbd);}}可以发现，分别调⽤三种⽅法：1.createBeanInstance() -> 实例化2.populateBean() -> 属性赋值3.initializeBean() -> 初始化⽽销毁阶段是在容器关闭时调⽤的，在ConfigurableApplicationContext类的close()中常⽤的扩展点影响多个bean的接⼝两个最重要的接⼝：InstantiationAwareBeanPostProcessorBeanPostProcessor实现这两个接⼝的bean，会⾃动切⼊到相应的⽣命周期中，其中InstantiationAwareBeanPostProcessor是作⽤于实例化阶段的前后，BeanPostProcessor是作⽤于初始化阶段的前后。

spring：bean的⽣命周期1、spring中bean的⽣命周期（1）概念在spring框架中，所有的bean对象都有⽣命周期，就是指bean的创建、初始化、服务、销毁的⼀个过程。

（2）bean的⽣命周期bean的定义在spring中通常是通过配置⽂档的⽅式来定义Bean的，在⼀个配置⽂件中可以定义多个Beanbean的初始化bean的使⽤通过ApplicationContext对象或Beanfactory对象获取bean销毁（3）代码的⽅式演⽰Bean的⽣命周期创建Student类：public class Student implements BeanNameAware {private String sname;@Overridepublic String toString() {return"Student{" +"sname='" + sname + '\'' +'}';}public Student() {System.out.println("bean创建了");}public void setSname(String sname) {System.out.println("设置对象属性setName()..");this.sname = sname;}//Bean的初始化⽅法public void initStudent() {System.out.println("初始化Bean");}//实现BeanNameAware接⼝的setBeanName(),传递Bean的ID。

@Overridepublic void setBeanName(String sname) {System.out.println("调⽤BeanNameAware的setBeanSname,返回的ID值是：" +sname);}//Bean的使⽤public void use() {System.out.println("使⽤Bean");}//Bean的销毁⽅法public void destroyStudent() {System.out.println("销毁Bean");}}其中调⽤接⼝后要实现接⼝的setBeanName⽅法，该⽅法的作⽤是返回bean的ID值再创建⼀个类，书写Bean后置处理器相关的⽅法：public class MyBeanPostProcessor implements BeanPostProcessor {@Overridepublic Object postProcessBeforeInitialization(Object o, String s) throws BeansException {System.out.println("前⽅法"+s);return o;}@Overridepublic Object postProcessAfterInitialization(Object o, String s) throws BeansException {System.out.println("后⽅法"+s);return o;}}spring的配置⽂件：<bean name="student"class="com.zhb.bean.Student" init-method="initStudent" destroy-method="destroyStudent"> </bean><bean class="com.zhb.test.MyBeanPostProcessor"></bean>第⼆个是配置后处理器的bean，只需要配置类全名，不需要配置ID等，spring可以⾃动识别并注⼊。

一分钟掌握Spring中bean的生命周期!
Spring中bean的生命周期是指从bean实例创建到bean实例销毁之间所经历的一系
列过程。

Spring容器会管理bean实例，并负责bean实例的这一系列过程，也就是bean
的生命周期。

beab的生命周期由以下几个步骤组成：
1、实例化Bean：在bean容器初始化的时候，Spring会根据配置的Bean实例化，通
常会调用Bean的无参构造方法。

2、装载属性：根据bean的自身配置的属性，为bean的属性赋值。

3、调用初始化方法：当Spring装载完bean的属性之后，会调用一些用户定义的初
始化方法，一般就是bean的init方法，它可以把一些初始化操作做完。

4、Bean使用：在完成初始化之后，bean就可以被使用了，即Spring容器提供bean
的实例供给其他程序使用。

5、调用销毁方法：当Spring需要销毁bean实例的时候，会通知bean调用用户配置
的destroy方法，在该方法中做一些合适的操作。

6、销毁Bean：最终，Spring容器完成bean实例的销毁，bean不再在内存当中占据
空间。

Spring容器会管理bean的这一生命周期，一般开发者只需关注初始化和销毁的过程，因为bean的创建和销毁的过程，开发者并不需要去处理，只需要定义一些必要的初始化
和销毁的操作即可。