Bean的作用域和生命周期

最新推荐文章于 2023-08-01 22:07:13 发布
最新推荐文章于 2023-08-01 22:07:13 发布
阅读量244 收藏
点赞数 1
分类专栏： SpringBoot 文章标签： Bean
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45364220/article/details/124477762
版权

1. Bean 的作用域案例

package Beans.Component;

import Model.User;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;

@Component
public class UserComponent {
    @Bean
    public User getUser(){
        User user=new User();
        user.setUserId(0);
        user.setUserName("张三");
        return user;
    }
}


package Beans.Controller;

import Model.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

@Controller
public class UserControllerA {
    @Autowired
    private User user;
    public User getUser(){
        System.out.println("Bean原name：" + user.getUserName());
        // 修改公共 Bean
        user.setUserName("王五");
        return user;
    }
}

A使用完之后修改了 User 的 name 属性

我们来看看后续用户使用 User 的情况

package Beans.Controller;

import Model.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

@Controller
public class BeanScopeControllerB {
    @Autowired
    private User user;

    public User getUser() {
        return user;
    }
}


import Beans.Controller.UserControllerA;
import Beans.Controller.UserControllerB;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class App {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
        UserControllerA A = context.getBean(UserControllerA.class);
        System.out.println("修改之前：" + A.getUser());

        UserControllerB B = context.getBean(UserControllerB.class);
        System.out.println("修改之后：" + B.getUser());
    }
}

// 运行结果
Bean原name：张三
修改之前：User{userId=0, userName='王五'}
修改之后：User{userId=0, userName='王五'}

发现 A 的修改作用到了 B 上

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4GItMSpf-1651447791413)(/Users/cxf/Desktop/MarkDown/images/作用域的修改.png)]

原因分析

以上的原因是因为 Bean 的单例模式导致的，单例模式中可以很大程度提升性能，因此 Spring 的 Bean 作用域默认也是 Singleton。所以中间只要被修改，后续的都会受到影响。

作用域定义

限定代码中变量的作用范围「定义某个变量的区域就是作用域」

Bean 的单例模式修改之后会影响后续的代码使用，从作用域的角度来看会发现 Bean 的单例模式作用域是在整个Spring框架下的

2. Bean 的六种作用域

2.1 singleton「单例作用域」

运用：在普通的 Spring 项目中

描述：该作用域下的 Bean 对象在 IOC 容器中只有一份「即ApplicationContext.getBean( )获取或者@Autowired装配都是同一个 Bean」

场景：通常 无状态 的 Bean 使用该作用域。无状态：Bean 对象的属性状态不需要更新

备注：Spring 默认选择该作用域

package Beans.Component;

import Model.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

@Component
public class UserComponent {
    @Scope("singleton")
    @Bean(name = {"getUser", "gU"})
    public User getUser(){
        User user=new User();
        user.setUserId(0);
        user.setUserName("张三");
        return user;
    }
}

// 运行结果
Bean原name：张三
修改之前：User{userId=0, userName='王五'}
修改之后：User{userId=0, userName='王五'}

2.2 prototype「原型作用域」

运用：在普通的 Spring 项目中

描述：每次对该作用于下的 Bean 请求都会创建新的实例「多例模式」：即ApplicationContext.getBean( )获取或者@Autowired装配都是一个新的对象实例

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

package Beans.Component;

import Model.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

@Component
public class UserComponent {
    @Scope("prototype")
    @Bean(name = {"getUser", "gU"})
    public User getUser(){
        User user=new User();
        user.setUserId(0);
        user.setUserName("张三");
        return user;
    }
}
// 运行结果
Bean原name：张三
修改之前：User{userId=0, userName='王五'}
修改之后：User{userId=0, userName='张三'}

补充一个额外的注解

package Beans.Component;

import Model.User;
import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

