SpringIOC容器Bean的作用域及生命周期实例

目录

• bean作用域
• 1. 默认单实例
• 2. 设置多实例
• bean生命周期
• 一、生命周期过程示例
• 二、更完整的过程
• 1. 创建后置处理器

bean作用域

bean的作用域，其实就是设置创建 bean 的实例是属于单实例，还是多实例。

1. 默认单实例

默认情况下，创建的 bean 是单实例对象。

比如，用之前的代码为例：

@Test
    public void testCollection2() {
        ApplicationContext context =
                new ClassPathXmlApplicationContext(\"bean2.xml\");
        Book book = context.getBean(\"book\", Book.class);
        Book book2 = context.getBean(\"book\", Book.class);
        System.out.println(book);
        System.out.println(book2);
    }

在测试方法中，创建了 2 个 Book 类型的实例 book 和 book2，默认情况下应该是单实例，打印出来的地址应该一致。

com.pingguo.spring5.collectiontype.Book@4ae82894
com.pingguo.spring5.collectiontype.Book@4ae82894
Process finished with exit code 0

地址一致。

2. 设置多实例

在配置文件中的 bean 标签里，有一个属性 scope 是用来设置单实例和多实例的。

scope 有多个值：

singleton：也是默认值，表示单实例对象。 

prototype：表示多实例对象。 

request：每次 http 请求都会创建一个新的 bean，仅适用于 WebApplicationContext 环境。 

session：同一个 http session 共享一个 bean，不同的 session 使用不同的 bean，仅适用于 WebApplicationContext 环境。

而最常用的有 2 个：singleton 和 prototype。

现在把上述的示例代码改成多实例的，那么配置文件中增加 scope="prototype"：

<bean id=\"book\" class=\"com.pingguo.spring5.collectiontype.Book\" scope=\"prototype\">
        <property name=\"list\" ref=\"bookList\"></property>
    </bean>

再次运行测试方法：

com.pingguo.spring5.collectiontype.Book@543788f3
com.pingguo.spring5.collectiontype.Book@6d3af739
Process finished with exit code 0

可以看到，2个对象地址不同。

此外，singleton 和 prototype 还有 1 个区别需要注意：

scope 值为 singleton ：加载 spring 配置文件的时候，就会创建单例对象。

scope 值为 prototype ：加载配置文件时候不创建，而是在调用 getBean 方法时候创建多个实例对象。

bean生命周期

bean 的生命周期是指，从对象创建到对象销毁的过程。

过程如下：

• 通过构造器创建 bean 实例(比如，无参数构造)。
• 为 bean 的属性设置值和对其他 bean 的引用(比如，调用set方法)。
• 调用 bean 的初始化方法(需要进行配置初始化的方法)。
• bean 可以使用了(比如，对象被获取到了)。
• 当容器关闭，调用 bean 的销毁的方法(需要进行配置销毁的方法)。

一、生命周期过程示例

新建一个类 Orders，并且在配置文件中写好 bean 标签。然后根据上面的步骤，依次写好打印输出。

package com.pingguo.spring5.bean;
public class Orders {
    public Orders() {
        System.out.println(\"第一步：执行无参构造方法创建 bean 的实例\");
    }
    private String orderName;
    public void setOrderName(String orderName) {
        this.orderName = orderName;
        System.out.println(\"第二步：调用 set 方法设置属性值\");
    }
    // 创建执行的初始化方法，需要在配置文件中配置调用
    public void initMethod() {
        System.out.println(\"第三步：执行初始化方法\");
    }
    // 创建 bean 销毁方法，需要在配置文件中配置调用
    public void destroyMethod() {
        System.out.println(\"第五步：执行销毁的方法\");
    }
}

注意：

第四步，是在测试方法里调用时候走到的。

初始化方法和销毁方法，需要在配置文件中进行配置，使用 init-method和destroy-method。

<?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 id=\"orders\" class=\"com.pingguo.spring5.bean.Orders\"
          init-method=\"initMethod\"
          destroy-method=\"destroyMethod\">
        <property name=\"orderName\" value=\"苹果\"></property>
    </bean>
</beans>

现在添加一个测试函数来执行一下：

@Test
    public void test4() {
        ClassPathXmlApplicationContext context =
                new ClassPathXmlApplicationContext(\"bean4.xml\");
        Orders orders = context.getBean(\"orders\", Orders.class);
        System.out.println(\"第四步：获取创建的 bean 实例对象\");
        System.out.println(orders);
        // 手动让 bean 实例销毁
        context.close();
    }

注意这里是用的 ClassPathXmlApplicationContext ，因为close()方法在这个类下面。

而 ClassPathXmlApplicationContext是ApplicationContext的实现类。

ok，执行测试方法 test4():

第一步：执行无参构造方法创建 bean 的实例
第二步：调用 set 方法设置属性值
第三步：执行初始化方法
第四步：获取创建的 bean 实例对象
com.pingguo.spring5.bean.Orders@43738a82
第五步：执行销毁的方法
Process finished with exit code 0

二、更完整的过程

其实更完整的过程，还有 2 个步骤，这个2个过程叫做 bean 的后置处理器。

分别会在 上述 5 步骤中的第 3 步的前后调用，所以 7 个步骤现在应该是这样的：

• 通过构造器创建 bean 实例(比如，无参数构造)。
• 为 bean 的属性设置值和对其他 bean 的引用(比如，调用set方法)。
• 把 bean 实例传递给后置处理器的一个方法。
• 调用 bean 的初始化方法(需要进行配置初始化的方法)。
• 把 bean 实例传递给后置处理器的另一个方法。
• bean 可以使用了(比如，对象被获取到了)。
• 当容器关闭，调用 bean 的销毁的方法(需要进行配置销毁的方法)。

现在看下添加后置处理器的效果：

1. 创建后置处理器

创建类，实现接口 BeanPostProcessor 来创建后置处理器。

package com.pingguo.spring5.bean;
import org.springframework.beans.factory.config.BeanPostProcessor;
public class MyBeanPost implements BeanPostProcessor {
}

点进去 BeanPostProcessor 会看到有2个方法，这就是后置处理器过程中先后调用到的方法：

postProcessBeforeInitialization：初始化之前调用postProcessAfterInitialization：初始化之后调用

现在手动在类中实现这2个方法：

package com.pingguo.spring5.bean;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
public class MyBeanPost implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println(\"执行初始化之前的方法\");
        return bean;
    }
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println(\"执行初始化之后的方法\");
        return bean;
    }
}

还没结束，现在还需要在配置文件中配置后置处理器：

<!--配置后置处理器-->
    <bean id=\"myBeanPost\" class=\"com.pingguo.spring5.bean.MyBeanPost\"></bean>

配置好后，当前配置文件里的所有 bean 都会走这个后置处理器。

执行测试函数：

这个就是完整的生命周期。

以上就是SpringIOC容器Bean的作用域及生命周期实例的详细内容，更多关于SpringIOC Bean作用域生命周期的资料请关注其它相关文章！