(目录)


Bean 作⽤域和⽣命周期

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


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

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

我们预期的结果是,公共 Bean 可以在各⾃的类中被修改,但不能影响到其他类。

被修改的 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());
        
   }
}

执⾏结果如下:

image-20220705165905132


原因分析

操作以上问题的原因是因为 Bean 默认情况下是单例状态(singleton),也就是所有⼈的使⽤的都是同⼀个对象,之前我们学单例模式的时候都知道,使⽤单例可以很⼤程度上提⾼性能,所以在 Spring 中Bean 的作⽤域默认也是 singleton 单例模式。


作用域定义

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

Bean 的作⽤域是指 Bean 在 Spring 整个框架中的某种⾏为模式

⽐如 singleton 单例作⽤域,就表 示 Bean 在整个 Spring 中只有⼀份,它是全局共享的,那么当其他⼈修改了这个值之后,那么另⼀个 ⼈读取到的就是被修改的值。


Bean 的 6 种作用域

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

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

  1. singleton:单例作⽤域

  2. prototype:原型作⽤域(多例作⽤域)

  3. request:请求作⽤域

  4. session:回话作⽤域

  5. application:全局作⽤域

  6. websocket:HTTP WebSocket 作⽤域

image-20220705224520715

作用域 描述
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实例

注意后 4 种状态是 Spring MVC 中的值,在普通的 Spring 项⽬中只有前两种

后四种是spring MVC中的值,仅适用于web的SpringWebApplicationContext环境中。


1. 普通 Spring 环境:


① singleton

  • 官⽅说明:(Default) Scopes a single bean definition to a single object instance for each Spring IoC container.

  • 描述:该作⽤域下的Bean在IoC容器中只存在⼀个实例获取Bean(即通过applicationContext.getBean等⽅法获取)及装配Bean(即通过@Autowired注⼊)都是同⼀ 个对象。

  • 场景:通常⽆状态的Bean使⽤该作⽤域。⽆状态表示Bean对象的属性状态不需要更新

  • 备注:Spring默认选择该作⽤域

  • Singleton是单例模式,就是在创建容器时就自动的创建了这个对象,无论是否使用,它都已经存在了,每次获取到的都是同一个对象。**而且singleton是spring的默认作用域(缺省作用域)**。

代码举例:

创建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

  • 官⽅说明:Scopes a single bean definition to any number of object instances.

  • 描述:每次对该作⽤域下的Bean的请求都会创建新的实例获取Bean(即通过applicationContext.getBean等⽅法获取)及装配Bean(即通过@Autowired注⼊)都是新的 对象实例

  • 场景:通常有状态的Bean使⽤该作⽤域

  • prototype是原型类型,在创建容器的时候并不会实例化对象,而是当我们尝试去获取一个bean时才会去创建一个对象,而且我们每次获取到的对象都不是同一个对象。

代码举例:

创建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 环境:

requestsessionapplication这三个作用域是基于Spring WebApplicationContext实现的,只有在web环境下才能使用(比如XmlWebApplicationContext中)

如果在普通的spring环境下,即常规的IOC容器(比如ClassPathXmlApplicationContext)中使用这些作用域,那么程序会抛出一个IllegalStateException异常,来表明使用了未知的作用域。

而在web环境下,比如使用Spring中的WebApplicationContext时,我们不仅可以使用singleton和prototype这两个作用域,还可以使用三个独有的作用域:request、session、application.


使用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是请求作用域

  • 官⽅说明:Scopes a single bean definition to the lifecycle of a single HTTP request. That is, each HTTP request has its own instance of a bean created off the back of a single bean definition. Only valid in the context of a web-aware Spring ApplicationContext.

  • 描述:每次http请求会创建新的Bean实例,类似于prototype

  • 场景:⼀次http的请求和响应的共享Bean

  • 备注:限定SpringMVC中使⽤

在进行使用时,也是在scope属性中声明:

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

假设这个bean的id是loginAction,Spring容器每一次用loginAction来处理Http请求时都会创建一个新的实例,即loginAction 这个bean的作用域是Http Request级别的。

