Spring高手之路5——彻底掌握Bean的生命周期

以你之姓@ 2023-10-12 14:21 7阅读 0赞

#### 文章目录 ####

*  1. 理解Bean的生命周期
 *   *  1.1 生命周期的各个阶段
 *  2. 理解init-method和destroy-method
 *   *  2.1 从XML配置创建Bean看生命周期
     *  2.2 从配置类注解配置创建Bean看生命周期
     *  2.3 初始化和销毁方法的特性
     *  2.4 探究Bean的初始化流程顺序
 *  3. @PostConstruct和@PreDestroy
 *   *  3.1 示例：@PostConstruct和@PreDestroy的使用
     *  3.2 初始化和销毁——注解和init-method共存对比
 *  4. 实现InitializingBean和DisposableBean接口
 *   *  4.1 示例：实现InitializingBean和DisposableBean接口
     *  4.2 三种生命周期并存
 *  5. 原型Bean的生命周期
 *  6. Spring中控制Bean生命周期的三种方式总结

## 1. 理解Bean的生命周期 ##

### 1.1 生命周期的各个阶段 ###

在`Spring IOC`容器中，`Bean`的生命周期大致如下：

1.  实例化：当启动`Spring`应用时，`IOC`容器就会为在配置文件中声明的每个`<bean>`创建一个实例。
2.  属性赋值：实例化后，`Spring`就通过反射机制给`Bean`的属性赋值。
3.  调用初始化方法：如果`Bean`配置了初始化方法，`Spring`就会调用它。初始化方法是在`Bean`创建并赋值之后调用，可以在这个方法里面写一些业务处理代码或者做一些初始化的工作。
4.  `Bean`运行期：此时，`Bean`已经准备好被程序使用了，它已经被初始化并赋值完成。
5.  应用程序关闭：当关闭`IOC`容器时，`Spring`会处理配置了销毁方法的`Bean`。
6.  调用销毁方法：如果`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容器已关闭。");
        }
    }

运行结果

![在这里插入图片描述][1c254b2e47bc44258fc83a0fe7808f55.png]

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

运行结果

![在这里插入图片描述][53bf17db9935427fb8ced211207d8fcd.png]

注意：在`Spring`中，如果在`Java`配置中定义了一个`Bean`，并在`XML`中定义了一个相同`id`或`name`的`Bean`，那么最后注册的那个`Bean`会覆盖之前注册的，这取决于配置文件加载顺序，无论在`Java`配置中还是`XML`配置中定义的`initMethod`或`destroyMethod`，最后生效的总是后加载的配置中定义的。

**“`init-method`”是指定初始化回调方法的属性的统称，无论它是在`XML`配置还是`Java`配置中使用。同样地，“`destroy-method`”是指定销毁回调方法的属性的统称。后文我们讲解多种声明周期共存的时候，将延续这种说法。**

### 2.3 初始化和销毁方法的特性 ###

在`Spring`框架中配置`Bean`的初始化和销毁方法时，需要按照`Spring`的规范来配置这些方法，否则`Spring`可能无法正确地调用它们。下面给每个特性提供一个解释和示例：

1.  方法的访问权限无限制：无论方法是`public`、`protected`、`private`，还是`default`（包私有），`Spring`都可以调用。`Spring`通过反射来调用这些方法，所以它可以忽略`Java`的访问权限限制。示例：

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

在上述代码中，即使`init`方法是`private`的，`Spring`也可以正常调用。

1.  方法没有参数：由于`Spring`不知道需要传递什么参数给这些方法，所以这些方法不能有参数。示例：

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

`Spring`允许这些方法具有参数，`Spring`容器会尝试使用它的自动装配特性，通过类型或名称匹配找到合适的`bean`来作为参数进行调用。但是如果`Spring`无法找到匹配的`bean`或有多个匹配的`bean`，那么会在应用启动时抛出异常。

1.  方法没有返回值：由于返回的值对`Spring`来说没有意义，所以这些方法不应该有返回值。示例：

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

在上述代码中，`init`方法是`void`的，如果让此方法返回一个值，如`public String init()`，那么`Spring`将忽略此返回值。

1.  方法可以抛出异常：如果在初始化或销毁过程中发生错误，这些方法可以抛出异常来通知`Spring`。示例：

public class MyBean {
        
        public void init() throws Exception {
        
            // 初始化代码
            if (somethingGoesWrong) {
        
                throw new Exception("Initialization failed.");
            }
        }
    }

在上述代码中，如果在`init`方法中的初始化代码出错，它会抛出一个异常。不管是调用初始化还是销毁方法，只要抛出了异常（无论是检查型异常还是未检查型异常），这些异常将被`Spring`容器捕获并封装为`BeanCreationException`或`BeanDestructionException`后抛出，这会导致`Bean`的创建或销毁过程失败。

1.  方法不应是静态的：由于`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容器已关闭。");
        }
    }

运行结果

![在这里插入图片描述][78476bdf34e94a38984d855d00f8b7a4.png]