@Component
public class UserComponent {
    @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
    @Bean(name = {"getUser", "gU"})
    public User getUser(){
        User user=new User();
        user.setUserId(0);
        user.setUserName("张三");
        return user;
    }
}

2.3 request「请求作用域」

运用：限定在 SpringMvc 项目中

描述：每次 HTTP 请求都会创建新的 Bean 实例，类似于 prototype

场景：一次 HTTP 请求和响应的共享 Bean

2.4 session「会话作用域」

运用：限定在 SpringMvc 项目中

描述：在一个 HTTP Session 中定一个 Bean 实例

场景：用户回话的共享 Bean，比如：记录一用户的登录信息

2.5 application「全局作用域，了解即可」

运用：限定在 SpringMvc 项目中

描述：在一个 HTTP ServleContext 中，定一个 Bean 实例

场景：Web 应用的上下文信息，比如：记录一个应用的共享信息

2.6 websocket「HTTP WebSocket 作用域，了解即可」

运用：限定在 SpringWebSocket 项目中

描述：再以一个 HTTP WebSocket 的生命周期中，保存了一个 Map 结构的头信息，将用来包裹客户端信息头。第一次初始化后，直到 WebSocket 结束都是同一个 Bean

2.7 单例作用域（singleton）和全局作用域（application）区别

  • singleton 是 Spring Core 的作用域；application 是 Spring Web 中的作用域
  • singleton 作用域 IOC 容器，而 application 作用域 Servlet 作用域

3. Bean 的原理分析

3.1 Bean 执行流程

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Y2FzqnsC-1651447791415)(/Users/cxf/Desktop/MarkDown/images/Bean的执行流程.png)]

Bean执行流程「Spring执行流程」：启动 Spring 容器 -> 实例化 Bean「分配内存，从无到有」 -> Bean 注册到 Spring 中「存」 -> 将 Bean 装配到需要的类中「取」

3.2 Bean 生命周期

了解了 Servlet 的生命周期：每个 Servlet 都是从 Tomcat 实例化出来的对象 init() 自动调用「诞生」 -> 根据每个 HTTP 请求来进行对应的响应「应用」-> 最后结束运行的时候会调用 **destory()**自动销毁

那么 Bean 对像的生命周期又是什么呢？可以分为 5 部分

  1. 实例化 Bean「为 Bena 分配内存」
  2. 设置属性「Bean的依赖注入和装配」
  3. Bean 初始化
    • 实现了各种 Aware 通知的方法，如 BeanNameAware，BeanFaactoryAware，ApplicationContextAware 的接口方法
    • 执行 BeanPostProcessor 初始化前置方法
    • 执行 @PostConstruct 初始化方法，依赖注入操作之后被执行
    • 执行自己制定的 init-method 方法「如果有指d定方法」
    • 执行 BeanPostProcessor 初始化后置方法
  4. 使用 Bean
  5. 销毁 Bean

销毁容器的各种方法，如 @PreDestory，DIsposableBean 接口方法，destory-method

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kVD1OABB-1651447791416)(/Users/cxf/Desktop/MarkDown/images/Bean生命周期.png)]

package Beans.Component;

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

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

@Component
public class BeanLife implements BeanNameAware {
    @Override
    public void setBeanName(String s) {
        System.out.println("执行：BeanNameAware 方法" + s);
    }

    /**
     * 初始化方法1
     */
    @PostConstruct
    public void postConstruct1(){
        System.out.println("执行：PostConstruct");
    }

    /**
     * 初始化方法2
     */
    @PostConstruct
    public void init2(){
        System.out.println("执行：init-method");
    }

    /**
     * 销毁方法1
     */
    @PreDestroy
    public void preDestroy(){
        System.out.println("执行：preDestroy");
    }

    /**
     * 销毁方法2
     */
    public void myDestroy(){
        System.out.println("执行：destroy-method");
    }
}

