从前面的博客我们可以看出
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 User 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("springconfig.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());
}
}
执行结果如下:
![](https://i-blog.csdnimg.cn/blog_migrate/a4b9191c2ec0988f14085e4180f0635a.png)
原因分析
操作以上问题的原因是因为
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 作用域
注意后
4
种状态是
Spring MVC
中的值,在普通的
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默认选择该作用域
prototype
- 官方说明:Scopes a single bean definition to any number of object instances.
- 描述:每次对该作用域下的Bean的请求都会创建新的实例:获取Bean(即通过 applicationContext.getBean等方法获取)及装配Bean(即通过@Autowired注入)都是新的对象实例。
- 场景:通常有状态的Bean使用该作用域
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中使用
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中使用
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中使用
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
容器。
Bean 原理分析
接下来,咱们来看一下
Bean
执行原理和生命周期总结。
Bean 执行流程
![](https://i-blog.csdnimg.cn/blog_migrate/967ec8a1f1845c89a23688708e0cf5eb.png)
Bean
执行流程(
Spring
执行流程):启动
Spring
容器
->
实例化
Bean
(分配内存空间,从无到有)
-> Bean 注册到
Spring
中(存操作)
->
将
Bean
装配到需要的类中(取操作
)
。
Bean 生命周期
所谓的生命周期指的是一个对象从诞生到销毁的整个生命过程,我们把这个过程就叫做一个对象的生命周期。
Bean
的生命周期分为以下
5
大部分:
1.实例化 Bean
为
Bean
分配内存空间
2.设置属性
Bean
注入和装配
3.Bean 初始化
- 实现了各种 Aware 通知的方法,如 BeanNameAware、BeanFactoryAware、
- ApplicationContextAware 的接口方法;
- 执行 BeanPostProcessor 初始化前置方法;
- 执行 @PostConstruct 初始化方法,依赖注入操作之后被执行;
- 执行自己指定的 init-method 方法(如果有指定的话);
- 执行 BeanPostProcessor 初始化后置方法。
4.使用 Bean
5.销毁 Bean
销毁容器的各种方法,如
@PreDestroy
、
DisposableBean
接口方法、
destroy-method
。
执行流程如下图所示:
![](https://i-blog.csdnimg.cn/blog_migrate/8f6851cee49fbfb77e1ec4be399c73b5.png)
实例化和初始化的区别
实例化和属性设置是
Java
级别的系统
“
事件
”
,其操作过程不可人工干预和修改;而初始化是给开发者提供的,可以在实例化之后,类加载完成之前进行自定义“
事件
”
处理。
生命流程的“故事”
Bean
的生命流程看似繁琐,但咱们可以以生活中的场景来理解它,比如我们现在需要买一栋房子,那么我们的流程是这样的:
1. 先买房(实例化,从无到有);2. 装修(设置属性);3. 买家电,如洗衣机、冰箱、电视、空调等([各种 ] 初始化);4. 入住(使用 Bean );5. 卖出去( 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();
}
}
总结
本篇博客介绍了
Bean
的
6
种作用域:
1. singleton :单例作用域2. prototype :原型作用域(多例作用域)3. request :请求作用域4. session :回话作用域5. application :全局作用域6. websocket : HTTP WebSocket 作用域
其中前两种是
spring
核心作用域,而后
4
种是
spring mvc
中的作用域,也介绍了
spring
的执行流程和bean 的生命周期,其中
bean
的作用域是最重要的知识点也是常见的面试题,而
bean
大的执行流程也一定要知道。