javaEE进阶 - Spring 的 Bean 作用域 和 生命周期 - 细节狂魔

前言

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


Bean 的作用域

1、通过 一个案例 来看 Bean 作用域的问题

假设现在有一格公共的 Bean,提供给 A 用户 和 B 用户使用,然而在使用的途中 A 用户 却 “悄悄”地 修改来了公共 Bean 的数据,导致 B 用户在使用时发生了预期之外的逻辑错误。B用户:你真是一个老六!

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


1.1、被修改的 Bean 案例

未修改状态

通过方法注解@Bean,向 Spring 中 存储 一个 User 对象。

其内部属性,id 为 1, name 为 Java

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

使用 属性注入,获取到了 User 对象。
在 getUser1 方法中,通过 bean 提供的方法,将 bean对象内部的 name 属性值修改了。
将 Java 修改成了 悟空


B 用户再去使用 公共 Bean 的时候
@Controller
public class BeanScopesController2 {
    @Autowired
    private User user1;
    public User getUser1() {
        User user = user1;
        return user;
    }
}

注意!此时的 B 用户 对于 A 用户的修改 是知情的!
通过 getUser1 返回的 User 对象中的内容 并不是 B 用户预期的内容。


打印 A ⽤户和 B ⽤户公共 Bean 的值
public class BeanScopesTest {
    public static void main(String[] args) {
    // 1、获取 Spring 的 上下文对象
        ApplicationContext context = new
                ClassPathXmlApplicationContext("spring-config.xml");
    //2、使用 上下文对象 提供的 getBean 方法 来获取 bean
        BeanScopesController beanScopesController =
                context.getBean(BeanScopesController.class);
       // 调用 bean 中的方法
        System.out.println("A 对象修改之后 Name:" +
                beanScopesController.getUser1().toString());

    //2、使用 上下文对象 提供的 getBean 方法 来获取 bean
        BeanScopesController2 beanScopesController2 =
                context.getBean(BeanScopesController2.class);
     // 调用 bean 中的方法
        System.out.println("B 对象读取到的 Name:" +
                beanScopesController2.getUser1().toString());
    }
}

注意!我们是先调用 A 的执行方法。
因此,User 对象中的内容,已经被 A 修改。
B 在读取的时候,就会发现数据已然不对!
在这里插入图片描述


原因分析

操作以上问题的原因是:

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

为什么要使用单例模式?
就是为了提高性能!

你想想 相同的资源,我只创建一份,大家共享。
这样做,就可以节省空间。
而且,
不需要去 过多的构造一个生命周期 和销毁。
就是 对象的创建 与 销毁,这两个操作在执行的时候,都是需要占用系统资源的。
如果每个人来了,我都要给它 创建一个 对象,用完了,还需要关注它需不需要销毁。这样的话,系统的开销自然就很大。
如果他们共享一个资源,那不就节省了很多系统资源嘛!
程序执行的速度就可以提高。
这也是 为什么 Spring 默认是 单例模式、

那么,讲这个 和 我们的作用域又有什么关系呢?
来看下面的作用域分析


作用域分析

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

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

有的人可能很疑惑:为什么 Spring 要 将 作用域 称为 行为模式?

在 Spring 看来,所谓的 bean 的作用域,指的就是 bean 在 整个Spring框架中的某种行为。
比如:
单例模式,就是一种行为。
我们的 Bean 在 整个Spring 中,只存在一份!
这不就是 Bean 的一种行为 嘛!

另外,有单例,就会有多例。
下面我们就来看看 Bean 的 作用域有几类?


Bean 的 6 种 作用域

Spring 容器在初始化⼀个 Bean 的实例时,同时会指定该实例的作⽤域。
Spring有 6 种作⽤域,
最后四种是基于 Spring MVC ⽣效的:


1、singleton:单例作⽤域(默认)【共用一个对象】- Spring

