Bean的作用域和生命周期

最新推荐文章于 2024-10-09 11:13:12 发布

小李（写代码版）

最新推荐文章于 2024-10-09 11:13:12 发布

阅读量48

点赞数 3

文章标签： java 前端数据库

本文链接：https://blog.csdn.net/m0_57248630/article/details/131943982

版权

文章详细介绍了Spring框架中Bean的六种作用域，包括singleton、prototype、request、session、application和websocket，以及它们各自的特点和适用场景。此外，还阐述了Spring的启动流程和Bean的生命周期，包括实例化、属性设置、初始化、使用和销毁等阶段，并通过生活中的例子帮助理解Bean的生命周期。

摘要由CSDN通过智能技术生成

1.作用域定义

限定程序中变量的可⽤范围叫做作⽤域，或者说在源代码中定义变量的某个区域就叫做作⽤域。⽽ Bean 的作⽤域是指 Bean 在 Spring 整个框架中的某种⾏为模式，⽐如 singleton 单例作⽤域，就表示 Bean 在整个 Spring 中只有⼀份，它是全局共享的，那么当其他⼈修改了这个值之后，那么另⼀个⼈读取到的就是被修改的值。

1.1Bean的六种作用域

Spring 容器在初始化⼀个 Bean 的实例时，同时会指定该实例的作⽤域。Spring有 6 种作⽤域，最后四种是基于 Spring MVC ⽣效的：

1. singleton：单例作⽤域

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

3. request：请求作⽤域

4. session：回话作⽤域

5. application：全局作⽤域

6. websocket：HTTP WebSocket 作⽤域

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默认选择该作用域。

prototype:

官⽅说明：Scopes a single bean definition to any number of object instances.

描述：每次对该作⽤域下的Bean的请求都会创建新的实例：获取Bean（即通过applicationContext.getBean等方法获取）及装配Bean（即通过@Autowired注⼊）都是新的对象实例。

场景：通常有状态的Bean使用该作用域。

requet：

官⽅说明：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中使⽤

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中使⽤

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中使⽤

websocket：

官⽅说明：Scopes a single bean definition to the lifecycle of a WebSocket. Only valid in the

context of a web-aware Spring ApplicationContext

描述：在⼀个HTTP WebSocket的⽣命周期中，定义一个Bean对象

场景：WebSocket的每次会话中，保存了⼀个Map结构的头信息，将⽤来包裹客户端消息头。第⼀

次初始化后，直到WebSocket结束都是同⼀个Bean。

备注：限定Spring Websocket中使用

单例作⽤域(singleton) VS 全局作⽤域(application)

singleton 是 Spring Core 的作⽤域；application 是 Spring Web 中的作⽤域；

singleton 作⽤于 IoC 的容器，⽽ application 作⽤于 Servlet 容器。

ApplicationContext context=new ClassPathXmlApplicationContext("spring-config.xml");
ScopeController scopeController=context.getBean(ScopeController.class);
scopeController.sayHi();
ScopeController scopeController2=context.getBean(ScopeController.class);
scopeController2.sayHi();

singleton执行结果相同

ApplicationContext context=new ClassPathXmlApplicationContext("spring-config.xml");
ScopeController scopeController=context.getBean(ScopeController.class);
scopeController.sayHi();
ApplicationContext context2=new ClassPathXmlApplicationContext("spring-config.xml");
ScopeController scopeController2=context2.getBean(ScopeController.class);
scopeController2.sayHi();

application执行结果不同

1.2设置作用域

使⽤ @Scope 标签就可以⽤来声明 Bean 的作⽤域，⽐如设置 Bean 的作⽤域，如下代码所示：

public class Users {
    @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
    @Bean(name = "u1")
    public User user1() {
        User user = new User();
        user.setAge(1);
        user.setName("Java"); // 【重点：名称是 Java】
        return user;
    }
}

@Scope 标签既可以修饰⽅法也可以修饰类，@Scope 有两种设置⽅式：

1. 直接设置值：@Scope("prototype")

2.使用枚举设置：@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)

2.sprine:g的启动流程

2.1spring的执行流程

Bean 执⾏流程（Spring 执⾏流程）：启动 Spring 容器 -> 实例化 Bean（分配内存空间，从⽆到

有） -> Bean 注册到 Spring 中（存操作） -> 将 Bean 装配到需要的类中（取操作)。

2.2Bean的生命周期

1.实例化 Bean（为 Bean 分配内存空间）（不等于初始化）

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

3.Bean 初始化

实现了各种 Aware 通知的⽅法，如 BeanNameAware、BeanFactoryAware、

ApplicationContextAware 的接⼝⽅法；

执⾏ BeanPostProcessor 初始化前置⽅法；

执⾏ @PostConstruct 初始化⽅法，依赖注⼊操作之后被执⾏；

执⾏⾃⼰指定的 init-method ⽅法（如果有指定的话）；

执⾏ BeanPostProcessor 初始化后置⽅法。

4.使⽤ Bean

5.销毁 Bean

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

执行流程如下图所示：

实例化和初始化的区别：

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

生命流程的故事：

Bean 的⽣命流程看似繁琐，但咱们可以以⽣活中的场景来理解它，⽐如我们现在需要买⼀栋房⼦，那么我们的流程是这样的：

1. 先买房（实例化，从⽆到有）；

2. 装修（设置属性）；

3. 买家电，如洗⾐机、冰箱、电视、空调等（[各种]初始化）；

4. ⼊住（使⽤ Bean）；

5. 卖出去（Bean 销毁）。

生命周期演示：

public class BeanLifeComponent implements BeanNameAware {
    public BeanLifeComponent() {
        System.out.println("执行构造函数");
    }

    /**
     * spring初始化方法
     * @param s
     */
    @Override
    public void setBeanName(String s) {
        System.out.println("设置"+s);
    }

    /**
     * spring初始化方法
     */
    @PostConstruct
    public void postConstruct(){
        System.out.println("执行方法");
    }
    public void hi(){
        System.out.println("hi");
    }
    public void init(){
        System.out.println("执行init方法");
    }
    @PreDestroy
    public void destroy(){
        System.out.println("执行销毁方法");
    }
    public void destory2(){
        System.out.println("执行销毁方法2");
    }


}

<content:component-scan base-package="component"></content:component-scan>
<bean id="beanlife" class="component.BeanLifeComponent" init-method="init" destroy-method="destory2"></bean>

public class App2 {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext context=new ClassPathXmlApplicationContext("spring-config.xml");
        BeanLifeComponent beanLifeComponent=context.getBean(BeanLifeComponent.class);
        beanLifeComponent.hi();

        context.destroy();
    }
}

由执行结果可以看出，先执行context，再执行bean