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("fl"); // 【重点：名称是 fl】
        return user;
    }
}
1
2
3
4
5
6
7
8
9
10

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 user1;
    }
}
1
2
3
4
5
6
7
8
9
10
11

B 用户再去使用公共 Bean 的时候：

@Controller
public class BeanScopesController2 {
    @Autowired
    private User user1;
    public User getUser1() {
        User user = user1;
        return user1;
    }
}
1
2
3
4
5
6
7
8
9

打印 A 用户和 B 用户公共 Bean 的值：

public class App {
    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());
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

原因分析

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

作用域定义

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

而 Bean 的作用域是指 Bean 在 Spring 整个框架中的某种行为模式，比如 singleton 单例作用域，就表示 Bean 在整个 Spring 中只有⼀份，它是全局共享的，那么当其他人修改了这个值之后，那么另一个人读取到的就是被修改的值

Bean 的 6 种作用域

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

1.singleton：单例作用域

该作用域下的Bean在IoC容器中只存在⼀个实例：获取Bean（即通过applicationContext.getBean等方法获取）及装配Bean（即通过@Autowired注入）都是同一个对象

通常无状态的Bean使⽤该作用域。无状态表示Bean对象的属性状态不需要更新

Spring默认选择该作用域

2.prototype：原型作用域(多例作用域)

每次对该作用域下的Bean的请求都会创建新的实例：获取Bean（即通过applicationContext.getBean等⽅法获取）及装配Bean（即通过@Autowired注入）都是新的对象实例

通常有状态的Bean使用该作用域

3.request：请求作用域

每次http请求会创建新的Bean实例，类似于prototype

⼀次http的请求和响应的共享Bean

限定SpringMVC中使用

4.session：会话作用域

在⼀个http session中，定义⼀个Bean实例

用户会话的共享Bean，比如：记录⼀个用户的登陆信息

限定SpringMVC中使用

5. application：全局作用域

在⼀个http servlet Context中，定义⼀个Bean实例

Web应用的上下问信息，比如：记录⼀个应用的共享信息

限定SpringMVC中使用

6. websocket：HTTP WebSocket 作用域

在⼀个HTTP WebSocket的生命周期中，定义⼀个Bean实例

WebSocket的每次会话中，保存了⼀个Map结构的头信息，将⽤来包裹客户端消息头。第⼀次初始化后，直到WebSocket结束都是同⼀个Bean

限定Spring WebSocket中使用

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

singleton 是 Spring Core 的作用域；application 是 Spring Web 中的作用域；
singleton 作用于 IoC 的容器，而 application 作用于 Servlet 容器

设置作用域

使用 @Scope 注解就可以用来声明 Bean 的作用域，比如设置 Bean 的作用域，如下代码所示：

@Component
public class Users {
    @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
    @Bean
    public User user1() {
        User user = new User();
        user.setId(1);
        user.setName("fl"); 
        return user;
    }
}
1
2
3
4
5
6
7
8
9
10
11

再次运行代码

现在 Bean 从单例作用域变为了原型作用域

@Scope 注解既可以修饰方法，也可以修饰类，@Scope 有两种设置方法：

1. 直接设置值：@Scope(“prototype”)
2. 使用枚举设置：@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)

Bean 执行流程

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

Bean 生命周期

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

Bean 的生命周期分为以下 5 大部分：

1.实例化 Bean（为 Bean 分配内存空间）
2.设置属性（Bean 注入和装配）
3.Bean 初始化

a. 实现了各种 Aware 通知的⽅法，如 BeanNameAware、BeanFactoryAware、ApplicationContextAware 的接口方法
b. 执行 BeanPostProcessor 初始化前置方法
c. 执行构造方法，两种执行方式，一种是先执行 @PostConstruct， 另一种是后执行 init- method 方法
d. 执行 BeanPostProcessor 初始化后置方法。

4.使用 Bean
5.销毁 Bean

a. @PreDestroy
b. 重写DisposableBean 接口方法
c. destroy-mehod

Bean 生命周期演示

@Component
public class BeanLifeComponent implements BeanNameAware {
    @PostConstruct
    public void postConstruct() {
        System.out.println("执⾏了 @PostConstruct");
    }

    public void init() {
        System.out.println("执⾏了 init-method");
    }

    public void use() {
        System.out.println("使用 bean");
    }

    @PreDestroy
    public void preDestroy() {
        System.out.println("执⾏了 @PreDestroy");
    }

    public void setBeanName(String s) {
        System.out.println("执⾏了 Aware 通知");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

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="com.beans">content:component-scan>
    <bean id="beanLifeComponent" class="com.beans.BeanLifeComponent" init-method="init">bean>
beans>
1
2
3
4
5
6
7
8

调用类：

public class App {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
        BeanLifeComponent beanLife = context.getBean(BeanLifeComponent.class);
        beanLife.use();
        context.destroy();
    }
}
1
2
3
4
5
6
7
8

最终结果：

问题：
为什么要先设置属性在进行初始化呢？

如果先进行初始化，在初始化中使用了属性，此时就出现null异常，因为属性还没被设置
所以设置属性和初始化的顺序不能颠倒