官⽅说明:(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默认选择该作⽤域


2、prototype:原型作⽤域(多例作⽤域)【每回拿到的对象,都是刚new的,未改变的。】- Spring

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

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

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


3、request:请求作⽤域【针对每一次请求,都创建一个对象】- Spring MVC

官⽅说明:Scopes a single bean definition to the lifecycle of a single HTTP request. Thatis, 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(new一个新的对象)
场景:⼀次http的请求和响应的共享Bean
备注:限定SpringMVC中使⽤


4、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中使⽤

关于 会话,你们可以看Servlet这篇文章


5、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中使⽤


6、websocket:HTTP WebSocket 作⽤域【在 Spring WebSocket 项目中,才会涉及到的作用域类型】- 了解

官⽅说明:Scopes a single bean definition to the lifecycle of a WebSocket. Only valid in the context of a web-aware Spring ApplicationContext.
描述:在⼀个HTTP WebSocket的⽣命周期中,定义⼀个Bean实例
场景:WebSocket的每次会话中,保存了⼀个Map结构的头信息,将⽤来包裹客户端消息头。第⼀次初始化后,直到WebSocket结束都是同⼀个Bean。
备注:限定Spring WebSocket中使⽤


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

singleton 是 Spring Core 的作⽤域;application 是 Spring Web 中的作⽤域;
singleton 作⽤于 IoC 的容器,⽽ application 作⽤于 Servlet 容器。


设置作用域

回到 刚才 的 那个案例。

B 就是希望自己获取的 bean,里面的内容,没有被修改。
这就需要将 程序,从 单例模式 设置成 原型模式(多例模式)。
这样 获得的对象,独属于 B 自己的。
就不会受到别人操作的影响。

那么,问题来了:怎么设置作用域呢?
需要借助一个 @Scope 注解,并在参数中,设置对应的 作用域。
将上述注解,放在 @Bean 的 (上面 / 下面)。
如下所示:

@Component
public class Users {
    @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)// prototype - 原型作用域
    @Bean
    public User user1() {
        User user = new User();
        user.setId(1);
        user.setName("Java"); // 【重点:名称是 Java】
        return user;
    }
}

@Scope 标签既可以修饰方法,也可以修饰类。
@Scope 有两种设置方式

1、直接设置值:@Scope(“prototype”)

2、使用类似枚举的方式进行设置:@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)

ConfigurableBeanFactory 这是一个类,你可以理解为是一个 " 枚举类 "。
在这里插入图片描述


Spring 执行流程 和 Bean 的生命周期

接下来,咱们来看一下 Bean 执行原理 和 生命周期。


Spring 执行流程 / Spring 的生命周期

这里只是 Spring 的 启动 与 加载的流程。
在这里插入图片描述
总的来说:
先去启动容器,加载 xml 配置文件。
然后,扫描五大类注解,随后,将具有五大类注解的类,存入 Spring 当中。
如果 存入的过程中,存在属性的注入,就先执行属性的注入。
然后,再继续执行 类 的 实例化。
实例化之后,将其存入Spring 中。
上述的流程,知识初始化阶段。
如果说:我们处于 运行 阶段,相当于直接根据 URL 地址 去匹配到 相应的方法。
然后,执行它。
执行完之后,当我们停止 Tomcat,或者停止 项目的时候,就会把这些对象,给注销掉。
这就是 Spring项目 整个执行的大概流程(Spring的生命周期)。


Bean 的 生命周期【经典面试题】

所谓的⽣命周期指的是⼀个对象从诞⽣到销毁的整个⽣命过程,我们把这个过程就叫做⼀个对象的⽣命周期。

Bean 的⽣命周期分为以下 5 ⼤部分:

1.实例化 Bean(为 Bean 分配内存空间)

2.设置属性(Bean 注⼊和装配)

3.Bean 初始化

1、执行各种通知(各种Aware)
比如:
Spring在初始化 bean,是需要给 bean 赋予 id(name)。
而设置 beanName 成功的话,就会生成一个 beadNameAware 通知。

2、执行初始化的前置方法
前提:我们重新 前置方法,不然它按照源码来操作。

3、执行构造方法,两种执行方式。
  3.1、执行具有 @PostConstruct 注解的方法。【PostConstruct -> 初始化方法】
  3.2、执行 init-method 方法,是 Spring 中 配置文件里面 的 bean 标签所有具有的属性。在这里插入图片描述
这个 两个执行方法,是两个不同时期的产物。
@PostConstruct,是一种通过 注解 来初始化的方法。
init-method,是 xml 时代 的 初始化方法。
但是!它们描述的都是同一件事情 “ 初始化 ”。

