(目录)

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

执⾏结果如下：

【Spring】详解Bean的六种作用域、执行流程、生命周期Bean 作⽤域和⽣命周期通过⼀个案例来看 Bean 作⽤域的问题作用域定义Bean 的 6 种作用域如何设置 Bean 作用域Bean 执行流程Bean ⽣命周期

原因分析

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

作用域定义

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

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

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

Bean 的 6 种作用域

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

Spring有 6 种作⽤域，

最后四种是基于 Spring MVC ⽣效的

：

singleton：单例作⽤域

prototype：原型作⽤域（多例作⽤域）

request：请求作⽤域

session：回话作⽤域

application：全局作⽤域

websocket：HTTP WebSocket 作⽤域

作用域	描述
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的Spring
WebApplicationContext 环境中。

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 环境：

request 、 session 、 application 这三个作用域是 基于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上添加注解：

直接设置值：@Scope("prototype")

使用枚举设置：@Scope("ConfigurableBeanFactory.SCOPE_PROTOTYPE")

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 执行流程

Bean 执⾏流程（Spring 执⾏流程）：

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

Bean ⽣命周期

Bean的生命周期

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

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

具体过程如下：

实例化Bean，为Bean分配一些内存空间。

设置属性，注入或者装配Bean

进行初始化：

实现各种通知（Aware）方法，如BeanNameAware、BeanFactoryAware、BeanFactoryAware、ApplicationContextAware等

执行 BeanPostProcessor 初始化前置方法

执行@PostConstruct初始化方法，注入依赖后执行

执行自定义的inti-method方法（可有可无）

执行 BeanPostProcessor 初始化后置方法。

使用Bean

销毁Bean

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

执⾏流程如下图所示：

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

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

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

2. ⽣命流程的“故事”

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

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

先买房（实例化，从⽆到有）

装修（设置属性）

买家电，如洗⾐机、冰箱、电视、空调等（[各种]初始化）

⼊住（使⽤ Bean）

卖出去（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(); // 销毁方法

    }
}

【Spring】详解Bean的六种作用域、执行流程、生命周期Bean 作⽤域和⽣命周期通过⼀个案例来看 Bean 作⽤域的问题作用域定义Bean 的 6 种作用域如何设置 Bean 作用域Bean 执行流程Bean ⽣命周期

Bean 作⽤域和⽣命周期

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

作用域定义

Bean 的 6 种作用域

1. 普通 Spring 环境：

① singleton

② prototype

2. Spring Web 环境：

③ request

④ session

⑤ application

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

如何设置 Bean 作用域

1. 通过xml配置文件

2. 通过注解

Bean 执行流程

Bean ⽣命周期

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

2. ⽣命流程的“故事”

继续阅读

MyBatis-Plus 之AR模式

驯服烂代码_驯服Tomcat：Tomcat 5的过滤技巧

基于Springboot+VUE+Mysql的大学生校园疫情防控管理系统

Using MessageConverter

驯服烂代码_C＃中的驯服配置

Spring Cloud整合Sleuth，当请求完成后，Zipkin没有链路信息

JAVA自学之路——马士兵

Rabbitmq命令行手动创建队列

整合 Spring 开发框架及服务端技术

SSM整合02---Spring-SpringMVC层一、添加web框架支持二、web.xml三、spring-mvc.xml

SSM框架（二）------------表现层的SpringMVC

Intellij idea基于Maven 的SSM 框架整合

Spring数据和Redis

SpringMVC的启动过程源码分析1 SpringMVC 配置XML的方式启动2 SpringMVC纯注解模式启动

Java Spring 框架

SpringCloud微服务（四）之ribbon笔记ribbon是什么？入门案例自定义均衡负载算法