【Spring core学习四】Bean作用域和生命周期

IUIUStar

已于 2023-07-18 21:59:04 修改

阅读量979

点赞数 1

分类专栏： Spring学习文章标签： spring 学习 java

于 2023-07-18 21:56:44 首次发布

本文链接：https://blog.csdn.net/qq_48479056/article/details/131730588

版权

Spring学习专栏收录该内容

14 篇文章 2 订阅

订阅专栏

一、Bean的作用域

🌈1、被修改的Bean值现象

UserService类：

UserController1类：修改姓名

UserController2类：

执行结果：

分析：公共 Bean，A ⽤户使⽤时，进⾏了修改操作，B ⽤户再去使⽤公共 Bean 的时候，获取到的是被修改的值。操作以上问题的原因是因为 Bean 默认情况下是单例状态（singleton），也就是所有⼈的使⽤的都是同⼀个对象，使⽤单例可以很⼤程度上提⾼性能，在 Spring 中Bean 的作⽤域默认也是单例模式。

🌈2、 Bean 的 6 种作⽤域

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

        该作⽤域下的Bean在IoC容器中只存在⼀个实例：获取Bean（即通过
applicationContext.getBean等⽅法获取）及装配Bean（即通过@Autowired注⼊）都是同⼀个对象。

比如我们要区分两个学生一定是属性不同，如果两个个对象各种属性都相同，那么就认为是同一个对象，所以可以共享一个对象的，我们就称为是无状态的。使用场景：一般无状态的Bean，使用该单例作用域，也就是Bean对象的属性不需要更新。（每次获取的Bean都是相同的一个对象）
（2）prototype：原型作⽤域（多例作⽤域）

每次获取的Bean都是一个新的对象。
（3）request：请求作⽤域

        在一次http请求中获取的是同一个Bean，每次http请求会创建新的Bean实例。类似于prototype。
（4） session：会话作⽤域

        在⼀个session中，是⼀个相同的Bean实例；在Session过期后，获取的就是新的一个Bean。
（5）application：全局作⽤域

        在⼀个http servlet Context中，定义⼀个Bean实例。
（6）websocket：HTTP WebSocket 作⽤域

      在⼀个HTTP WebSocket的⽣命周期中，定义⼀个Bean实例。

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

singleton 是 Spring Core 的作⽤域；application 是 Spring Web （Spring MVC）中的作⽤域；
singleton 作⽤于 IoC 的容器，⽽ application 作⽤于 Servlet 容器。
Application 作用域是对于整个web容器来说，bean的作用域是ServletContext级别的，和singleton有点类似，但是区别在于Application作用域是ServletContext级别，singleton是一个ApplicationContext的单例。（一个web 服务，只有一个ServletContext，但是可以有多个ApplicationContext）

演示在一个ApplicationContext下获取到的是同一个单例

🌈3、设置作用域

使⽤ @Scope 标签就可以⽤来声明 Bean 的作⽤域，⽐如设置 Bean 的作⽤域
在第一部分，我们将代码做如下修改：

二、Spring的执行流程

Bean 执⾏流程（Spring 执⾏流程）：

启动 Spring 容器
实例化 Bean（分配内存空间，从⽆到有）
Bean 注册到 Spring 中（存操作）
将 Bean 装配到需要的类中（取操作)

三、Bean的生命周期

🌈1、Bean生命周期的过程

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

Bean 的⽣命周期分为以下 5 ⼤部分：

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

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

（3）Bean初始化：

实现各种Aware通知的方法：如BeanNameAware，BeanFactoryAware，ApplicationContextAware 的接⼝⽅法；
执行BeanPostProcessor初始化前置方法；
执行@PostContruct初始化方法，依赖注入操作之后被执行；
执行自己指定的Init-method方法（如果有指定的话）；
执行BeanPostProcessor初始化后置方法；

（4）使用Bean;

（5）销毁Bean。

Bean 的⽣命流程看似繁琐，用一个例子来比喻一下：⽐如我们现在需要买⼀栋房⼦，那么我们的流程是这样的：
1. 先买房（实例化，从⽆到有）；
2. 装修（设置属性）；
3. 买家电，如洗⾐机、冰箱、电视、空调等（[各种]初始化）；
4. ⼊住（使⽤ Bean）；
5. 卖出去（Bean 销毁）

上面一个过程可能比较抽象，尤其是第三步初始化中，很多顺序理解不清楚，所以遇见比较抽象的东西，我们可以用代码来验证一下。

🌈2、演示生命周期

下面的代码不需要掌握，只是根据代码进一步理解生命周期的执行过程即可。

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">
       <content:component-scan base-package="beanLife"></content:component-scan>
       <bean id = "beanLifeComponent" class = "beanLife.BeanLifeComponent" init-method="init"></bean>
</beans>

BeanLifeComponent类

import org.springframework.beans.factory.BeanNameAware;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;

//交给Spring管理
@Component
public class BeanLifeComponent implements BeanNameAware {

    //0.构造函数
    public BeanLifeComponent(){
        System.out.println("执行构造函数");
    }

    //1.实现这个接口：通知
    @Override
    public void setBeanName(String s) {
        System.out.println("设置了BeanName:"+s);
    }
    //2.设置前置方法
    @PostConstruct
    public void postConstruct(){
        System.out.println("执行postConstruct方法");
    }
//    这个方法不论是否执行，都会执行12步
    public void sayHello(){
        System.out.println("hello");
    }

    //3、init-method方法
    public void init(){
        System.out.println("执行init方法");
    }

    //4、销毁bean
    public void preDestroy(){
        System.out.println("执行了destroy方法");
    }
}

public class Main {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
        //通过类名拿到对象
        BeanLifeComponent component = context.getBean((BeanLifeComponent.class));
        //执行sayHello方法
//        component.sayHello();
        //销毁方法
        component.preDestroy();
    }
}

测试结果：与前文的总结顺序一致。

注意：

IUIUStar

关注

1
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
【Spring core学习四】Bean作用域和生命周期

UserService类：UserController1类：修改姓名UserController2类：执行结果：分析：公共 Bean，A ⽤户使⽤时，进⾏了修改操作，B ⽤户再去使⽤公共 Bean 的时候，获取到的是被修改的值。操作以上问题的原因是因为 Bean 默认情况下是单例状态（singleton），也就是所有⼈的使⽤的都是同⼀个对象，使⽤单例可以很⼤程度上提⾼性能，在Spring 中Bean 的作⽤域默认也是单例模式。
复制链接

扫一扫