它们两个执行的优先级:
这么说吧:如果 两种方法,同时存在。
先执行 @PostConstruct 注解的方法,然后执行 init-method 方法。
原因更简单,我们是使用的是高版本的版本,过去的东西终究会被淘汰!

4、执行初始化的后置方法

4.使⽤ Bean
5.销毁 Bean

销毁容器的各种方法,如 @PreDestroy,DisposableBean 接⼝⽅法,destroy-method
【 PS1:@PreDestroy 和 destroy-method 之间的关系,与 @PostConstruct 和 init-method 之间的关系,是一样的。】
【PS2:如果重写了 DisposableBean 接口方法,就会执行销毁 Bean】
【PS3:优先级:@PreDestroy > DisposableBean > destroy-method】

执行流程图

在这里插入图片描述


实例化和初始化的区别

实例化和属性设置是 Java 级别的系统“事件”,其操作过程不可⼈⼯⼲预和修改;
⽽初始化是给开发者提供的,可以在实例化之后,类加载完成之前进⾏⾃定义“事件”处理。

简单来说 实例化 就是 分配内存空间。
初始化,就是把我们一些参数,方法的具体实现逻辑。。。给加载进去。


⽣命流程的“故事”

Bean 的⽣命流程看似繁琐,但咱们可以 以⽣活中的场景 来理解它,⽐如我们现在需要买⼀栋房⼦,那么我们的流程是这样的:

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

⽣命周期演示
bean
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
@Component
public class BeanLifeComponent implements BeanNameAware {
    @PostConstruct
    public void postConstruct() {
        System.out.println("执⾏ PostConstruct()");
    }
    public void init() {
        System.out.println("执⾏ BeanLifeComponent init-method");
    }
    @PreDestroy
    public void preDestroy() {
        System.out.println("执⾏:preDestroy()");
    }
    public void setBeanName(String s) {
        System.out.println("执⾏了 setBeanName ⽅法:" + s);
    }
}

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">
<content:component-scan base-package="com.bit.component">
</content:component-scan>
<beans>
<bean id="beanLifeComponent"
class="com.bit.component.BeanLifeComponent" init-method="init"></bean>
</beans>
</beans>

调⽤类 / 启动类
import com.bit.controller.BeanLife;
import 
org.springframework.context.support.ClassPathXmlApplicationContext;
public class BeanLifeTest {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext context =
                new ClassPathXmlApplicationContext("spring-config.xml");
        BeanLife life = context.getBean(BeanLife.class);
        System.out.println("执⾏ main ⽅法");
// 执⾏销毁⽅法
        context.destroy();
    }
}

总结分析

在这里插入图片描述


思考:为什么要先设置属性在进⾏初始化呢?

也就将 第2部分 和 第3部分 的顺序,能不能打个颠倒?

@Controller
public class UserController {
    @Resource
    private UserService userService;
    @PostConstruct
    public void postConstruct() {
        userService.sayHi();
        System.out.println("执⾏ User Controller 构造⽅法");
    }
}

在上述的代码中,如果 先执行 第三步(初始化),后执行 第二步(设置属性)。
此时代码 会先执行 postConstruct 方法,【初始化方法】
而在这个方法中,它会调用 userService 属性变量。
但是!它还没有注入属性,因此,它还是一个 null 值。
那么!此时 初始化方法 这一调用,就会造成空指针异常!!!!

答案显而易见,第二步 和 第三步的位置 的执行顺序,能换吗?
不能!!!!


总结

本博文介绍了 Bean 的 6 种作⽤域:
1、 singleton:单例作⽤域
2、prototype:原型作⽤域(多例作⽤域)
3、 request:请求作⽤域
4、session:回话作⽤域
5、application:全局作⽤域
6、 websocket:HTTP WebSocket 作⽤域
其中前两种是 spring 核⼼作⽤域,⽽后 4 种是 spring mvc 中的作⽤域,也介绍了 spring 的执⾏流程和 bean 的⽣命周期,其中 bean 的作⽤域是最重要的知识点也是常⻅的⾯试题,⽽ bean ⼤的执⾏流程也⼀定要牢记。

评论 14
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Dark And Grey

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值