Spring Bean 作用域和生命周期

Posted 2023-04-24

参考技术A

spring bean默认为单例，避免了对象的频繁创建与销毁，达到了bean对象的复用，性能高。

像表现层、业务层、数据层、工具类对象只需要调用方法，比较适合交给Spring IoC容器管理

但是像那种需要封装实例的域对象，因为会引发线程安全问题，不适合交给Spring IoC容器管理。

Spring 根据 Bean 的作用域来选择 Bean 的管理方式。

综上所述： 为了更好研究如何控制bean周期，下面案例中创建的bean默认都使用单例模式。

由于ApplicationContext类中没有关闭容器的方法，所以想要关闭容器需要用到ApplicationContext的子类——ClassPathXmlApplicationContext类。该类又有两种方法可以关闭容器

Bean 生命周期回调的方法主要有两种：

我们可以通过以下方式 2种方式自定义 Bean 的生命周期回调方法：

我们可以在 Spring Bean 的 Java 类中，通过实现 InitializingBean 和 DisposableBean 接口，指定 Bean 的生命周期回调方法。

注意 ：由于通过接口设置生命周期的方式会导致代码的耦合性过高，所以通常情况下，我们会通过xml设置生命周期。

通过 元素中的 init-method 和 destory-method 属性，指定 Bean 的生命周期回调方法。

Spring详解Bean的六种作用域执行流程生命周期

@TOC

---

Bean 作⽤域和⽣命周期

从前⾯的博客我们可以看出 Spring 是⽤来读取和存储 Bean，因此在 Spring 中 Bean 是最核⼼的操作资源，所以接下来我们深⼊学习⼀下 Bean 对象

---

通过⼀个案例来看 Bean 作⽤域的问题

假设现在有⼀个公共的 Bean，提供给 A ⽤户和 B ⽤户使⽤，然⽽在使⽤的途中 A ⽤户却 悄悄 地修改了公共 Bean 的数据，导致 B ⽤户在使⽤时发⽣了预期之外的逻辑错误。

被修改的 Bean 案例

公共 Bean：

@Component
public class Users 
    @Bean
    public User user1() 
        User user = new User();
        user.setId(1);
        user.setName("Java"); // 【重点：名称是 Java】
        return user;
   

A ⽤户使⽤时，进⾏了修改操作：

@Controller
public class BeanScopesController 
    @Autowired
    private User user1;
    public User getUser1() 
        User user = user1;
        System.out.println("Bean 原 Name：" + user.getName());
        user.setName("悟空"); // 【重点：进⾏了修改操作】
        return user;
   

B ⽤户再去使⽤公共 Bean 的时候：

@Controller
public class BeanScopesController2 
    @Autowired
    private   user1;
    public User getUser1() 
        User user = user1;
        return user;
   

打印 A ⽤户和 B ⽤户公共 Bean 的值：

public class BeanScopesTest 
    public static void main(String[] args) 
        ApplicationContext context = new
ClassPathXmlApplicationContext("spring-config.xml");

        BeanScopesController beanScopesController =
context.getBean(BeanScopesController.class);

        System.out.println("A 对象修改之后 Name：" +
beanScopesController.getUser1().toString());

        BeanScopesController2 beanScopesController2 =
context.getBean(BeanScopesController2.class);

        System.out.println("B 对象读取到的 Name：" +
beanScopesController2.getUser1().toString());

   

执⾏结果如下：

---

原因分析

---

作用域定义

限定程序中变量的可⽤范围叫做作⽤域，或者说在源代码中定义变量的某个区域就叫做作⽤域。

---

Bean 的 6 种作用域

Spring 容器在初始化⼀个 Bean 的实例时，同时会指定该实例的作⽤域。

Spring有 6 种作⽤域， 最后四种是基于 Spring MVC ⽣效的：

作用域	描述
singleton	单例作用域，在整个Spring IoC容器仅存在一个Bean实例，Bean以单例方式存在
prototype	原型作用域，每次从容器中调用Bean时，都返回一个新的实例。即每次调用getBean时，相当于执行newXxxBean方法
request	请求作用域，每次Http请求都会创建一个新的Bean
session	会话作用域，同一个Http Session共享一个Bean，不同Session使用不同的Bean
application	全局作用域，在一个Http Servlet Context中，定义一个Bean.
websocket	在一个WebSocket的生命周期中，定义一个Bean实例

---

1. 普通 Spring 环境：

---

① singleton

代码举例：

创建TestSingleton类作为bean:

package com;

import org.springframework.stereotype.Component;

@Component
public class TestSingleton 
    private String message;
    public void setMessage(String message)
        this.message  = message;
    
    public void getMessage()
        System.out.println("Your Message : " + message);
    

在测试类中同时尝试获取两个bean，看输出信息是否相同，相同即同一个实例：

import com.Controller.UserController;
import com.TestSingleton;
import com.User.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class App 
    public static void main(String[] args) 
        ApplicationContext context=new ClassPathXmlApplicationContext("a.xml");

        TestSingleton testSingleton_A=(TestSingleton)context.getBean("testSingleton");
        System.out.println("下面是第一个bean的信息：");
        testSingleton_A.setMessage("This is A!");
        testSingleton_A.getMessage();

        TestSingleton testSingleton_B=(TestSingleton)context.getBean("testSingleton");
        System.out.println("下面是第二个bean的信息：");
        testSingleton_B.getMessage();

    

