Java EE 突击 6 - Bean 作用域和生命周期
Bean 的作用域和生命周期
- 一 . 通过一个案例来看 Bean 作用域的问题
- 二 . 作用域定义
-
- 2.1 Bean 的 6 种作用域
-
- sigleton : 单例模式[默认的作用域]
- prototype : 原型模式
- request : 请求作用域[只能在 Spring MVC 里面使用]
- session : 会话作用域[只能在 Spring MVC 里面使用]
- application : 全局作用域[只能在 Spring MVC 里面使用]
- websocket : HTTP WebSocket 作用域[只能在 WebSocket 程序中使用]
- 单例作用域 (singleton) VS 全局作用域 (application)
- 2.2 设置作用域
- 三 . Spring 执行流程与生命周期
-
- 3.1 Spring 主要的执行流程
- 3.2 Bean 生命周期
-
- 生命周期的演示
- 生命周期的故事
- 思考：为什么要先设置属性在进行初始化呢？
这个专栏给大家介绍一下 Java 家族的核心产品 - SSM 框架
JavaEE 进阶专栏Java 语言能走到现在 , 仍然屹立不衰的原因 , 有一部分就是因为 SSM 框架的存在
接下来 , 博主会带大家了解一下 Spring、Spring Boot、Spring MVC、MyBatis 相关知识点
并且带领大家进行环境的配置 , 让大家真正用好框架、学懂框架
来上一篇文章复习一下吧
点击即可跳转到我的小秘密
在好久好久之前的学习中 , 我们了解过作用域这个概念 .
作用域（scope）是程序设计概念，通常来说 , 一段程序代码中所用到的名字并不总是有效/可用的 , 而限定这个名字的可用性的代码范围就是这个名字的作用域。
- 局部变量的作用域是变量所在的局部范围。
- 全局变量的作用域是整个工程。
比如这段代码
public class Main {
private int c = 0;// c 可以在整个类当中使用
public void test() {
int a = 0;// a 只能在这个函数里面使用
}
public static void main(String[] args) {
int b = 0;// b 可以在 main 方法里面使用
}
}
如果还记得这个概念的话 , 那么接下来就都好说了
一 . 通过一个案例来看 Bean 作用域的问题
假设张三开发出了一个公共的 Bean 叫做 “张三” , 提供给李四和王五使用 , 但是在使用的过程中 , 李四不小心的把 “张三” 改成了 “李四” , 这个时候王五在使用的时候还按照 “张三” 去使用 , 就会出现问题 .
那么大家可能感觉不知所云 , 就举个栗子吧 .
我们创建一个 model 类 , 在里面创建一个 Dog 类 , 有他的编号、姓名、年龄
package model;
public class Dog {
private int id;
private String name;
private int age;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Dog{" +
"id=" + id +
", name='" + name + '\'' +
", age=" + age +
'}';
}
}
然后我们在 Controller 包底下去创建一个类 : DogBean
这个类就是张三开发出的公共模块 , 用来给李四和王五使用的
package controller;
import model.Dog;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;
@Component
public class DogBean {
@Bean
public Dog dog() {
Dog dog = new Dog();
dog.setId(1);
dog.setName("大黑");
dog.setAge(1);
return dog;
}
}
李四和王五就可以调用这段代码
这时候李四就去使用他了
创建一个类 : ScopeController.java
package controller;
import model.Dog;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
@Controller
public class ScopeController {
@Autowired
private Dog dog;//这里我们为什么去使用属性注入呢?因为方便
public void doScope() {
System.out.println("Do scope controller.");
System.out.println("原数据:" + dog);
// 这是李四写的代码
// 但是他进行了一些修改
Dog dog2 = dog;// 他为了不影响之前的dog,自己新建一个dog
dog2.setName("旺旺");
System.out.println("修改之后的数据" + dog2);
}
}
李四是这样想的 , 我自己新创建一个 dog , 然后针对自己的 dog 去修改 , 不改变张三的 dog
然后王五开始写代码了 : ScopeController2.java
package controller;
import model.Dog;
import org.springframework.stereotype.Controller;
import javax.annotation.Resource;
@Controller
public class ScopeController2 {
@Resource
private Dog dog;
public void doSCope() {
System.out.println("Do SCope controller 2.");
System.out.println(dog);
}
}
然后我们在启动类运行一下
import com.ethan.controller.ScopeController;
import com.ethan.controller.ScopeController2;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class App {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
ScopeController scopeController = context.getBean("scopeController", ScopeController.class);
scopeController.doScope();
System.out.println("----------------------------------------------------------------");
ScopeController2 scopeController2 = context.getBean("scopeController2", ScopeController2.class);
scopeController2.doScope2();
}
}
这是为什么呢 ?
这要追溯到我们之前学习的基础类型和引用类型的知识了
这是因为我们 Spring 是单例模式 , 默认情况下 , dog 只有一份 , 我们会先去 Spring 里面拿 dog , 所以拿到的都是一个 dog , 获取到的也就是一个对象 , 就导致了这个问题 .
二 . 作用域定义
Bean 的作用域是指 Bean 对象在整个 Spring 中的某种行为模式
比如单例作用域，就表示 Bean 在整个 Spring 框架中只有⼀份，它是全局共享的，那么当其他⼈修改了这个值之后，那么另⼀个人读取到的就是被修改的值。
2.1 Bean 的 6 种作用域
- singleton : 单例作用域(默认作用域)
Spring 默认的是单例作用域 , 因为它只存在一份 , 性能比较高 , 消耗的资源比较少 , 糟糕的问题就是当有一个人修改之后 , 其他人拿到的也就是被修改的作用域
- prototype : 原型作用域(多例作用域)
- request : 请求作用域
- session : 会话作用域
- application : 全局作用域
- websocket : HTTP WebSocket 作用域
ps. 下面这 4 个是 Spring MVC 里面的作用域 , 在普通的 Spring 项目 (Spring FrameWork Core) 里面只有前两种
sigleton : 单例模式[默认的作用域]
官方说明 : (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 对象的属性状态不需要更新(不需要进行修改的 Bean)
备注 : Spring 默认选择该作用域
prototype : 原型模式
原来的形状的模式 , 原来是什么样我们就给你什么样 , 那怎么才能保证原型模式呢 ?
那就每一次使用都复制一份 , 他的模板是不变的 , 然后有人需要的话就复制一份一模一样的给你
描述 : 每次对该作用域下的 Bean 的请求都会创建新的实例 : 获取 Bean (即通过applicationContext.getBean 等方法获取) 及装配 Bean (即通过 @Autowired 注入) 都是新的对象实例。
这里怎么没说可以去从 @Resource 获取呢 ?
这是因为我们的 Spring 公司是不会去推销别人家的东西的 , @Resource 是 Java 的 , 我为什么要帮他打广告 , 但是其实 @Resource 是可以使用的
场景 : 通常有状态的 Bean 使用该作用域(有状态 : 总去修改的 Bean)
request : 请求作用域[只能在 Spring MVC 里面使用]
在这里 , request 表示 请求作用域 , 而不是在 Servlet 里面的请求对象
官方说明 : 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 beandefinition. Only valid in the context of a web-aware Spring ApplicationContext.
描述 : 每次 http 请求会创建新的 Bean 实例 , 类似于 prototype
prototype 每次访问都会创建一个新对象 , 比如 : 每次类里面添加了 @Autowired , 就会新建一个对象
Request 而是每一次 HTTP 请求 , 就会创建一个 Bean 对象
场景 : ⼀次 HTTP 的请求和响应的共享 Bean
备注 : 限定 SpringMVC 中使用
session : 会话作用域[只能在 Spring MVC 里面使用]
官方说明 : Scopes a single bean definition to the lifecycle of an HTTP Session. Only valid inthe context of a web-aware Spring ApplicationContext.
描述 : 在⼀个 HTTP session 中，定义⼀个 Bean 实例
登陆成功 , 是一次会话 , 在这一次会话里面 , 任何地方使用了这个对象 , 都是一个 Bean 对象
退出登录再登陆之后 , 又是一个新的 session 了
每次 (session) 会话使用一个 bean 对象
场景 : 用户会话的共享 Bean, 比如 : 记录⼀个用户的登陆信息
备注 : 限定 SpringMVC 中使用
application : 全局作用域[只能在 Spring MVC 里面使用]
一个 HTTP Servlet context 中共享一个对象
websocket : HTTP WebSocket 作用域[只能在 WebSocket 程序中使用]
WebSocket 是什么 ?
现在其实这个技术有点不常见了 , 但是在日常生活中应用还是比较广泛的 , 比如网页聊天室 , 比如 : 某个网站上有在线客服 , 你们可以在线解决问题 . 还比如网页游戏等等
它的底层协议是 TCP/UDP
他是和 HTTP 协议同一级别的应用层的协议
我们只需要重点记住前四个即可
单例作用域 (singleton) VS 全局作用域 (application)
singleton 是 Spring Core 的作用域 ; application 是 Spring Web 中的作用域 ；
singleton 作用于 IoC 的容器，而 application 作用于 Servlet 容器。
2.2 设置作用域
使用 @Scope 标签就可以用来声明 Bean 的作用域，比如设置 Bean 的作用域
把它放到你要存储的对象的上边
@Scope 标签既可以修饰方法也可以修饰类，@Scope 有两种设置方式：
- 直接设置值：@Scope(“prototype”)
- 使用枚举设置：@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
来看之前的例子
package controller;
import model.Dog;
import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
@Component
public class DogBean {
// 写法一
@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
// @Scope(ConfigurableListableBeanFactory.SCOPE_PROTOTYPE) //这种写法也是可以的
// 写法二
// @Scope("prototype")
@Bean
public Dog dog() {
Dog dog = new Dog();
dog.setId(1);
dog.setName("大黑");
dog.setAge(1);
return dog;
}
}
然后运行一下
说明现在就是多例的模式
那我们再使用写法二来看一下
也成功了
但是我们还是推荐 写法1 这种方法 , 因为它可以进行代码提示 , 我们不容易出错
三 . Spring 执行流程与生命周期
3.1 Spring 主要的执行流程
3.2 Bean 生命周期
- 实例化 Bean (为 Bean 分配内存空间)
不等于初始化
实例化就是分配内存空间
比如 : 我们想要在一个城市安身立业 , 咱们的传统就是得先有个家才算安身了 , 那么实例化就是在这个地方买个房子 , 但是现在这个叫家吗 ? 显然不是 , 我们还需要装修买家具等等
- 设置属性 (Bean 注入和装配)
- Bean 初始化
- 实现了各种 Aware 通知的方法，如 BeanNameAware、BeanFactoryAware、ApplicationContextAware 的接口方法；
加入我们现在有个 Bean , Bean 是有自己的名称的 , 我给这个 Bean 起名 , 这是一个事件 , 然后我给这个 Bean 设置好名字之后就会有一个通知 , 叫做 BeanNameAware
- 设置属性[依赖注入-DI]
- 初始化
- 执行各种通知
- 初始化的前置方法
通过 spring-config.xml 里面定义 init-mtehod
也可以通过 @PostConstruct 注解
3. 初始化方法
4. 初始化的后置方法
- 使用 Bean
- 销毁 Bean
销毁容器的各种方法，如 @PreDestroy、DisposableBean 接口方法、destroy-method
大致步骤也在图片里面画了
生命周期的演示
我们在 Controller 里面创建一个类 , 叫做 BeanLifeComponent (Bean 的一生)
然后先把注解加上
package controller;
import org.springframework.stereotype.Component;
@Component
public class BeanLifeComponent {
}
接下来 , 先写通知 , 我们就需要实现 BeanNameAware , 然后重写他的通知方法
package controller;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.stereotype.Component;
@Component
public class BeanLifeComponent implements BeanNameAware {
@Override
public void setBeanName(String s) {
System.out.println("执行了 Bean Name 的通知:" + s);
}
}
然后我们在写一个方法
(我们为了测试 xml 时代的写法 , 就先把 @Component 注解去掉)
package controller;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.stereotype.Component;
//@Component
public class BeanLifeComponent implements BeanNameAware {
@Override
public void setBeanName(String s) {
System.out.println("执行了 Bean Name 的通知:" + s);
}
/**
* 方法名随便定义
* 在 xml 中 init-method 指定的方法
*/
public void initMethod() {
System.out.println("执行了 init method 方法");
}
}
接下来我们在 xml 里面去定义它
<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="controller">content:component-scan>
<bean id="beanlife" class="controller.BeanLifeComponent" init-method="initMethod">bean>
beans>
然后接下来 , 我们编写初始化的代码 , 在上面加一个注解 : @PostConstruct
package controller;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
//@Component
public class BeanLifeComponent implements BeanNameAware {
@Override
public void setBeanName(String s) {
System.out.println("执行了 Bean Name 的通知:" + s);
}
/**
* 方法名随便定义
* 在 xml 中 init-method 指定的方法
*/
public void initMethod() {
System.out.println("执行了 init method 方法");
}
/**
* 方法名随便定义
* 尽量要符合规范
*/
@PostConstruct
public void myPostConstruct() {
System.out.println("执行了 PostConstruct 方法");
}
}
然后执行销毁方法
package controller;
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 {
@Override
public void setBeanName(String s) {
System.out.println("执行了 Bean Name 的通知:" + s);
}
/**
* 方法名随便定义
* 在 xml 中 init-method 指定的方法
*/
public void initMethod() {
System.out.println("执行了 init method 方法");
}
/**
* 方法名随便定义
* 尽量要符合规范
*/
@PostConstruct
public void myPostConstruct() {
System.out.println("执行了 PostConstruct 方法");
}
@PreDestroy
public void myPreDestroy() {
System.out.println("执行了 PreDestroy 方法");
}
}
最后我们再写一个普通方法来进行测试
package controller;
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 {
@Override
public void setBeanName(String s) {
System.out.println("执行了 Bean Name 的通知:" + s);
}
/**
* 方法名随便定义
* 在 xml 中 init-method 指定的方法
*/
public void initMethod() {
System.out.println("执行了 init method 方法");
}
/**
* 方法名随便定义
* 尽量要符合规范
*/
@PostConstruct
public void myPostConstruct() {
System.out.println("执行了 PostConstruct 方法");
}
/**
* 销毁前执行方法
*/
@PreDestroy
public void myPreDestroy() {
System.out.println("执行了 PreDestroy 方法");
}
public void use() {
System.out.println("执行了 use 方法");
}
}
但是这个写法和之前的写法就不太一样了
如果我们要去销毁他 , 就必须调用他的 myPreDestroy 方法 , 但是我们还不能使用 ApplicationContext , 因为 ApplicationContext 没有销毁方法 , 所以咱们就使用 ClassPathXmlApplicationContext 方法定义上下文对象 , 才有 myPreDestroy 方法
import controller.BeanLifeComponent;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class App {
public static void main(String[] args) {
ClassPathXmlApplicationContext context =
new ClassPathXmlApplicationContext("spring-config.xml");
BeanLifeComponent component = context.getBean("beanlife",BeanLifeComponent.class);
component.use();
// 关闭容器
context.destroy();
}
}
运行一下
我们来分析一下
接下来 , 我再实现一个构造方法 , 来看一下效果
package com.ethan.controller;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.beans.factory.annotation.Autowired;
import com.ethan.service.UserService;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
//@Component
public class BeanLifeComponent implements BeanNameAware {
@Override
public void setBeanName(String s) {
System.out.println("执行了 Bean Name 的通知:" + s);
}
/**
* 方法名随便定义
* 在 xml 中 init-method 指定的方法
*/
public void initMethod() {
System.out.println("执行了 init method 方法");
}
/**
* 方法名随便定义
* 尽量要符合规范
*/
@PostConstruct
public void myPostConstruct() {
System.out.println("执行了 PostConstruct 方法");
}
/**
* 销毁前执行方法
*/
@PreDestroy
public void myPreDestroy() {
System.out.println("执行了 PreDestroy 方法");
}
public void use() {
System.out.println("执行了 use 方法");
}
public BeanLifeComponent() {
System.out.println("BeanLifeComponent 的构造方法");
}
}
构造方法是最先执行的 , 这是因为构造方法是我们 JDK 的 , 在 JDK 中构造方法优先执行 , 我们的 Spring 也是要遵循 JDK 的
接下来我们新建一个 service 包 , 底下新建一个类 , 叫做 UserService
然后编写以下代码
package com.ethan.service;
import org.springframework.stereotype.Service;
@Service
public class UserService {
public UserService() {
System.out.println("UserService 的构造方法");
}
public void doService() {
System.out.println("doService()");
}
}
接下来在我们的 BeanLifeComponent 类里面添加 @Autowired 注解
package com.ethan.controller;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.beans.factory.annotation.Autowired;
import com.ethan.service.UserService;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
//@Component
public class BeanLifeComponent implements BeanNameAware {
@Autowired
private UserService userService;
@Override
public void setBeanName(String s) {
System.out.println("执行了 Bean Name 的通知:" + s);
}
/**
* 方法名随便定义
* 在 xml 中 init-method 指定的方法
*/
public void initMethod() {
System.out.println("执行了 init method 方法");
}
/**
* 方法名随便定义
* 尽量要符合规范
*/
@PostConstruct
public void myPostConstruct() {
System.out.println("执行了 PostConstruct 方法");
}
/**
* 销毁前执行方法
*/
@PreDestroy
public void myPreDestroy() {
System.out.println("执行了 PreDestroy 方法");
}
public void use() {
System.out.println("执行了 use 方法");
}
public BeanLifeComponent() {
System.out.println("BeanLifeComponent 的构造方法");
}
}
运行一下
为什么会执行我们的 UserService 的构造方法呢 ?
这是因为我们引入了 Userservice 对象 , 里面有他的构造方法 .
那么这两个构造方法的先后顺序都比较特殊 , 他们都来自于 JDK , 先加载那个类是不一定的 , 所以先打印谁后打印谁都是不一定的 .
生命周期的故事
- 先买房 (实例化 , 从无到有)
- 装修 (设置属性)
- 买家电 ([各种]初始化)
- 入住 (使用 Bean)
- 不想住然后卖出去 (Bean 销毁)
思考：为什么要先设置属性在进行初始化呢？
在初始化的过程中 , 有很多个方法 , 在这些方法中 , 有可能会调用属性里面的某个对象里面的某个方法 , 而如果先初始化再设置属性的话 , 调用的时候就会报空指针异常
举个栗子 :
所以我们会先进行对象注入 , 防止以后需要使用对象的时候会报错