当Http请求调用作用域级别为Request的bean时,每增加一个Http请求,Spring就会创建一个新的bean,当请求处理完成之后变回销毁这个bean,开发者可以任意的改变一个实例的状态,因为每一个bean之间都是根据独立的请求来的,其他实例根本看不到其他被开发者改变的实例的状态。


④ session

session是会话作用域

  • 官⽅说明:Scopes a single bean definition to the lifecycle of an HTTP Session. Only valid in the context of a web-aware Spring ApplicationContext.

  • 描述:在⼀个http session中,定义⼀个Bean实例

  • 场景:⽤户回话的共享Bean, ⽐如:记录⼀个⽤户的登陆信息

  • 备注:限定SpringMVC中使⽤

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

在使用时,可以在scope属性中声明:

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

假设bean的id是user,Spring容器每次调用user的时候,都会在一个会话中创建一个实例,即这个bean是Http Session级别的。

Session中的所有http请求共享一个Bean,每次用Session级别的bean处理会话时,每增加一个会话,都会创建一个新的实例。与上面的request一样,开发者可以随意修改bean的状态,因为每个bean都是根据单独的会话session来创建的,其他的bean无法看到这个bean的状态。


⑤ application

application是全局作用域

● 官⽅说明:Scopes a single bean definition to the lifecycle of a ServletContext. Only valid in the context of a web-aware Spring ApplicationContext.

● 描述:在⼀个http servlet Context中,定义⼀个Bean实例

● 场景:Web应⽤的上下⽂信息,⽐如:记录⼀个应⽤的共享信息

备注:限定SpringMVC中使⽤

使用方式:

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

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


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

  • singleton 是 Spring Core 的作⽤域;application 是 Spring Web 中的作⽤域;

  • singleton 作⽤于 IoC 的容器,⽽ application 作⽤于 Servlet 容器。


如何设置 Bean 作用域

1. 通过xml配置文件

在xml配置文件中,直接设置bean元素的scope属性即可。

<?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上添加注解:

  1. 直接设置值:@Scope("prototype")
  2. 使用枚举设置:@Scope("ConfigurableBeanFactory.SCOPE_PROTOTYPE")

image-20220705225528010

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);
    }
}

@Component(“SingletonBean”)标识这个类是一个bean,@Scope(“prototype”)标识这个bean的作用域为prototype类型。


Bean 执行流程

image-20220705230812084

Bean 执⾏流程(Spring 执⾏流程):

启动 Spring 容器 -> 实例化 Bean(分配内存空间,从⽆到有)-> Bean 注册到 Spring 中(存操作) -> 将 Bean 装配到需要的类中(取操作)。

image-20220705230739691


Bean ⽣命周期

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

Bean的定义——>Bean的初始化——>Bean的使用——>Bean的销毁.


具体过程如下:

  1. 实例化Bean,为Bean分配一些内存空间。

  2. 设置属性,注入或者装配Bean

  3. 进行初始化:

    • 实现各种通知(Aware)方法,如BeanNameAware、BeanFactoryAware、BeanFactoryAware、ApplicationContextAware等
    • 执行BeanPostProcessor初始化前置方法
    • 执行@PostConstruct初始化方法,注入依赖后执行
    • 执行自定义的inti-method方法(可有可无)
    • 执行BeanPostProcessor初始化后置方法。
  4. 使用Bean

  5. 销毁Bean

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

image-20220705231655218

执⾏流程如下图所示:

image-20220705231230614


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

实例化和属性设置是 Java 级别的系统“事件”,其操作过程不可⼈⼯⼲预和修改

初始化是给 开发者提供的,可以在实例化之后,类加载完成之前进⾏⾃定义“事件”处理。


2. ⽣命流程的“故事”

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

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

  1. 先买房(实例化,从⽆到有)
  2. 装修(设置属性)
  3. 买家电,如洗⾐机、冰箱、电视、空调等([各种]初始化)
  4. ⼊住(使⽤ Bean)
  5. 卖出去(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(); // 销毁方法

    }
}

效果如下:

image-20220705231655218