本文主要介绍，Spring 中 Bean 的作用域和生命周期，希望对大家有所帮助

---

1. Bean 的作用域

1.1 通过一个案例来看 Bean 作用域的问题

假设现有一个公用的 Bean，提供给两个用户 A 和 B 使用，但是在使用途中 A 用户在 B 用户不知情下修改了公共 Bean 的数据，导致用户 B 拿到的 Bean 不是预设的 Bean

公共 Bean

@Slf4j
@Component
@Data
public class User {
    public int uid;
    public String name;

    public User() {
        this.uid = 1024;
        this.name = "java";
        log.info("User 的构造方法被调用，user 对象被创建 {}", this);
    }

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

A 用户使用时，对 Bean 进行了修改

@Slf4j
@Component
public class CommandLine1 implements CommandLineRunner {
    private final User user;

    @Autowired
    public CommandLine1(User user) {
        this.user = user;
    }

    @Override
    public void run(String... args) throws Exception {
        user.setName("hsq");
        log.info("CommandLine-1 下的 user 是 {}", user);
    }
}

B 用户拿到 Bean 时

@Slf4j
@Component
public class CommandLine2 implements CommandLineRunner {
    private final User user;

    @Autowired
    public CommandLine2(User user) {
        this.user = user;
    }

    @Override
    public void run(String... args) throws Exception {
        log.info("CommandLine-2 下的 user 是 {}", user);
    }
}

原因分析

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

1.2 作用域的定义

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

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

1.3 Spring Bean 支持的作用域（未介绍完全）

singleton

单例，Spring 中默认的作用域

prototype

每次从 Spring 容器中 get Bean 对象，都会触发一次创建过程，每个对象都是独立的对象

context.getBean(User.class) <=> new User()

request

以请求为单位，一次请求过程中，从开始到结尾，期间 context.getBean() 拿到的都是同一个 Bean ，但如果不同请求，则获取对象不同

session

以用户 Session 为单位。每个用户都有自己独立的 Bean，context.getBean() 根据不同的 session，得到不同的 Bean

1.4 修改 Bean 的作用域

使用 @Scope() 注解修饰 Bean（参数填上作用域名），即可修改 Bean 的作用域，不加注解默认为 singleton

1.5 Bean 执行流程

1. 启动容器，加载配置文件（类加载路径下的 XML 文件）
2. 根据配置完成 Bean 初始化，扫描与 application 文件同包下的 @Controller、@Service、@Component、@Repository 注解
3. 注册 Bean 到容器中，如果 Bean 需要使用其他 Bean 作为属性，需提前注入
4. 将 Bean 注入到需要的类中

2. Bean 的生命周期

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

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

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

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

2.1.3 Bean 初始化

• 实现了各种 Aware 通知的方法，如 BeanNameAware、InitializingBean 等的接口方法
• 执行 BeanPostProcessor 初始化前置方法；
• 执行 @PostConstruct 初始化方法，依赖注入操作之后被执行；
• 执行自己指定的 init-method 方法（如果有指定的话）；
• 执行 BeanPostProcessor 初始化后置方法。

2.1.4 Bean 使用

2.1.5 销毁 Bean

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

2.2 Bean 的生命周期执行流程

2.3 生命周期演示

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

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

    // 一定发生属性被注入之后，bean 被使用之前
    @PostConstruct  // 指定 init-method
    public void initMethod() {
        log.info("LifeOfBean 的 init-method 方法");
    }

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

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

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

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

    // 一定发生属性被注入之后，bean 被使用之前
    @Override
    public void afterPropertiesSet() throws Exception {
        log.info("LifeOfBean 的 afterPropertiesSet()");
    }

    // 销毁 Bean
    @PreDestroy
    public void preDestroy() {
        log.info("执行：preDestroy()");
    }
}


@Slf4j
@SpringBootApplication
public class BeanApplication {
    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(BeanApplication.class, args);
        log.info("Spring Application 启动结束");

        LifeOfBean bean = context.getBean(LifeOfBean.class);
        log.info("拿到手的 bean: {}", bean);
    }
}