spring-config.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="Beans"></content:component-scan>
    <!--  Bean的初始化和销毁  -->
    <beans>
        <bean id="beanLife" class="Beans.Component.BeanLife" init-method="init2" destroy-method="myDestroy"></bean>
    </beans>
</beans>

import Beans.Component.BeanLife;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class App {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext context=new ClassPathXmlApplicationContext("spring-config.xml");
        BeanLife beanLife=context.getBean(BeanLife.class);
        System.out.println("使用Bean");
        System.out.println("销毁Bean");
        context.destroy();
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Nq79aUOr-1651447791418)(/Users/cxf/Desktop/MarkDown/images/代码解析.png)]

这里边一个是 xml的产物，一个是 @注解的产物。描述的都是一个事情，只是形式不一样罢了。

  • 初始化： PostConstruct 是通过注解的形式执行调用，init-method 是通过配置 spring-config.xml 执行调用的「注意方法名要关联才可以被调用到」
  • 销毁： PreDestroy 是通过注解的形式执行调用，destroy-method 是通过配置 spring-config.xml 执行调用的「注意方法名要关联才可以被调用到」

3.3 实例化 VS 初始化

实例化是步骤2「先分配内存，在分配属性」，初始化「给属性赋值」是步骤3

这俩操作能不能颠倒过来呢？

那之前的代码例子来说

@Service
public class UserService {
    public UserService() {
        System.out.println("
                User Service");
    }

    public void sayHi() {
        System.out.println("User Service SayHi.");
    }
}

@Controller
public class UserController {
    @Resource
    private UserService userService;