我们可以得出结论：**在`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容器已关闭。");
        }
    }

运行结果

![在这里插入图片描述][a45d03097a65439aa9dfa414f44020d0.png]

这里可以看到`@PostConstruct`和`@PreDestroy`注解正确地应用在了`Lion`的初始化和销毁过程中。

注意：  
  `@PostConstruct`和`@PreDestroy`可用于任何`Java`类，初始化和销毁方法与`init-method`和`destroy-method`类似，但也有一定的区别。

1.  这些方法**必须**是非静态的，否则`Spring`容器在启动或销毁时会抛出`BeanCreationException`或`BeanDestructionException`异常，导致创建或销毁`bean`失败。
2.  这些方法推荐无参数，与`init-method`和`destroy-method`的行为类似。
3.  这些方法推荐无返回值，与`init-method`和`destroy-method`的行为类似。
4.  可以是任何访问级别，与`init-method`和`destroy-method`的行为类似。
5.  可以抛出异常，与`init-method`和`destroy-method`的行为类似。
6.  **不能被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容器已关闭。");
        }
    }

运行结果

![在这里插入图片描述][715c6be3374d43a7a0c4ad41e810ffab.png]

**这里可以看到`@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容器已关闭。");
        }
    }

运行结果：

![在这里插入图片描述][9c579918b26c44fda5af3c7a65444fad.png]

### 4.2 三种生命周期并存 ###

在`Spring`框架中，控制`Bean`生命周期的三种方式是：

1.  使用`Spring`的`init-method`和`destroy-method`（在`XML`配置或者`Java`配置中自定义的初始化和销毁方法）；
2.  使用`JSR-250`规范的`@PostConstruct`和`@PreDestroy`注解；
3.  实现`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容器已关闭。");
        }
    }

运行结果：

![在这里插入图片描述][33e55be7ca894d3cadabd8bd5cc6a4b3.png]

从上面的结果，我们可以得出以下结论，在`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`生命周期的流程：

1.  **实例化（通过构造器方法）；**
2.  **设置`Bean`的属性（通过`setter`方法）；**
3.  调用`Bean`的初始化方法（`@PostConstruct`、`afterPropertiesSet`方法或者`init-method`指定的方法）；
4.  `Bean`可以被应用程序使用；
5.  当容器关闭时，调用`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);
        }
    }

运行结果：

![在这里插入图片描述][111f8e55d4244f1185c8c40472e17ba8.png]

当我们明确请求一个`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...");
        }
    }

运行结果：

![在这里插入图片描述][730df47202d047388f8134c7567e8339.png]

将原型`Bean`和单例`Bean`的三种生命周期进行对比后发现，调用`IOC`容器的`destroyBean()`方法销毁原型`Bean`时，只有`@PreDestroy`注解和`DisposableBean`接口的`destroy`方法会被触发，而被`destroy-method`标记的自定义销毁方法并不会被执行。

从这里我们可以得出结论：在销毁原型`Bean`时，`Spring`不会执行由`destroy-method`标记的自定义销毁方法，所以原型`Bean`的`destroy-method`的也有局限性。如果有重要的清理逻辑需要在`Bean`销毁时执行，那么应该将这部分逻辑放在`@PreDestroy`注解的方法或`DisposableBean`接口的`destroy`方法中。

--------------------

## 6. Spring中控制Bean生命周期的三种方式总结 ##

<table> 
 <thead> 
  <tr> 
   <th></th> 
   <th>执行顺序</th> 
   <th>代码依赖性</th> 
   <th>容器支持</th> 
   <th>单实例Bean</th> 
   <th>原型Bean</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>init-method &amp; destroy-method</td> 
   <td>最后</td> 
   <td>较低（依赖于Spring Bean配置，不侵入业务代码）</td> 
   <td>xml、注解原生支持</td> 
   <td>√</td> 
   <td>只支持 init-method</td> 
  </tr> 
  <tr> 
   <td>@PostConstruct &amp; @PreDestroy</td> 
   <td>最先</td> 
   <td>中等（需要在业务代码中添加JSR规范的注解）</td> 
   <td>注解原生支持，xml需开启注解驱动</td> 
   <td>√</td> 
   <td>√</td> 
  </tr> 
  <tr> 
   <td>InitializingBean &amp; DisposableBean</td> 
   <td>中间</td> 
   <td>较高（需要业务代码实现Spring特定接口）</td> 
   <td>xml、注解原生支持</td> 
   <td>√</td> 
   <td>√</td> 
  </tr> 
 </tbody> 
</table>

--------------------

欢迎一键三连~  
  
有问题请留言，大家一起探讨学习  
  
\----------------------Talk is cheap, show me the code-----------------------

[1c254b2e47bc44258fc83a0fe7808f55.png]: https://img-blog.csdnimg.cn/1c254b2e47bc44258fc83a0fe7808f55.png
[53bf17db9935427fb8ced211207d8fcd.png]: https://img-blog.csdnimg.cn/53bf17db9935427fb8ced211207d8fcd.png
[78476bdf34e94a38984d855d00f8b7a4.png]: https://img-blog.csdnimg.cn/78476bdf34e94a38984d855d00f8b7a4.png
[a45d03097a65439aa9dfa414f44020d0.png]: https://img-blog.csdnimg.cn/a45d03097a65439aa9dfa414f44020d0.png
[715c6be3374d43a7a0c4ad41e810ffab.png]: https://img-blog.csdnimg.cn/715c6be3374d43a7a0c4ad41e810ffab.png
[9c579918b26c44fda5af3c7a65444fad.png]: https://img-blog.csdnimg.cn/9c579918b26c44fda5af3c7a65444fad.png
[33e55be7ca894d3cadabd8bd5cc6a4b3.png]: https://img-blog.csdnimg.cn/33e55be7ca894d3cadabd8bd5cc6a4b3.png
[111f8e55d4244f1185c8c40472e17ba8.png]: https://img-blog.csdnimg.cn/111f8e55d4244f1185c8c40472e17ba8.png
[730df47202d047388f8134c7567e8339.png]: https://img-blog.csdnimg.cn/730df47202d047388f8134c7567e8339.png