描述：该作用域下的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 级别的系统“事件”，其操作过程不可人工干预和修改；
而初始化是给开发者提供的，可以在实例化之后，类加载完成之前进行自定义“事件”处理。

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

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

🏓🏓🏓

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

🥇1. Bean 作用域

1.1 Bean 的作用域