输出：

下面是第一个bean的信息：
Your Message : This is A!
下面是第二个bean的信息：
Your Message : This is A!

---

② prototype

代码举例：

创建TestPrototype类作为bean，通过注解Scope将作用域类型设置为prototype:

package com;

import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

@Component
@Scope("prototype") // 注解生效
public class TestPrototype 
    private String message;
    public void setMessage(String message)
        this.message  = message;
    
    public void getMessage()
        System.out.println("Your Message : " + message);
    

在测试类中获取两个bean，看输出信息是否相同，相同即是同一个实例，不同则是不同的实例：

import com.TestPrototype;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class App 
    public static void main(String[] args) 
        ApplicationContext context=new ClassPathXmlApplicationContext("a.xml");

        TestPrototype testSingleton_A=(TestPrototype)context.getBean("testPrototype");
        System.out.println("下面是第一个bean的信息：");
        testSingleton_A.setMessage("This is A!");
        testSingleton_A.getMessage();

        TestPrototype testSingleton_B=(TestPrototype)context.getBean("testPrototype");
        System.out.println("下面是第二个bean的信息：");
        testSingleton_B.getMessage();

    

输出：

下面是第一个bean的信息：
Your Message : This is A!
下面是第二个bean的信息：
Your Message : null

---

2. Spring Web 环境：

---

在使用Web环境相关的作用域时，必须在Web容器中进行一些额外的配置：

• 如果使用的是Spring MVC框架，就不需这些配置，因为每一次http请求都会通过DispatcherServlet来处理，而DispatcherServlet中已经配置好了相关状态。
• 如果是低版本的web容器，需要在配置的XML文件中添加如下声明即可：

<web-app>
    ...
    <listener>
        <listener-class>
            org.springframework.web.context.request.RequestContextListener
        </listener-class>
    </listener>
    ...
</web-app>

还可以使用Spring中的RequestContextFilter或者ServletRequestListener和其他方式，这里不再详细介绍。

---

③ request

request是请求作用域

在进行使用时，也是在scope属性中声明：

<bean id="" class="" scope="request"/>

---

④ session

session是会话作用域

同一个Http Session(会话)之间共享一个bean，而不同的会话使用不同的bean.

在使用时，可以在scope属性中声明：

<bean id="user" class="" scope="session"/>

---

⑤ application

application是全局作用域。

使用方式：

<bean id="app" class="" scope="application"/>

假设bean的id为app，Spring容器会在整个web应用范围使用到app的时候创建一个新的实例。也就是说，appBean是在ServletContext级别的.。

---

单例作⽤域(singleton)和全局作⽤域(application)区别

---

如何设置 Bean 作用域

1. 通过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">

     //scope属性
    <bean id="SingletonBean" class="com.spring.demo.SingletonBean" scope="prototype">       </bean>

</beans>

---

2. 通过注解

在bean上添加注解：

package com.spring.demo;

import org.springframework.context.annotation.Scope;;
import org.springframework.stereotype.Component;

@Component("SingletonBean")
@Scope("prototype")
//@Scope("ConfigurableBeanFactory.SCOPE_PROTOTYPE")
public class SingletonBean 
    private String message;
    public void setMessage(String message)
        this.message  = message;
    
    public void getMessage()
        System.out.println("Your Message : " + message);
    

---

Bean 执行流程

---

Bean ⽣命周期

Bean的生命周期指一个Bean对象从“出生”到“销毁”的过程，可以表达为：

---

具体过程如下：

销毁容器的各种⽅法，如 @PreDestroy、DisposableBean 接⼝⽅法、destroy-method。

执⾏流程如下图所示：

---

1. 实例化和初始化的区别

---

2. ⽣命流程的“故事”

Bean 的⽣命流程看似繁琐，但咱们可以以⽣活中的场景来理解它。

⽐如我们现在需要买⼀栋房⼦，那 么我们的流程是这样的：

---

⽣命周期演示

import com.bit.service.UserService;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.beans.factory.annotation.Autowired;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

public class UserController10 implements BeanNameAware 

    @Autowired
    private UserService userService;

    @Override
    public void setBeanName(String s) 
        System.out.println("执行通知：" + s);
    

    // 初始化方法
    @PostConstruct
    public void postConstruct() 
        System.out.println("执行 @PostConstruct 方法");
    

    public void init()  // init() 方法名字可以随便起，只需要和 xml 中的名称保持一致即可
        System.out.println("执行 init 方法");
    

    @PreDestroy
    public void preDestroy() 
        System.out.println("执行 @PreDestroy");
    

    public void destroy() 
        System.out.println("执行 destroy 方法");
    

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"
       xmlns:content="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

    <!-- 配置 Spring 扫描的根路径（此根路径下的所有 Spring 存对象的注解才能生效） -->
    <content:component-scan base-package="com.bit"></content:component-scan>

    <beans>
        <bean id="userController10"
              class="com.bit.controller.UserController10"
              init-method="init" destroy-method="destroy"></bean>
    </beans>

</beans>

启动类：

/**
 * Spring 启动类（非必须，为了方便演示 Spring 的功能而创建）
 */
public class App 
    public static void main(String[] args) 
        // 1.先获取对象的
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
        UserController10 userController10 = context.getBean("userController10", UserController10.class);
        context.destroy(); // 销毁方法

    

效果如下：

---