一、引入案例来探讨Bean的作用域

首先我们创建一个User类，定义一个用户信息，在定义一个Users类，使用方法注解将user存入Spring中，然后两个用户A对这个公共的Bean获取到之后，在自己的类中对Bean进行了修改，我们预期的结果是公共的Bean可以在各自的类中被修改，但是不能影响到其他类。

package com.java.demo.model;

public class User {
    private int id;
    private String name;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }

}

package com.java.demo.model;


import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;
/*
* 公共对象
* */

@Component
public class Users {
  @Bean("user")
  public User getUser(){
      User user = new User();
      user.setId(123);
      user.setName("李逵");
      return user;
  }
}

A想着在自己的类中对Bean对象进行修改，不会影响到其他的类。

package com.java.demo.controller;

import com.java.demo.model.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

/*
* 用户控制器
* 作者：A
* */
@Controller
public class UserController2 {

    @Autowired
    private User user;
    public void doMethod(){
        User user2 = user;
        System.out.println("User -> 修改之前 : user "+user);
        user2.setId(111);
        user2.setName("黑旋风");
        System.out.println("User -> 修改之后 : user "+user);
    }
}

B没有做任何修改，只是在自己的类中获取了之后，打印了这个Bean对象

package com.java.demo.controller;

import com.java.demo.model.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

/*
* 用户控制器
* 作者：B
* */
@Controller
public class UserController3 {
    @Autowired
    private User user;
    public void doMethod(){
        System.out.println("UserController3: user->"+user);
    }
}

可以看到A用户在自己的类中修改了Bean对象，也影响到了B获取的Bean对象的结果。这个问题的原因在于Bean对象在默认情况下是单例模式，也就是A和B用户使用的都是同一个对象。为了达到我们预期的效果，下面我们来了解一下Bean的作用域。

二、Bean的作用域

我们在学习Java基础知识的时候，了解到的作用域是说源代码中定义的变量的可用范围。但是在Spring中Bean的作用域试着Bean在Spring整个框架中的某种行为模式，就比如我们刚刚的代码，它其中的Bean对象的作用域就是单例作用域。

2.1、Bean的6种作用域

Spring容器在初始化一个Bean的实例时，同时会指定该实例的作用域。

1️⃣singleton（单例作用域）：是Spring中，Bean默认的作用域，若一个Bean的作用域是单例的，那么每个IoC容器只会有一个Bean对象，所有对这个Bean的依赖和获取这个Bean的代码，拿到的都是同一个Bean对象，这个Bean对象是全局共享的。其他人修改了这个值之后，那么另一个人读取到的就是被修改的值。单例模式的Bean不是线程安全的，可以将Bean里面的属性设置为ThreadLocal（本地线程），就会是线程安全的。

需要注意的是这里的单例和我们之前说到的设计模式中的单例是不同的。设计模式中说到的单例模式指的是某个类在进程中只有唯一的一个实例；而Spring中的单例指的是在一个Spring容器中，只会缓存某个类的一个Bean对象，所有通过这个容器获取Bean的方式，拿到的都是同一个Bean对象。但是在不同的Spring容器中，每一个Spring容器都会存在某个类的唯一的一个Bean对象。也就是说这里的单例是限定在一个Spring容器中，而不是整个应用程序中。

2️⃣prototype(原型作用域)也可以理解为多例作用域。若一个Bean的作用域是prototype，那么Spring容器并不会缓存创建的Bean，程序中对这个Bean的每一次获取，容器都会重新实例化一个Bean对象。这也就意味着容器不会帮我们做对象销毁的工作。

3️⃣request（请求作用域）：它将Bean的使用范围限定在一个http请求中，对于每个请求，都会单独创建一个Bean，一次的请求和响应共享一个Bean。请求结束，Bean也会随之销毁，使用request作用域一般不存在线程安全问题。

4️⃣session（会话作用域）：它将Bean的使用范围限定在了一次http会话中，对于每一个会话，Spring容器都会创建一个单独的Bean，若session被销毁，则Bean也随之销毁。

5️⃣application(全局作用域)：在整个Web应用期间，创建一个Bean实例。适合存储全局的配置数据等。

