【SSM】Bean 作用域和生命周期（重点：Bean 的生命周期5大部分）

【大家好，我是爱干饭的猿，本文重点介绍Bean 的 6 种作用域singleton、prototype、request、session、application、websocket：HTTP和Bean 的生命周期5大部分。

后续会继续分享其他重要知识点总结，如果喜欢这篇文章，点个赞，关注一下吧】

上一篇文章：《【SSM】MyBatis 操作数据库（重点：Mybatis两种使用方式）》

---

目录

1. Bean 作用域

1.1 Bean 的作用域

1.2 Bean 的 6 种作用域

1. singleton：单例作用域

2. prototype：原型作用域（多例作用域）

3. request：请求作用域

4. session：回话作用域

5. application：全局作用域

6. websocket：HTTP WebSocket 作用域

7. @Scope 注释 修改作用域

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

2. Bean 生命周期

2.1 Bean 的生命周期分为5大部分

1.实例化 Bean（为 Bean 分配内存空间）

2.设置属性（Bean 注入和装配）

3.Bean 初始化

4.使用 Bean

5.销毁 Bean

6. 实例化和初始化的区别

---

1. Bean 作用域

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

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

1.1 Bean 的作用域

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

1.2 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中使用

7. @Scope 注释 修改作用域

@Data
@Component
//@Scope("singleton") //不写Scope，Spring默认选择singleton作用域
@Scope("prototype") // @Scope"request"...
public class User {
    public Integer uid;
    public String username;

    public User() {
        this.uid = 1;
        this.username = "张三";
    }

    @Override
    public String toString() {
        return "User{" +
                "uid=" + uid +
                ", name='" + username + '\'' +
                ", hashCode()=" + this.hashCode() +
                '}';
    }
}

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

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

2. Bean 生命周期

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

2.1 Bean 的生命周期分为5大部分

1.实例化 Bean（为 Bean 分配内存空间）

如果是无参构造的化，直接调用。

如果是有参构造的化，参数这两个bean如果是实现已经构造过了则直接使用，否则递归的方式，触发了这两个bean的初始化过程。

2.设置属性（Bean 注入和装配）

@Autowired String name / setter方法注入@Autowired void setName(String name) (.. }

如果参数需要其他Bean，继续递归的方式，初始化所需的Bean

3.Bean 初始化

实现了Spring定义的各种接口

各种 Aware 通知的方法，如 BeanNameAware、BeanFactoryAware、 ApplicationContextAware 的接口方法；

• 执行 BeanPostProcessor 初始化前置方法；
• 执行 @PostConstruct 初始化方法，依赖注入操作之后被执行；
• 执行自己指定的 init-method 方法（如果有指定的话 (根据BeanDefinition)）；
• 执行 BeanPostProcessor 初始化后置方法。

4.使用 Bean

5.销毁 Bean

销毁容器的各种方法，如 @PreDestroy、DisposableBean 接口方法、destroy-method。

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.ResourceLoaderAware;
import org.springframework.core.io.ResourceLoader;
import org.springframework.stereotype.Component;

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

@Slf4j
@Component
public class LifeOfBean implements ApplicationContextAware, BeanNameAware, BeanClassLoaderAware, ResourceLoaderAware, InitializingBean, DisposableBean {
    @Autowired
    public LifeOfBean() {
        log.info("LifeOfBean 的构造方法");
    }

    @Autowired
    public void setName(@Value("${custom-user.name}") String name) {
        log.info("LifeOfBean 的 setName(name = {}) 方法", name);
    }

    @Override
    public void setBeanName(String name) {
        log.info("1. LifeOfBean 的 setBeanName(), beanName = {}", name);
    }

    @Override
    public void setBeanClassLoader(ClassLoader classLoader) {
        log.info("2. LifeOfBean 的 setBeanClassLoader(), classLoader = {}", classLoader);
    }

    @Override
    public void setResourceLoader(ResourceLoader resourceLoader) {
        log.info("3. LifeOfBean 的 setResourceLoader(), resourceLoader = {}", resourceLoader);
    }

    @PostConstruct  // 指定 init-method
    public void initMethod() {
        log.info("4. LifeOfBean 的 init-method 方法");
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        log.info("5. LifeOfBean 的 setApplicationContext(), applicationContext = {}", applicationContext);
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        log.info("6. LifeOfBean 的 afterPropertiesSet()");
    }

    @PreDestroy
    void destroyMethod() {
        log.info("7. LifeOfBean 的 destroyMethod()");
    }

    @Override
    public void destroy() throws Exception {
        log.info("8. LifeOfBean 的 destroy()");
    }
}

6. 实例化和初始化的区别

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

---

分享到此，感谢大家观看！！！

如果你喜欢这篇文章，请点赞加关注吧，或者如果你对文章有什么困惑，可以私信我。