@TOC
Bean 作⽤域和⽣命周期
从前⾯的博客我们可以看出 Spring 是⽤来读取和存储 Bean，因此在 Spring 中 Bean 是最核⼼的操作资源，所以接下来我们深⼊学习⼀下 Bean 对象
通过⼀个案例来看 Bean 作⽤域的问题
假设现在有⼀个公共的 Bean，提供给 A ⽤户和 B ⽤户使⽤，然⽽在使⽤的途中 A ⽤户却 悄悄 地修改了公共 Bean 的数据，导致 B ⽤户在使⽤时发⽣了预期之外的逻辑错误。
我们预期的结果是，公共 Bean 可以在各⾃的类中被修改，但不能影响到其他类。
被修改的 Bean 案例
公共 Bean：
@Component public class Users { @Bean public User user1() { User user = new User(); user.setId(1); user.setName("Java"); // 【重点：名称是 Java】 return user; } }A ⽤户使⽤时，进⾏了修改操作：
@Controller public class BeanScopesController { @Autowired private User user1; public User getUser1() { User user = user1; System.out.println("Bean 原 Name：" + user.getName()); user.setName("悟空"); // 【重点：进⾏了修改操作】 return user; } }B ⽤户再去使⽤公共 Bean 的时候：
@Controller public class BeanScopesController2 { @Autowired private user1; public User getUser1() { User user = user1; return user; } }打印 A ⽤户和 B ⽤户公共 Bean 的值：
public class BeanScopesTest { public static void main(String[] args) { ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml"); BeanScopesController beanScopesController = context.getBean(BeanScopesController.class); System.out.println("A 对象修改之后 Name：" + beanScopesController.getUser1().toString()); BeanScopesController2 beanScopesController2 = context.getBean(BeanScopesController2.class); System.out.println("B 对象读取到的 Name：" + beanScopesController2.getUser1().toString()); } }执⾏结果如下：
原因分析
操作以上问题的原因是因为 Bean 默认情况下是单例状态（singleton），也就是所有⼈的使⽤的都是同⼀个对象，之前我们学单例模式的时候都知道，使⽤单例可以很⼤程度上提⾼性能，所以在 Spring 中Bean 的作⽤域默认也是 singleton 单例模式。
作用域定义
限定程序中变量的可⽤范围叫做作⽤域，或者说在源代码中定义变量的某个区域就叫做作⽤域。
⽽ Bean 的作⽤域是指 Bean 在 Spring 整个框架中的某种⾏为模式。
⽐如 singleton 单例作⽤域，就表 示 Bean 在整个 Spring 中只有⼀份，它是全局共享的，那么当其他⼈修改了这个值之后，那么另⼀个 ⼈读取到的就是被修改的值。
Bean 的 6 种作用域
Spring 容器在初始化⼀个 Bean 的实例时，同时会指定该实例的作⽤域。
Spring有 6 种作⽤域， 最后四种是基于 Spring MVC ⽣效的：
singleton：单例作⽤域
prototype：原型作⽤域（多例作⽤域）
request：请求作⽤域
session：回话作⽤域
application：全局作⽤域
注意后 4 种状态是 Spring MVC 中的值，在普通的 Spring 项⽬中只有前两种。
后四种是spring MVC中的值，仅适用于web的SpringWebApplicationContext环境中。
1. 普通 Spring 环境：
① singleton
-
官⽅说明：(Default) Scopes a single bean definition to a single object instance for each Spring IoC container.
-
描述：该作⽤域下的Bean在IoC容器中只存在⼀个实例：获取Bean（即通过applicationContext.getBean等⽅法获取）及装配Bean（即通过@Autowired注⼊）都是同⼀ 个对象。
-
场景：通常⽆状态的Bean使⽤该作⽤域。⽆状态表示Bean对象的属性状态不需要更新
- 备注：Spring默认选择该作⽤域
- Singleton是单例模式，就是在创建容器时就自动的创建了这个对象，无论是否使用，它都已经存在了，每次获取到的都是同一个对象。而且singleton是spring的默认作用域（缺省作用域）。
代码举例：
创建TestSingleton类作为bean:
package com; import org.springframework.stereotype.Component; @Component public class TestSingleton { private String message; public void setMessage(String message){ this.message = message; } public void getMessage(){ System.out.println("Your Message : " + message); } }在测试类中同时尝试获取两个bean，看输出信息是否相同，相同即同一个实例：
import com.Controller.UserController; import com.TestSingleton; import com.User.User; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; public class App { public static void main(String[] args) { ApplicationContext context=new ClassPathXmlApplicationContext("a.xml"); TestSingleton testSingleton_A=(TestSingleton)context.getBean("testSingleton"); System.out.println("下面是第一个bean的信息："); testSingleton_A.setMessage("This is A!"); testSingleton_A.getMessage(); TestSingleton testSingleton_B=(TestSingleton)context.getBean("testSingleton"); System.out.println("下面是第二个bean的信息："); testSingleton_B.getMessage(); } }输出：
下面是第一个bean的信息： Your Message : This is A! 下面是第二个bean的信息： Your Message : This is A!② prototype
-
官⽅说明：Scopes a single bean definition to any number of object instances.
-
描述：每次对该作⽤域下的Bean的请求都会创建新的实例：获取Bean（即通过applicationContext.getBean等⽅法获取）及装配Bean（即通过@Autowired注⼊）都是新的 对象实例
- 场景：通常有状态的Bean使⽤该作⽤域
- prototype是原型类型，在创建容器的时候并不会实例化对象，而是当我们尝试去获取一个bean时才会去创建一个对象，而且我们每次获取到的对象都不是同一个对象。
代码举例：
创建TestPrototype类作为bean，通过注解Scope将作用域类型设置为prototype:
package com; import org.springframework.context.annotation.Scope; import org.springframework.stereotype.Component; @Component @Scope("prototype") // 注解生效 public class TestPrototype { private String message; public void setMessage(String message){ this.message = message; } public void getMessage(){ System.out.println("Your Message : " + message); } }在测试类中获取两个bean，看输出信息是否相同，相同即是同一个实例，不同则是不同的实例：
import com.TestPrototype; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; public class App { public static void main(String[] args) { ApplicationContext context=new ClassPathXmlApplicationContext("a.xml"); TestPrototype testSingleton_A=(TestPrototype)context.getBean("testPrototype"); System.out.println("下面是第一个bean的信息："); testSingleton_A.setMessage("This is A!"); testSingleton_A.getMessage(); TestPrototype testSingleton_B=(TestPrototype)context.getBean("testPrototype"); System.out.println("下面是第二个bean的信息："); testSingleton_B.getMessage(); } }输出：
下面是第一个bean的信息： Your Message : This is A! 下面是第二个bean的信息： Your Message : null2. Spring Web 环境：
request、session、application这三个作用域是基于Spring WebApplicationContext实现的，只有在web环境下才能使用（比如XmlWebApplicationContext中）
如果在普通的spring环境下，即常规的IOC容器（比如ClassPathXmlApplicationContext）中使用这些作用域，那么程序会抛出一个IllegalStateException异常，来表明使用了未知的作用域。
而在web环境下，比如使用Spring中的WebApplicationContext时，我们不仅可以使用singleton和prototype这两个作用域，还可以使用三个独有的作用域：request、session、application.
在使用Web环境相关的作用域时，必须在Web容器中进行一些额外的配置：
- 如果使用的是Spring MVC框架，就不需这些配置，因为每一次http请求都会通过DispatcherServlet来处理，而DispatcherServlet中已经配置好了相关状态。
- 如果是低版本的web容器，需要在配置的XML文件中添加如下声明即可：
还可以使用Spring中的RequestContextFilter或者ServletRequestListener和其他方式，这里不再详细介绍。
③ request
request是请求作用域
- 官⽅说明：Scopes a single bean definition to the lifecycle of a single HTTP request. That is, each HTTP request has its own instance of a bean created off the back of a single bean definition. Only valid in the context of a web-aware Spring ApplicationContext.
-
描述：每次http请求会创建新的Bean实例，类似于prototype
-
场景：⼀次http的请求和响应的共享Bean
- 备注：限定SpringMVC中使⽤
在进行使用时，也是在scope属性中声明：
<bean id="" class="" scope="request"/>假设这个bean的id是loginAction，Spring容器每一次用loginAction来处理Http请求时都会创建一个新的实例，即loginAction 这个bean的作用域是Http Request级别的。
当Http请求调用作用域级别为Request的bean时，每增加一个Http请求，Spring就会创建一个新的bean，当请求处理完成之后变回销毁这个bean，开发者可以任意的改变一个实例的状态，因为每一个bean之间都是根据独立的请求来的，其他实例根本看不到其他被开发者改变的实例的状态。
④ session
session是会话作用域
-
官⽅说明：Scopes a single bean definition to the lifecycle of an HTTP Session. Only valid in the context of a web-aware Spring ApplicationContext.
-
描述：在⼀个http session中，定义⼀个Bean实例
-
场景：⽤户回话的共享Bean, ⽐如：记录⼀个⽤户的登陆信息
- 备注：限定SpringMVC中使⽤
同一个Http Session(会话)之间共享一个bean，而不同的会话使用不同的bean.
在使用时，可以在scope属性中声明：
<bean id="user" class="" scope="session"/>假设bean的id是user，Spring容器每次调用user的时候，都会在一个会话中创建一个实例，即这个bean是Http Session级别的。
Session中的所有http请求共享一个Bean，每次用Session级别的bean处理会话时，每增加一个会话，都会创建一个新的实例。与上面的request一样，开发者可以随意修改bean的状态，因为每个bean都是根据单独的会话session来创建的，其他的bean无法看到这个bean的状态。
⑤ application
application是全局作用域。
● 官⽅说明：Scopes a single bean definition to the lifecycle of a ServletContext. Only valid in the context of a web-aware Spring ApplicationContext.
● 描述：在⼀个http servlet Context中，定义⼀个Bean实例
● 场景：Web应⽤的上下⽂信息，⽐如：记录⼀个应⽤的共享信息
备注：限定SpringMVC中使⽤
使用方式：
<bean id="app" class="" scope="application"/>假设bean的id为app，Spring容器会在整个web应用范围使用到app的时候创建一个新的实例。也就是说，appBean是在ServletContext级别的.。
单例作⽤域(singleton)和全局作⽤域(application)区别
-
singleton 是 Spring Core 的作⽤域；application 是 Spring Web 中的作⽤域；
- singleton 作⽤于 IoC 的容器，⽽ application 作⽤于 Servlet 容器。
如何设置 Bean 作用域
1. 通过xml配置文件
在xml配置文件中，直接设置bean元素的scope属性即可。
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"> //scope属性 <bean id="SingletonBean" class="com.spring.demo.SingletonBean" scope="prototype"> </bean> </beans>2. 通过注解
在bean上添加注解：
@Component(“SingletonBean”)标识这个类是一个bean，@Scope(“prototype”)标识这个bean的作用域为prototype类型。
Bean 执行流程
Bean 执⾏流程（Spring 执⾏流程）：
启动 Spring 容器 -> 实例化 Bean（分配内存空间，从⽆到有）-> Bean 注册到 Spring 中（存操作） -> 将 Bean 装配到需要的类中（取操作）。
Bean ⽣命周期
Bean的生命周期指一个Bean对象从“出生”到“销毁”的过程，可以表达为：
Bean的定义——>Bean的初始化——>Bean的使用——>Bean的销毁.
具体过程如下：
进行初始化：
- 实现各种通知（Aware）方法，如BeanNameAware、BeanFactoryAware、BeanFactoryAware、ApplicationContextAware等
- 执行BeanPostProcessor初始化前置方法
- 执行@PostConstruct初始化方法，注入依赖后执行
- 执行自定义的inti-method方法（可有可无）
- 执行BeanPostProcessor初始化后置方法。
销毁容器的各种⽅法，如 @PreDestroy、DisposableBean 接⼝⽅法、destroy-method。
执⾏流程如下图所示：
1. 实例化和初始化的区别
实例化和属性设置是 Java 级别的系统“事件”，其操作过程不可⼈⼯⼲预和修改
初始化是给 开发者提供的，可以在实例化之后，类加载完成之前进⾏⾃定义“事件”处理。
2. ⽣命流程的“故事”
Bean 的⽣命流程看似繁琐，但咱们可以以⽣活中的场景来理解它。
⽐如我们现在需要买⼀栋房⼦，那 么我们的流程是这样的：
⽣命周期演示
import com.bit.service.UserService; import org.springframework.beans.factory.BeanNameAware; import org.springframework.beans.factory.annotation.Autowired; import javax.annotation.PostConstruct; import javax.annotation.PreDestroy; public class UserController10 implements BeanNameAware { @Autowired private UserService userService; @Override public void setBeanName(String s) { System.out.println("执行通知：" + s); } // 初始化方法 @PostConstruct public void postConstruct() { System.out.println("执行 @PostConstruct 方法"); } public void init() { // init() 方法名字可以随便起，只需要和 xml 中的名称保持一致即可 System.out.println("执行 init 方法"); } @PreDestroy public void preDestroy() { System.out.println("执行 @PreDestroy"); } public void destroy() { System.out.println("执行 destroy 方法"); } }xml 配置如下：
<?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"> <!-- 配置 Spring 扫描的根路径（此根路径下的所有 Spring 存对象的注解才能生效） --> <content:component-scan base-package="com.bit"></content:component-scan> <beans> <bean id="userController10" class="com.bit.controller.UserController10" init-method="init" destroy-method="destroy"></bean> </beans> </beans>启动类：
/** * Spring 启动类（非必须，为了方便演示 Spring 的功能而创建） */ public class App { public static void main(String[] args) { // 1.先获取对象的 ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring.xml"); UserController10 userController10 = context.getBean("userController10", UserController10.class); context.destroy(); // 销毁方法 } }效果如下：