Spring 是⽤来读取和存储 Bean，因此在 Spring 中 Bean 是最核⼼的操作资源，所以接下来我们深⼊学习⼀下 Bean 对象.

1.通过⼀个案例来看 Bean 作⽤域的问题

假设现在有⼀个公共的 Bean，提供给 A ⽤户和 B ⽤户使⽤，然⽽在使⽤的途中 A ⽤户却“悄悄”地修改了公共 Bean 的数据，导致 B ⽤户在使⽤时发⽣了预期之外的逻辑错误。

我们预期的结果是，公共 Bean 可以在各⾃的类中被修改，但不能影响到其他类。

 

 

 

 

 

 

 

 

 

 

 

 原因分析

操作以上问题的原因是因为 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 eachSpring 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. Thatis, each HTTP request has its own instance of a bean created off the back of a singlebean 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. Onlyvalid 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 validin 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 inthe 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作用域的声明方式有两种：

@Scope标签既可以修饰方法也可以修饰类

1.直接设置值：@Scrope("prototype")

2.使用枚举设置：@Scrope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)

读了这些基本概念，我们继续编写上边的代码 

第一种方式：

 

运行结果：

 

 

第二种方式：

 

运行结果：

 

 

 2.Bean原理分析

 Bean执行流程：

 

 

 

 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）

 

执⾏流程如下图所示：

 

 

实例化和初始化的区别

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

 

 生命流程的“故事”

Bean 的⽣命流程看似繁琐，但咱们可以以⽣活中的场景来理解它，⽐如我们现在需要买⼀栋房⼦，那么我们的流程是这样的：
1. 先买房（实例化，从⽆到有）；
2. 装修（设置属性）；
3. 买家电，如洗⾐机、冰箱、电视、空调等（[各种]初始化）；
4. ⼊住（使⽤ Bean）；
5. 卖出去（Bean 销毁）；

生命周期代码示例：

package com.hdc.beans.component;

import org.springframework.beans.factory.BeanNameAware;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

@Component
public class BeanLife implements BeanNameAware {
    @Override
    public void setBeanName(String s) {
        System.out.println("执行了 BeanNameAware setBeanName方法：" + s);
    }

    //初始化方式一
    @PostConstruct
    public void postConstruct() {
        System.out.println("执行：postConstruct");
    }

    //初始化方式二
    public void init() {
        System.out.println("执行 init 方法");
    }

    //销毁方法一
    @PreDestroy
    public void preDestory() {
        System.out.println("执行 preDestory 方法");
    }

    //销毁方法二
    public void myDestory() {
        System.out.println("执行 myDestory 方法");
    }
}

 配置xml文件（我这里用了俩种方式，一种是直接注解，另一种是方法加配置xml文件中的

init-method()和destory-method()方法，使用注解更加简单方便）

 

 

运行结果：

 

 

 

了解 Spring 生命周期的意义在于：

可以利用 Bean 在其存活期间的指定时刻完成一些相关操作。这种时刻可能有很多，但一般情况下，会在 Bean 被初始化后和被销毁前执行一些相关操作。

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

@Service
public class UserService {
    public UserService() {
        System.out.println("调用 UserService 构造方法");
    }

    public void sayHi(String name) {
        System.out.println("hello " + name);
    }
}


@Controller
public class UserController {
    @Autowired
    private UserService userService;

    @PostConstruct
    public UserController(UserService userService) {
        userService.sayHi();
        System.out.println("执行 UserController 构造方法");
    }
}

如果先初始化，下面的@PostConstruct比@Autowired先执行，下面的@PostConstruct里面的userService对象压根就没有引入，如何使用？会报空指针异常。