    @PostConstruct
    public void postConstruct() {
        userService.sayHi();
        System.out.println(" User Controller ");
    }
}

如果先执行了初始化，则代码15行中的设置属性还没有生成，肯定会出现异常情况。因此必须先设置完属性在初始化

Spring 的加载过程是 先外后内：先把外部的东西准备好，在加载内部的变量

你去把唐僧使徒除掉
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SPRING FRAMEWORK BEAN作用域和生命周期原理解析
08-25
SPRING FRAMEWORK BEAN作用域和生命周期原理解析 Spring Framework 是一个流行的 Java Web 应用程序框架，它提供了一个强大的依赖注入机制，称为 Bean 容器。Bean 容器管理着应用程序中的所有对象，并提供了一些...
深入了解Spring中Bean的作用域和生命周期
08-25
在 Spring 中，Bean 的作用域是指 Bean 实例的生命周期和共享程度。Spring 提供了五种作用域：singleton、prototype、request、session 和 globalSession。每种作用域都有其特点和应用场景。 1. Singleton 作用域 ...
【JavaEE】深入了解Spring中Bean的可见范围（作用域）以及前世今生（生命周期）
最新发布
Carefree_State的博客
08-01 1560
本文章主要讲解Spring中Bean的作用域和生命周期。作用域的一个例子，定义，六种不同的作用域，如何设置Bean的作用域。Spring的执行流程，生命周期，Bean的详细生命周期讲解，初始化过程讲解，代码演示...
【Spring】Bean 的作用域和生命周期
潘潘的博客
07-13 197
Bean 的作用域和生命周期
【Spring】Bean的作用域和生命周期
DerrickWestbrook的博客
06-15 382
假设现在有⼀个公共的 Bean，提供给 A ⽤户和 B ⽤户使⽤，然⽽在使⽤的途中 A ⽤户却“悄悄”地修改 了公共 Bean 的数据，导致 B ⽤户在使⽤时发⽣了预期之外的逻辑错误。（说好⼀起到⽩头，你却悄悄 焗了油）。 操作以上问题的原因是因为 Bean 默认情况下是单例状态（singleton），也就是所有⼈的使⽤的都是同 ⼀ 个对象，之前我们学单例模式的时候都知道，使用单例可以很⼤程度上提高性能，所以在 Spring 中 Bean 的作⽤域默认也是 singleton 单例模式。限定程序
Bean的生命周期、作用域
qq_37933128的博客
10-02 1387
在设置属性阶段后，postProcessBeforeInitialization方法执行前，会执行很多Aware类型的接口，这种类型接口作用是加载资源到Spring容器中，让bean获取Spring容器中的服务。1.InitializingBean的afterPropertiesSet方法。2.DisposableBean接口的destroy()方法。3.配置的destroy-method。在初始化阶段，有个特别重要的接口。3.配置的init-method。
Bean的作用域及生命周期
你能找到这里，说明你有经天纬地之才，扭转乾坤只能，鬼神不测之计包藏宇宙之志，真乃乱世之枭雄，治世之能臣也
07-23 1521
Singleton：单例-整个容器只有一个对象实例默认是单例（使用Singleton定义的bean在spring容器中将只有一个实例，也就是说无论多少个bean引用ta，始终指向同一个对象） Prototype：原型-每次获取bean都产生一个新的对象（每个通过spring容器获取prototype定义的bean时，容器都将创建一个新的bean实例） Request：每次请求时创建一个新的对象 Session：在会话的范围内是一个对象 Global session：--只在portlet下有用，表示
浅谈Spring中Bean的作用域、生命周期
08-28
在Spring框架中，Bean的作用域是指Bean实例的生命周期和可见性域。Spring框架中定义了五种作用域，分别是singleton、prototype、request、session和global session。 1. singleton：单例模式，Spring IoC容器中只会...
详解Spring中Bean的生命周期和作用域及实现方式
08-31
Spring中Bean的生命周期和作用域及实现方式 Spring是一个非常流行的Java应用程序框架，它提供了一个灵活的机制来管理Bean的生命周期和作用域。Bean的生命周期和作用域是Spring框架中两个非常重要的概念，它们决定了...
简单了解spring bean作用域属性singleton和prototype的区别
08-25
Spring Bean作用域属性singleton和prototype的区别详解 Spring Framework中，Bean的作用域属性是指Bean实例的生命周期和作用域。Spring提供了五种作用域：singleton、prototype、request、session和global session...
Spring IOC原理补充说明(循环依赖、Bean作用域等)
09-07
Spring IOC，即控制反转（Inversion of Control），是Spring框架的核心特性，它负责管理对象的生命周期和依赖关系。本文将深入探讨Spring如何处理循环依赖以及Bean的作用域。 **循环依赖** 循环依赖是指两个或多个...
Spring实战之协调作用域不同步的Bean操作示例
08-25
在Spring框架中， Bean的作用域（Scope）是指Bean的生命周期范围。 Spring框架提供了五种作用域：Singleton（单例）、Prototype（原型）、Request（请求）、Session（会话）和GlobalSession（全局会话）。其中，...
Spring配置使用之Bean生命周期详解
08-29
这个过程是非常重要的，因为它决定了 Bean 的生命周期和行为。 基本概念 在 Spring 中，Bean 的生命周期指的是 Bean 从创建到销毁的过程。这个过程包括了 Bean 的实例化、初始化、销毁等几个阶段。 lazy-init ...
Spring框架中Bean的生命周期 Spring中Bean有几种作用域
04-01
NULL 博文链接：https://cici9898-007.iteye.com/blog/1407695
Bean 作用域与生命周期
qq_54219272的博客
07-18 1273
​ 限定程序中变量的可用范围叫做作用域，或者说在源代码中定义变量的某个区域就叫做作用域。
Bean作用域和生命周期
m0_67683346的博客
02-09 440
Spring中Bean对象的作用域和生命周期
Spring bean的作用域和生命周期
05-12
Spring Bean 的作用域和生命周期是 Spring 框架中非常重要的两个概念，这里简单介绍一下。 1. Bean 的作用域 在 Spring 中，Bean 的作用域指的是 Bean 实例的创建和销毁的范围。Spring 提供了以下五种作用域： - ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值