6️⃣websocket(HTTP WebSocket 作用域)：在⼀个HTTP WebSocket的⽣命周期中，定义⼀个Bean实例。WebSocket 的每次会话中，保存了⼀个 Map 结构的头信息，将⽤来包裹客户端消息头。第⼀次初始化后，直到 WebSocket 结束都是同⼀个Bean。

2.2、设置Bean的作用域

我们可以使用注解@Scope来声明Bean的作用域，@Scope注解既可以修饰方法也可以修饰类，它的声明的方式有两种。

直接设置值：@Scope("prototype")
使用枚举设置：@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)

下面我们将开始的案例设置有单例作用域修改为原型作用域。

package com.java.demo.model;


import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
/*
* 公共对象
* */

@Component
public class Users {
  @Bean("user")
  @Scope("prototype")
  public User getUser(){
      User user = new User();
      user.setId(123);
      user.setName("李逵");
      return user;
  }
}

三、Spring的执行流程

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

四、Bean的声明周期

生命周期指的是一个对象从创建到销毁的整个生命过程，所以这里的Bean的生命周期指的就是Bean从创建到使用再到销毁的过程。

1️⃣实例化Bean：给Bean分配内存空间，（相当于毛坯房）

2️⃣设置属性：当前类创建Bean对象时，依赖其他的Bean对象，这个时候使用（属性注入、Setter注入，构造方法注入）的方式引入依赖的Bean对象，赋值给当前类的属性。（相当于购买装修的基本材料）

3️⃣Bean的初始化：这里相当于装修房子

执行各种通知：相当于通知各个装修师傅来施工
初始化的前置方法：相当于师傅到达现场之后，和业主商量装修的方案
初始化方法：这里初始化的方式有两种一种是使用xml的方式，一种使用注解@PostConstruct的方式；相当于师傅开始经行装修的工作
初始化的后置方法：相当于房子装修完毕之后的清理工作。

4️⃣使用Bean：相当于房子可以入住了

5️⃣销毁Bean：相当于拆或者买了房子

❓❓❓为什么设置属性在初始化之前进行？

❗❗❗通过下面的代码来理解，BeanLifeComponent类中有一个Users类型的变量。如果BeanLifeComponent类中的方法调用users对象的方法时，users对象还没有被引入（也就是说还没有引入这个依赖），那么执行时程序一定会报错。所以就需要先引入这个依赖（Bean对象）。先执行属性设置，有助于当前类创建对象，因为当前类中的方法可能使用了这个属性，属性就必须先赋值完成。
public class BeanLifeComponent implements BeanNameAware {
    @Autowired
    private Users users;
    @Override
    public void setBeanName(String s) {
        //通知方法
        System.out.println("执行了 BeanNameAware ->"+s);
    }
    @PostConstruct
    public void doPostConstruct(){
        //使用注解的初始化方式
        System.out.println("执行了@PostConstruct");
    }
}

1、生命周期演示

下面我们通过这个例子来说明

import org.springframework.beans.factory.BeanNameAware;

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

public class BeanLifeComponent implements BeanNameAware {
    @Override
    public void setBeanName(String s) {
        //通知方法
        System.out.println("执行了 BeanNameAware ->"+s);
    }
    @PostConstruct
    public void doPostConstruct(){
        //使用注解的初始化方式
        System.out.println("执行了@PostConstruct");
    }

    public void myInit(){
        //使用xml的初始化方式
        System.out.println("执行了myInit");
    }

    public void sayHi(){
        System.out.println("Bean");
    }
    @PreDestroy
    public void preDestroy(){
        //销毁方法
        System.out.println("执行了preDestroy方法");
    }
}

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class BeanLifeTest {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
        BeanLifeComponent component = context.getBean("myBean", BeanLifeComponent.class);
        component.sayHi();
        context.close();//这里会调用preDestroy方法进行对象销毁
    }
}

配置信息中Bean的init-method属性表示初始化方法

<?xml version="1.0" encoding="UTF-8"?>
<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.java"></content:component-scan>
   
    <bean id="myBean" class="BeanLifeComponent" init-method="myInit"></bean>

</beans>