Spring中Bean的生命周期原理解析：实例化、属性赋值、初始化、运行期和销毁_Java

1. 理解bean的生命周期

在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容器已关闭。");
    }
}

运行结果：

在上述 xml 配置文件中，使用 <bean> 标签向 spring ioc 容器中注册了一个 lion 类型的 bean。

<bean> 标签的核心作用

<bean> 标签用于声明一个由 spring 容器管理的对象，其中：

class 属性用于指定 bean 的全限定类名；
spring 在容器启动时，会根据该配置创建并管理该对象的生命周期。

init-method 与 destroy-method 的含义

在 <bean> 标签中，定义了两个非常关键的属性：

init-method="init"
destroy-method="destroy"

init-method 指定 bean 初始化完成后要执行的方法 → 当 bean 被实例化并完成属性注入后，spring 会自动调用 init() 方法
destroy-method 指定 bean 被销毁前要执行的方法 → 当 ioc 容器关闭时，spring 会自动调用 destroy() 方法

这两个方法无需实现任何接口，只需在类中定义普通方法即可。

property 标签的作用

<property name="name" value="simba"/>

用于给 bean 的属性进行依赖注入
spring 在调用初始化方法之前，会先完成属性赋值
这也是为什么在 init() 方法中可以直接使用 name 属性

控制台输出与生命周期验证

当 ioc 容器启动时，如果在 init() 方法中输出类似：

simba has been initialized...

说明 初始化方法已成功被 spring 调用。

当程序执行 context.close() 或应用正常关闭时，如果看到：

simba has been destroyed...

说明 销毁方法已成功被 spring 调用。

生命周期整体过程总结

整个 bean 生命周期可以总结为：

ioc 容器启动
spring 根据 xml 配置创建 bean 实例
完成属性注入（如 name = simba）
调用 init-method 指定的初始化方法
bean 进入可使用状态
ioc 容器关闭
调用 destroy-method 指定的销毁方法
所有 bean 销毁完成，ioc 容器关闭

小结

在 ioc 容器初始化完成之前，bean 默认已经被创建并完成了初始化操作；当容器关闭时，spring 会先销毁所有受其管理的 bean，最后再销毁整个 ioc 容器。

通过这个简单的 xml 示例，可以直观地看到 spring 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 可能无法按预期触发生命周期回调。下面从几个常见特性出发，对这些方法的使用规则进行说明，并配合示例进行解释。

方法的访问权限不受限制

初始化方法和销毁方法在访问权限上没有强制要求，无论是 public、protected、private，还是默认（包私有）权限，spring 都可以正常调用。

这是因为 spring 底层是通过反射机制来执行这些方法的，因此不会受到 java 访问控制符的限制。

示例：

public class mybean {
private void init() {// 初始化代码
    }
}

在上述示例中，即使 init() 方法被定义为 private，spring 依然能够在 bean 初始化阶段正确调用该方法。

方法通常不应包含参数

在默认情况下，spring 并不知道应该向初始化或销毁方法传递哪些参数，因此这些方法通常不应定义参数。

示例：

public class mybean {
public void init() {// 初始化代码
    }
}

需要注意的是，spring 并非完全禁止带参数的方法。如果方法定义了参数，spring 容器会尝试利用自动装配机制，按照类型或名称为参数匹配对应的 bean 并进行注入。

但如果：

无法找到匹配的 bean，或
存在多个符合条件的 bean，

那么 spring 会在应用启动阶段抛出异常，导致容器初始化失败。因此在实际开发中，一般不推荐在初始化或销毁方法中使用参数。

方法不应有返回值

初始化方法和销毁方法的返回值对 spring 容器来说没有任何实际意义，因此这些方法通常应定义为 void 类型。

示例：

public class mybean {
public void init() {// 初始化代码
    }
}

即使将方法声明为带返回值的形式，例如：

public string init() {return "success";
}

spring 也会直接忽略该返回值，不会对其进行任何处理。

方法允许抛出异常

在初始化或销毁过程中，如果发生错误，这些方法是允许抛出异常的，用于向 spring 容器明确地反馈失败信息。

示例：

public class mybean {
public void init() throws exception {// 初始化代码
        if (somethinggoeswrong) {throw new exception("initialization failed.");
        }
    }
}

当初始化或销毁方法抛出异常（无论是检查型异常还是运行时异常）时，spring 容器都会捕获该异常，并将其封装为 beancreationexception 或 beandestructionexception 后再次抛出，从而导致 bean 的创建或销毁过程失败。

方法不应定义为静态方法

初始化方法和销毁方法本质上是作用于 bean 实例生命周期的，而静态方法属于类级别，不依赖于具体实例，因此并不适合作为生命周期回调方法。

示例：

public class mybean {
public static void init() {// 初始化代码
    }
}

如果将初始化或销毁方法定义为 static，spring 并不会立即报错，但这种做法违背了生命周期方法应当绑定到 bean 实例的设计原则，也不符合实际使用场景。

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容器已关闭。");
    }
}

运行结果

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;

@componentpublic class lion {
   

    private string name;

    public void setname(string name) {
   
        this.name = name;
    }

    @postconstructpublic void init() {
   
        system.out.println("lion is going through init.");
    }

    @predestroypublic void destroy() {
   
        system.out.println("lion is going through destroy.");
    }

    @overridepublic 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...");
    }
}

运行结果：

可以看出：

在对 prototype bean（原型 bean） 与 singleton bean（单例 bean） 的三种销毁方式进行对比实验后可以发现：当通过 ioc 容器的 destroybean() 方法手动销毁原型 bean 时，只有使用 @predestroy 注解标注的方法以及实现了 disposablebean 接口的 destroy() 方法会被正常调用，而通过 destroy-method 属性指定的自定义销毁方法并不会被执行。

由此可以得出结论：在原型 bean 的销毁过程中，spring 并不会触发由 destroy-method 配置的自定义销毁逻辑。这也说明，destroy-method 方式在原型 bean 场景下存在一定的局限性。

因此，如果 bean 在销毁阶段包含关键的资源释放或清理逻辑，更稳妥的做法是将这些逻辑放在 @predestroy 注解的方法中，或者实现 disposablebean 接口的 destroy() 方法，以确保在原型 bean 被销毁时能够得到正确执行。

6. spring中控制bean生命周期的三种方式总结

	执行顺序	代码依赖性	容器支持	单实例bean	原型bean
init-method & destroy-method	最后	较低（依赖于spring bean配置，不侵入业务代码）	xml、注解原生支持	√	只支持 init-method
@postconstruct & @predestroy	最先	中等（需要在业务代码中添加jsr规范的注解）	注解原生支持，xml需开启注解驱动	√	√
initializingbean & disposablebean	中间	较高（需要业务代码实现spring特定接口）	xml、注解原生支持	√	√