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;@Overridepublic void setApplicationContext(ApplicationContext applicationContext) throws BeansException {this.applicationContext = applicationContext;}
}

接下来启动spring boot项目。

可以看到这个类在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;@Overridepublic void setApplicationContext(ApplicationContext applicationContext) throws BeansException {this.applicationContext = applicationContext;}@PostConstructpublic void init(){System.out.println("-------------------------测试工厂初始化-------------------------------");TestBean bean = applicationContext.getBean(TestBean.class);}
}

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

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

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

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

二、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实例化");}@Overridepublic void afterPropertiesSet() throws Exception {this.name = "testBean";System.out.println("afterPropertiesSet: " + this.name);}
}

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

显然，这个输出结果表明，在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实例化");}@PostConstructpublic 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实例化");}@PostConstructpublic void init(){this.name = "testBeanInit";System.out.println("init: " + this.name);}@Overridepublic void afterPropertiesSet() throws Exception {this.name = "testBeanAfterPropertiesSet";System.out.println("afterPropertiesSet: " + this.name);}
}

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

再细致一些观察，这个方法的名字很有意思啊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实例化");}@PostConstructpublic void init(){System.out.println(getName());this.name = "testBeanInit";System.out.println("init: " + this.name);}@Overridepublic 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，说明在这里其实已经是完成了注入了。

三、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实例化");}@PostConstructpublic void init(){System.out.println(getName());this.name = "testBeanInit";System.out.println("init: " + this.name);}@Overridepublic void afterPropertiesSet() throws Exception {this.name = "testBeanAfterPropertiesSet";System.out.println("afterPropertiesSet: " + this.name);}@Overridepublic void destroy() throws Exception {System.out.println(getName());System.out.println("destroy");}@PreDestroypublic void preDestroy(){System.out.println("PreDestroy");}
}

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

四、spring bean的生命周期总述

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

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

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

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

首先改写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实例化");}@PostConstructpublic void init(){this.name = "testBeanInit";System.out.println("6.init: " + this.name);}@Overridepublic void afterPropertiesSet() throws Exception {this.name = "testBeanAfterPropertiesSet";System.out.println("7.afterPropertiesSet: " + this.name);}@Overridepublic void destroy() throws Exception {System.out.println(getName());System.out.println("10.destroy");}@PreDestroypublic void preDestroy(){System.out.println("9.PreDestroy");}@Overridepublic void setBeanFactory(BeanFactory beanFactory) throws BeansException {System.out.println("4.setBeanFactory");}@Overridepublic 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 {@Overridepublic Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {System.out.println("8.postProcessAfterInitialization");return bean;}@Overridepublic Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {System.out.println("5.postProcessBeforeInitialization");return bean;}
}

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

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

这样就完成了整个bean的生命周期。