Spring高手之路5——彻底掌握Bean的生命周期
1. 理解Bean的生命周期
1.1 生命周期的各个阶段
在Spring IOC
容器中,Bean
的生命周期大致如下:
实例化:当启动
Spring
应用时,IOC
容器就会为在配置文件中声明的每个<bean>
创建一个实例。属性赋值:实例化后,
Spring
就通过反射机制给Bean
的属性赋值。调用初始化方法:如果
Bean
配置了初始化方法,Spring
就会调用它。初始化方法是在Bean
创建并赋值之后调用,可以在这个方法里面写一些业务处理代码或者做一些初始化的工作。Bean
运行期:此时,Bean
已经准备好被程序使用了,它已经被初始化并赋值完成。应用程序关闭:当关闭
IOC
容器时,Spring
会处理配置了销毁方法的Bean
。调用销毁方法:如果
Bean
配置了销毁方法,Spring
会在所有Bean
都已经使用完毕,且IOC
容器关闭之前调用它,可以在销毁方法里面做一些资源释放的工作,比如关闭连接、清理缓存等。
这就是Spring IOC
容器管理Bean
的生命周期,帮助我们管理对象的创建和销毁,以及在适当的时机做适当的事情。
我们可以将生命周期的触发称为回调,因为生命周期的方法是我们自己定义的,但方法的调用是由框架内部帮我们完成的,所以可以称之为“回调”。
2. 理解init-method和destroy-method
让我们先了解一种最容易理解的生命周期阶段:初始化和销毁方法。这些方法可以在Bean
的初始化和销毁阶段起作用,我们通过示例来演示这种方式。
为了方便演示XML
和注解的方式,接下来我们会创建两个类来分别进行演示,分别为Lion
和Elephant
,让我们一步一步对比观察。
2.1 从XML配置创建Bean看生命周期
先创建一个类Lion
package com.example.demo.bean;
public class Lion {
private String name;
public void setName(String name) {
this.name = name;
}
public void init() {
System.out.println(name + " has been initialized...");
}
public void destroy() {
System.out.println(name + " has been destroyed...");
}
}
在XML
中,我们使用<bean>
标签来注册Lion
:
applicationContext.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"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean class="com.example.demo.bean.Lion"
init-method="init" destroy-method="destroy">
<property name="name" value="simba"/>
</bean>
</beans>
加上主程序
package com.example.demo.application;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.support.ClassPathXmlApplicationContext;
@ComponentScan("com.example")
public class DemoApplication {
public static void main(String[] args) {
System.out.println("Spring容器初始化开始");
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
System.out.println("Spring容器初始化完成。");
System.out.println("==================");
System.out.println("Spring容器准备关闭");
context.close();
System.out.println("Spring容器已关闭。");
}
}
运行结果
在<bean>
标签中,有两个属性:init-method
和destroy-method
,这两个属性用于指定初始化和销毁方法。
这里"simba has been initialized...
",证明init()
方法被调用了。当context.close()
被调用时,看到"simba has been destroyed...
",证明destroy()
方法被调用了。
在 IOC
容器初始化之前,默认情况下 Bean
已经创建好了,而且完成了初始化动作;容器调用销毁动作时,先销毁所有 Bean
,最后 IOC
容器全部销毁完成。
这个例子通过一个简单的Spring
应用程序显示了Spring bean
的生命周期。我们可以在创建bean
时根据需要使用这些生命周期方法。
2.2 从配置类注解配置创建Bean看生命周期
这里再创建一个类Elephant
和上面对比
package com.example.demo.bean;
public class Elephant {
private String name;
public void setName(String name) {
this.name = name;
}
public void init() {
System.out.println(name + " has been initialized...");
}
public void destroy() {
System.out.println(name + " has been destroyed...");
}
}
对于注解,@Bean
注解中也有类似的属性:initMethod
和destroyMethod
,这两个属性的作用与XML
配置中的相同。
package com.example.demo.configuration;
import com.example.demo.bean.Elephant;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.ImportResource;
@Configuration
@ImportResource("classpath:applicationContext.xml")
public class AnimalConfig {
@Bean(initMethod = "init", destroyMethod = "destroy")
public Elephant elephant() {
Elephant elephant = new Elephant();
elephant.setName("Dumbo");
return elephant;
}
}
这里用@ImportResource("classpath:applicationContext.xml")
引入xml
配置创建Bean
进行对比。
主程序改为如下:
package com.example.demo.application;
import com.example.demo.configuration.AnimalConfig;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.ComponentScan;
@ComponentScan("com.example")
public class DemoApplication {
public static void main(String[] args) {
System.out.println("Spring容器初始化开始");
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AnimalConfig.class);
System.out.println("Spring容器初始化完成。");
System.out.println("==================");
System.out.println("Spring容器准备关闭");
context.close();
System.out.println("Spring容器已关闭。");
}
}
运行结果
注意:在Spring
中,如果在Java
配置中定义了一个Bean
,并在XML
中定义了一个相同id
或name
的Bean
,那么最后注册的那个Bean
会覆盖之前注册的,这取决于配置文件加载顺序,无论在Java
配置中还是XML
配置中定义的initMethod
或destroyMethod
,最后生效的总是后加载的配置中定义的。
“init-method
”是指定初始化回调方法的属性的统称,无论它是在XML
配置还是Java
配置中使用。同样地,“destroy-method
”是指定销毁回调方法的属性的统称。后文我们讲解多种声明周期共存的时候,将延续这种说法。
2.3 初始化和销毁方法的特性
在Spring
框架中配置Bean
的初始化和销毁方法时,需要按照Spring
的规范来配置这些方法,否则Spring
可能无法正确地调用它们。下面给每个特性提供一个解释和示例:
- 方法的访问权限无限制:无论方法是
public
、protected
、private
,还是default
(包私有),Spring
都可以调用。Spring
通过反射来调用这些方法,所以它可以忽略Java
的访问权限限制。示例:
public class MyBean {
private void init() {
// 初始化代码
}
}
在上述代码中,即使init
方法是private
的,Spring
也可以正常调用。
- 方法没有参数:由于
Spring
不知道需要传递什么参数给这些方法,所以这些方法不能有参数。示例:
public class MyBean {
public void init() {
// 初始化代码
}
}
Spring
允许这些方法具有参数,Spring
容器会尝试使用它的自动装配特性,通过类型或名称匹配找到合适的bean
来作为参数进行调用。但是如果Spring
无法找到匹配的bean
或有多个匹配的bean
,那么会在应用启动时抛出异常。
- 方法没有返回值:由于返回的值对
Spring
来说没有意义,所以这些方法不应该有返回值。示例:
public class MyBean {
public void init() {
// 初始化代码
}
}
在上述代码中,init
方法是void
的,如果让此方法返回一个值,如public String init()
,那么Spring
将忽略此返回值。
- 方法可以抛出异常:如果在初始化或销毁过程中发生错误,这些方法可以抛出异常来通知
Spring
。示例:
public class MyBean {
public void init() throws Exception {
// 初始化代码
if (somethingGoesWrong) {
throw new Exception("Initialization failed.");
}
}
}
在上述代码中,如果在init
方法中的初始化代码出错,它会抛出一个异常。不管是调用初始化还是销毁方法,只要抛出了异常(无论是检查型异常还是未检查型异常),这些异常将被Spring
容器捕获并封装为BeanCreationException
或BeanDestructionException
后抛出,这会导致Bean
的创建或销毁过程失败。
- 方法不应是静态的:由于
Spring
需要一个Bean
实例来调用初始化或销毁方法,静态方法属于类级别,不依赖于实例。如果标注在一个静态方法上,就失去了作用于实例生命周期的意义。比如:
public class MyBean {
public static void init() {
// 初始化代码
}
}
如果指定的初始化或销毁方法是静态的,Spring
并不会报错,但是这违背了初始化和销毁方法应该是实例级别的原则。
2.4 探究Bean的初始化流程顺序
在上面的代码中,我们可以看出Bean
在IOC
容器初始化阶段就已经创建并初始化了,那么每个Bean
的初始化动作又是如何进行的呢?我们修改一下Lion
,在构造方法和setName
方法中加入控制台打印,这样在调用这些方法时,会在控制台上得到反馈。
package com.example.demo.bean;
public class Lion {
private String name;
public Lion() {
System.out.println("Lion's constructor is called...");
}
public void setName(String name) {
System.out.println("setName method is called...");
this.name = name;
}
public void init() {
System.out.println(name + " has been initialized...");
}
public void destroy() {
System.out.println(name + " has been destroyed...");
}
}
我们重新运行主程序:
@ComponentScan("com.example")
public class DemoApplication {
public static void main(String[] args) {
System.out.println("Spring容器初始化开始");
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
System.out.println("Spring容器初始化完成。");
System.out.println("==================");
System.out.println("Spring容器准备关闭");
context.close();
System.out.println("Spring容器已关闭。");
}
}
运行结果
我们可以得出结论:在Bean
的生命周期中,首先进行属性赋值,然后执行init-method
标记的方法。
3. @PostConstruct和@PreDestroy
在JSR250
规范中,有两个与Bean
生命周期相关的注解,即@PostConstruct
和@PreDestroy
。这两个注解对应了Bean
的初始化和销毁阶段。
@PostConstruct
注解标记的方法会在bean
属性设置完毕后(即完成依赖注入),但在bean
对外暴露(即可以被其他bean
引用)之前被调用,这个时机通常用于完成一些初始化工作。
@PreDestroy
注解标记的方法会在Spring
容器销毁bean
之前调用,这通常用于释放资源。
3.1 示例:@PostConstruct和@PreDestroy的使用
我们这里还是用Lion
类来创建这个例子,将Lion
类修改为使用@PostConstruct
和@PreDestroy
注解
package com.example.demo.bean;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
@Component
public class Lion {
private String name;
public void setName(String name) {
this.name = name;
}
@PostConstruct
public void init() {
System.out.println("Lion is going through init.");
}
@PreDestroy
public void destroy() {
System.out.println("Lion is going through destroy.");
}
@Override
public String toString() {
return "Lion{" + "name=" + name + '}';
}
}
给Lion
类加上@Component
注解,让IOC
容器去管理这个类,我们这里就不把Elephant
类加进来增加理解难度了。
被 @PostConstruct
和 @PreDestroy
注解标注的方法与 init-method / destroy-method
方法的初始化和销毁的要求是一样的,访问修饰符没有限制,private
也可以。
我们可以注释掉之前的配置类和XML
配置,因为和这里的例子没有关系,我们来看看主程序:
package com.example.demo.application;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class DemoApplication {
public static void main(String[] args) {
System.out.println("Spring容器初始化开始");
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext("com.example.demo.bean");
System.out.println("Spring容器初始化完成。");
System.out.println("==================");
System.out.println("Spring容器准备关闭");
context.close();
System.out.println("Spring容器已关闭。");
}
}
运行结果
这里可以看到@PostConstruct
和@PreDestroy
注解正确地应用在了Lion
的初始化和销毁过程中。
注意:
@PostConstruct
和@PreDestroy
可用于任何Java
类,初始化和销毁方法与init-method
和destroy-method
类似,但也有一定的区别。
这些方法必须是非静态的,否则
Spring
容器在启动或销毁时会抛出BeanCreationException
或BeanDestructionException
异常,导致创建或销毁bean
失败。这些方法推荐无参数,与
init-method
和destroy-method
的行为类似。这些方法推荐无返回值,与
init-method
和destroy-method
的行为类似。可以是任何访问级别,与
init-method
和destroy-method
的行为类似。可以抛出异常,与
init-method
和destroy-method
的行为类似。不能被final修饰,如果使用
final
修饰这两个注解的方法,在编译时不会报错,可以正常编译。但是在运行时,Spring
容器在解析和设置注解时,会尝试使用CGLIB
或JDK
动态代理生成子类,由于方法被final
修饰,子类无法覆盖该方法,所以Spring
容器会抛出异常,表示无法为生命周期方法生成代理,这会导致标注了final
的生命周期方法无法被Spring
调用。
注意:init-method
和destroy-method
方法被final
修饰也无影响,因为Spring
通过反射机制来调用init-method
和destroy-method
,不需要生成代理子类,并没有试图覆盖这些方法。不过生命周期方法都不被建议设计为final
的,这需要注意。
3.2 初始化和销毁——注解和init-method共存对比
@PostConstruct
和@PreDestroy
注解与init-method/destroy-method
属性如何共存呢?我们来看看
我们只用Lion
类来举例子,在Lion
类中添加新的open()
和close()
方法
需要的全部代码如下:
Lion.java
package com.example.demo.bean;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
public class Lion {
private String name;
public Lion() {
System.out.println("Lion构造器");
}
public void setName(String name) {
System.out.println("Lion设置name");
this.name = name;
}
public void open() {
System.out.println("配置类initMethod - 打开Lion。。。");
}
public void close() {
System.out.println("配置类destroyMethod - 关闭Lion。。。");
}
@PostConstruct
public void init() {
System.out.println("@PostConstruct - Lion正在进行初始化。。。");
}
@PreDestroy
public void destroy() {
System.out.println("@PreDestroy - Lion正在进行销毁。。。");
}
@Override
public String toString() {
return "Lion{" + "name=" + name + '}';
}
}
配置类AnimalConfig.java
package com.example.demo.configuration;
import com.example.demo.bean.Lion;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class AnimalConfig {
@Bean(initMethod = "open", destroyMethod = "close")
public Lion lion() {
return new Lion();
}
}
主程序
package com.example.demo.application;
import com.example.demo.configuration.AnimalConfig;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class DemoApplication {
public static void main(String[] args) {
System.out.println("Spring容器初始化开始");
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AnimalConfig.class);
System.out.println("Spring容器初始化完成。");
System.out.println("==================");
System.out.println("Spring容器准备关闭");
context.close();
System.out.println("Spring容器已关闭。");
}
}
运行结果
这里可以看到@PostConstruct
和@PreDestroy
注解的优先级始终高于配置类中@Bean
注解的initMethod
和destroyMethod
属性。
4. 实现InitializingBean和DisposableBean接口
这两个接口是 Spring
预定义的两个关于生命周期的接口。他们被触发的时机与上文中的 init-method / destroy-method
以及 JSR250
规范的注解相同,都是在 Bean
的初始化和销毁阶段回调的。下面演示如何使用这两个接口。
4.1 示例:实现InitializingBean和DisposableBean接口
创建Bean
,我们让Lion
类实现这两个接口:
Lion.java
package com.example.demo.bean;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.stereotype.Component;
@Component
public class Lion implements InitializingBean, DisposableBean {
private Integer energy;
@Override
public void afterPropertiesSet() throws Exception {
System.out.println("狮子已经充满能量。。。");
this.energy = 100;
}
@Override
public void destroy() throws Exception {
System.out.println("狮子已经消耗完所有能量。。。");
this.energy = 0;
}
@Override
public String toString() {
return "Lion{" + "energy=" + energy + '}';
}
}
InitializingBean
接口只有一个方法:afterPropertiesSet()
。在Spring
框架中,当一个bean
的所有属性都已经被设置完毕后,这个方法就会被调用。也就是说,这个bean
一旦被初始化,Spring
就会调用这个方法。我们可以在bean
的所有属性被设置后,进行一些自定义的初始化工作。
DisposableBean
接口也只有一个方法:destroy()
。当Spring
容器关闭并销毁bean
时,这个方法就会被调用。我们可以在bean
被销毁前,进行一些清理工作。
主程序:
package com.example.demo.application;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class DemoApplication {
public static void main(String[] args) {
System.out.println("Spring容器初始化开始");
AnnotationConfigApplicationContext context
= new AnnotationConfigApplicationContext("com.example.demo.bean");
System.out.println("Spring容器初始化完成。");
System.out.println("==================");
System.out.println("Spring容器准备关闭");
context.close();
System.out.println("Spring容器已关闭。");
}
}
运行结果:
4.2 三种生命周期并存
在Spring
框架中,控制Bean
生命周期的三种方式是:
- 使用
Spring
的init-method
和destroy-method
(在XML
配置或者Java
配置中自定义的初始化和销毁方法); - 使用
JSR-250
规范的@PostConstruct
和@PreDestroy
注解; - 实现
Spring
的InitializingBean
和DisposableBean
接口。
接下来我们测试一下,一个Bean
同时定义init-method
、destroy-method
方法,使用@PostConstruct
、@PreDestroy
注解,以及实现InitializingBean
、DisposableBean
接口,执行顺序是怎样的。
我们创建一个新的类Lion2
,并同时进行三种方式的生命周期控制:
需要运行的全部代码如下:
package com.example.demo.bean;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
@Component
public class Lion2 implements InitializingBean, DisposableBean {
private Integer energy;
public void open() {
System.out.println("init-method - 狮子开始行动。。。");
}
public void close() {
System.out.println("destroy-method - 狮子结束行动。。。");
}
@PostConstruct
public void gainEnergy() {
System.out.println("@PostConstruct - 狮子已经充满能量。。。");
this.energy = 100;
}
@PreDestroy
public void loseEnergy() {
System.out.println("@PreDestroy - 狮子已经消耗完所有能量。。。");
this.energy = 0;
}
@Override
public void afterPropertiesSet() throws Exception {
System.out.println("InitializingBean - 狮子准备行动。。。");
}
@Override
public void destroy() throws Exception {
System.out.println("DisposableBean - 狮子行动结束。。。");
}
}
接着,我们注册Lion2
:
package com.example.demo.configuration;
import com.example.demo.bean.Lion2;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class AnimalConfig {
@Bean(initMethod = "open", destroyMethod = "close")
public Lion2 lion2() {
return new Lion2();
}
}
然后让注解 IOC
容器驱动这个配置类,主程序如下:
package com.example.demo.application;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class DemoApplication {
public static void main(String[] args) {
System.out.println("Spring容器初始化开始");
AnnotationConfigApplicationContext context
= new AnnotationConfigApplicationContext("com.example.demo");
System.out.println("Spring容器初始化完成。");
System.out.println("==================");
System.out.println("Spring容器准备关闭");
context.close();
System.out.println("Spring容器已关闭。");
}
}
运行结果:
从上面的结果,我们可以得出以下结论,在Spring
框架中单实例Bean
的初始化和销毁过程有这样的执行顺序:
初始化顺序:@PostConstruct → InitializingBean → init-method
销毁顺序:@PreDestroy → DisposableBean → destroy-method
在初始化Bean
时,@PostConstruct
注解方法会首先被执行,然后是实现InitializingBean
接口的afterPropertiesSet
方法,最后是init-method
指定的方法。
在销毁Bean
时,@PreDestroy
注解方法会首先被执行,然后是实现DisposableBean
接口的destroy
方法,最后是destroy-method
指定的方法
结合前面说过的属性赋值(构造器方法和setter
方法),简单总结一下Spring Bean
生命周期的流程:
- 实例化(通过构造器方法);
- 设置
Bean
的属性(通过setter
方法); - 调用
Bean
的初始化方法(@PostConstruct
、afterPropertiesSet
方法或者init-method
指定的方法); Bean
可以被应用程序使用;- 当容器关闭时,调用
Bean
的销毁方法(@PreDestroy
、destroy
方法或者destroy-method
指定的方法)。
5. 原型Bean的生命周期
原型Bean
的创建和初始化过程与单例Bean
类似,但由于原型Bean
的性质,其生命周期与IOC
容器的生命周期并不相同。
这里展示一下需要的全部代码。
Lion2.java
package com.example.demo.bean;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
public class Lion2 implements InitializingBean, DisposableBean {
private Integer energy;
public void roar() {
System.out.println("The lion is roaring...");
}
public void rest() {
System.out.println("The lion is resting...");
}
@PostConstruct
public void gainEnergy() {
System.out.println("@PostConstruct - 狮子已经充满能量。。。");
this.energy = 100;
}
@PreDestroy
public void loseEnergy() {
System.out.println("@PreDestroy - 狮子已经消耗完所有能量。。。");
this.energy = 0;
}
@Override
public void afterPropertiesSet() throws Exception {
System.out.println("InitializingBean - 狮子准备行动。。。");
}
@Override
public void destroy() throws Exception {
System.out.println("DisposableBean - 狮子行动结束。。。");
}
}
然后在Spring
的Java
配置中声明并设定其为原型Bean
package com.example.demo.configuration;
import com.example.demo.bean.Lion2;
import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Scope;
@Configuration
public class PrototypeLifecycleConfiguration {
@Bean(initMethod = "roar", destroyMethod = "rest")
@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
public Lion2 lion() {
return new Lion2();
}
}
如果我们只是启动了IOC
容器,但并未请求Lion2
的实例,Lion Bean
的初始化不会立刻发生。也就是说,原型Bean
不会随着IOC
容器的启动而初始化。以下是启动容器但并未请求Bean
的代码:
package com.example.demo.application;
import com.example.demo.configuration.PrototypeLifecycleConfiguration;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class DemoApplication {
public static void main(String[] args) {
System.out.println("Spring容器初始化开始");
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(
PrototypeLifecycleConfiguration.class);
}
}
运行结果:
当我们明确请求一个Lion2
的实例时,我们会看到所有的初始化方法按照预定的顺序执行,这个顺序跟单例Bean
完全一致:
package com.example.demo.application;
import com.example.demo.bean.Lion2;
import com.example.demo.configuration.PrototypeLifecycleConfiguration;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class DemoApplication {
public static void main(String[] args) {
System.out.println("Spring容器初始化开始");
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(
PrototypeLifecycleConfiguration.class);
System.out.println("Ready to get a Lion instance...");
Lion2 lion = context.getBean(Lion2.class);
System.out.println("A Lion instance has been fetched...");
System.out.println("Lion instance is no longer needed, preparing to destroy...");
context.getBeanFactory().destroyBean(lion);
System.out.println("Lion instance has been destroyed...");
}
}
运行结果:
将原型Bean
和单例Bean
的三种生命周期进行对比后发现,调用IOC
容器的destroyBean()
方法销毁原型Bean
时,只有@PreDestroy
注解和DisposableBean
接口的destroy
方法会被触发,而被destroy-method
标记的自定义销毁方法并不会被执行。
从这里我们可以得出结论:在销毁原型Bean
时,Spring
不会执行由destroy-method
标记的自定义销毁方法,所以原型Bean
的destroy-method
的也有局限性。如果有重要的清理逻辑需要在Bean
销毁时执行,那么应该将这部分逻辑放在@PreDestroy
注解的方法或DisposableBean
接口的destroy
方法中。
6. Spring中控制Bean生命周期的三种方式总结
执行顺序 | 代码依赖性 | 容器支持 | 单实例Bean | 原型Bean | |
---|---|---|---|---|---|
init-method & destroy-method | 最后 | 较低(依赖于Spring Bean配置,不侵入业务代码) | xml、注解原生支持 | √ | 只支持 init-method |
@PostConstruct & @PreDestroy | 最先 | 中等(需要在业务代码中添加JSR规范的注解) | 注解原生支持,xml需开启注解驱动 | √ | √ |
InitializingBean & DisposableBean | 中间 | 较高(需要业务代码实现Spring特定接口) | xml、注解原生支持 | √ | √ |
欢迎一键三连~
有问题请留言,大家一起探讨学习
----------------------Talk is cheap, show me the code-----------------------
- 点赞
- 收藏
- 关注作者
评论(0)