关于Bean对象,在将其存储到spring中以后,在使用或读取该Bean对象时,如果该对象是公有的,难免就会出现被一方修改,从而影响另外一方读取到的对象准确性的情况。因此了解Bean的作用域和生命周期就是十分必要的了。
首先,还是具体使用一个例子来理解上面提到的这种情况:
文章目录
- 示例
- Bean的6种作用域
- singleton
- prototype
- request
- session
- application
- websocket
- Bean作用域的设置
- Spring的执行流程
- Bean生命周期
示例
首先,新建一个Student实体类,为其设置属性,并提供其相关的get/set方法;
package com.yun.model;
public class Student {
private int id;
private String name;
private double score;
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 double getScore() {
return score;
}
public void setScore(double score) {
this.score = score;
}
@Override
public String toString() {
return "Student{" +
"id=" + id +
", name='" + name + '\'' +
", score=" + score +
'}';
}
}
创建一个Bean对象,使用方法注解存储到Spring;
package com.yun.controller;
import com.yun.model.Student;
import com.yun.model.User;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;
@Component
public class StudentBean {
@Bean
public Student stu(){
Student student=new Student();
student.setId(5);
student.setName("李大锤");
student.setScore(99.6);
return student;
}
}
A首先读取并且使用bean,同时进行一定的操作;
package com.yun.controller;
import com.yun.model.Student;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
/*
* A 1.获取bean;
* 2.创建了新的对象,对新创建的对象进行修改
* */
@Controller
public class StuController1 {
@Autowired
private Student student1;
public Student getStu1(){
Student student=student1;
System.out.println("student1 id="+student.getId()+" name="+student.getName());
student.setId(10);
student.setName("安慕希");
return student;
}
}
B 读取bean;
package com.yun.controller;
import com.yun.model.Student;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
/*
* B 读取bean,获取bean的具体值
* */
@Controller
public class StuController2 {
@Autowired
private Student student1;
public Student getStud2(){
Student student=student1;
return student;
}
}
获取原始bean的值,以及A读取到的值和B读取到的值;
通过运行结果可以得到结论,尽管看起来A是在自己新创建的Bean对象上进行了修改,但最终还是会影响到原始公共Bean的值;
而究其出现这种结果的原因,其实就是因为Bean在默认情况下是单例模式,即只有一份对象,这份对象供所有访问者使用。因此,A进行的修改操作自然也就会影响到B的读取结果。而使用单例状态的原因就是,提高性能。
Bean的6种作用域
作用域,顾名思义就是“作用到的区域或范围”,实际就是程序中变量的一个可用的范围。而Bean的作用域其实就是Bean在Spring框架中的某种行为模式,具体共有6种:
- singleton:单例作⽤域
- prototype:原型作⽤域(多例作⽤域)
- request:请求作⽤域
- session:会话作⽤域
- application:全局作⽤域
- websocket:HTTP WebSocket 作⽤域
singleton
是Spring默认选择的作用域;
在此作用域下的Bean在IoC容器中只有一个实例,即只有一个全局对象;
通常当Bean对象的属性状态不需要更新时,即Bean无状态的情况下会使用该作用域;
prototype
多例模式下使用的作用域;
在此作用域下的Bean每被访问一次就会创建出一个实例;
通常当Bean对象的属性状态需要更新时,即Bean有状态的情况下会使用该作用域;
在普通的Spring项目中,一般只有前面两种作用域;而后面提到的作用域则是只能在SpringMVC中使用或只能在Spring WebSocket中使⽤;
request
在每次http请求时都会创建一个新的Bean的实例;
只能在SpringMVC中使用;
session
每次会话都会定义一个Bean的实例;
只能在SpringMVC中使用;
application
在一个http servlet Context中,共享一个Bean实例;
只能在SpringMVC中使用;
websocket
在一个HTTP WebSocket中,定义一个Bean实例同时共享这个实例;
只能在Spring WebSocket中使⽤;
Bean作用域的设置
由于我们这里主要介绍的是Spring项目,因此关于Bean作用域的设置也只涉及到两种;
singleton是Spring默认的作用域,因此一个新创建的bean对象在不进行特别设置的情况下,其作用域就是singleton;
下面具体演示prototype的设置:
prototype的设置有上面图片中所示的两种方式,我们也可以从相关类中找到该作用域的定义信息:
在为其设置了全局作用域后,我们再次执行文章开始的实例,得到的结果如下:
此时,A的修改操作不再影响到B的读取;
Spring的执行流程
- 启动容器;
首先,启动容器,去加载相关的配置文件;
- 进行Bean初始化
对配置了加载组件路径下的类进行扫描,即扫描该路径下的文件,查看是否有相关的类注解;
- 注册Bean对象到容器
将在加载组件路径下的类中,添加了相关注解的类注册到容器中;
- 装配或使用Bean
即将需要使用的Bean注入到需要的类中去;
- Spring销毁
相关使用操作完毕,最终Spring销毁;
Bean生命周期
生命周期实际就是一个对象从产生到被销毁的全过程,关于Bean生命周期主要有5步:
- 实例化Bean
即为Bean对象分配内存空间;
- 设置属性
对Bean对象进行依赖注入; - 进行Bean初始化
3.1 执行各种通知;
3.2 初始化的前置方法;
3.3 初始化方法;
3.4 初始化的后置方法;
- 使用Bean;
- 销毁Bean;
简单使用代码来观察这个过程:
package com.yun.controller;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
public class BeanLife implements BeanNameAware {
@Override
public void setBeanName(String s) {
System.out.println("执行 setBeanName() 通知 "+s);
}
@PostConstruct
public void myPostConstruct(){
System.out.println("执行 myPostConstruct() 方法");
}
public void init(){
System.out.println("执行 init()");
}
public void use(){
System.out.println("执行 use 方法");
}
@PreDestroy
public void myPreDestroy(){
System.out.println("执行 myPreDestroy() 销毁");
}
}
使用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">
<!-- <bean id="userService" class="com.bit.service.UserService"></bean>-->
<!-- 配置存储 Bean 对象的扫描根路径 -->
<content:component-scan base-package="com.yun"></content:component-scan>
<bean id="beanlife" class="com.yun.controller.BeanLife"
init-method="init"></bean>
</beans>
设置一个启动类:
import com.yun.controller.BeanLife;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class BeanLifeApp {
public static void main(String[] args) {
/*
* 必须使用ClassPathXmlApplicationContext类,ApplicationContext无方法destroy()方法
* */
ClassPathXmlApplicationContext context=new ClassPathXmlApplicationContext("spring-config.xml");
BeanLife beanLife=context.getBean("beanlife",BeanLife.class);
beanLife.use();
System.out.println("执行 main方法");
context.destroy();
}
}
运行结果:
over!