【Spring高级】Bean作用域Scope及失效分析

最新推荐文章于 2024-05-01 11:14:59 发布
最新推荐文章于 2024-05-01 11:14:59 发布
阅读量1k 收藏 21
点赞数 24
分类专栏： # Spring高级 文章标签： spring java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43745578/article/details/136807789
版权

目录

Scope种类

在 Spring 里面，可以设置创建 bean 的作用域。

目前Spring Bean的作用域或者说范围主要有五种。

作用域描述
singleton在spring IoC容器仅存在一个Bean实例，Bean以单例方式存在，bean作用域范围的默认值。
prototype每次从容器中调用Bean时，都返回一个新的实例，即每次调用getBean()时，相当于执行newXxxBean()。
request每次HTTP请求都会创建一个新的Bean，该作用域仅适用于web的Spring WebApplicationContext环境。
session同一个HTTP Session共享一个Bean，不同Session使用不同的Bean。该作用域仅适用于web的Spring WebApplicationContext环境。
application限定一个Bean的作用域为ServletContext的生命周期。该作用域仅适用于web的Spring WebApplicationContext环境。

Singleton

表示Spring IoC容器中只会存在一个共享的bean实例，并且所有对bean的请求，只要id与该bean定义相匹配，则只会返回bean的同一实例。Singleton是单例类型，就是在创建起容器时就同时自动创建了一个bean的对象，不管你是否使用，他都存在了，每次获取到的对象都是同一个对象。spring中作用域默认是singleton。要在XML中将bean定义成singleton，可以这样配置：

<bean id="ServiceImpl" class="cn.example.service.ServiceImpl" scope="singleton">

Prototype

表示一个bean定义对应多个对象实例。Prototype作用域的bean会导致在每次对该bean请求（将其注入到另一个bean中，或者以程序的方式调用容器的getBean()方法）时都会创建一个新的bean实例。Prototype是原型类型，它在我们创建容器的时候并没有实例化，而是当我们获取bean的时候才会去创建一个对象，而且我们每次获取到的对象都不是同一个对象。根据经验，对有状态的bean应该使用prototype作用域，而对无状态的bean则应该使用singleton作用域。在XML中将bean定义成prototype，可以这样配置：

<bean id="account" class="com.foo.DefaultAccount" scope="prototype"/>  
 <!-- 或者 -->
<bean id="account" class="com.foo.DefaultAccount" singleton="false"/>

Request

表示在一次HTTP请求中，一个bean定义对应一个实例；即每个HTTP请求都会有各自的bean实例，它们依据某个bean定义创建而成。该作用域仅在基于web的Spring ApplicationContext情形下有效。

针对每次HTTP请求，Spring容器会根据loginAction bean的定义创建一个全新的LoginAction bean实例，且该loginAction bean实例仅在当前HTTP request内有效，因此可以根据需要放心的更改所建实例的内部状态，而其他请求中根据loginAction bean定义创建的实例，将不会看到这些特定于某个请求的状态变化。当处理请求结束，request作用域的bean实例将被销毁。

Session

表示在一个HTTP Session中，一个bean定义对应一个实例。该作用域仅在基于web的Spring ApplicationContext情形下有效。

针对某个HTTP Session，Spring容器会根据userPreferences bean定义创建一个全新的userPreferences bean实例，且该userPreferences bean仅在当前HTTP Session内有效。与request作用域一样，可以根据需要放心的更改所创建实例的内部状态，而别的HTTP Session中根据userPreferences创建的实例，将不会看到这些特定于某个HTTP Session的状态变化。当HTTP Session最终被废弃的时候，在该HTTP Session作用域内的bean也会被废弃掉。

Global Session

表示在一个全局的HTTP Session中，一个bean定义对应一个实例。典型情况下，仅在使用portlet context的时候有效。该作用域仅在基于web的Spring ApplicationContext情形下有效。

global session作用域类似于标准的HTTP Session作用域，不过仅仅在基于portlet的web应用中才有意义。Portlet规范定义了全局Session的概念，它被所有构成某个portlet web应用的各种不同的portlet所共享。在global session作用域中定义的bean被限定于全局portlet Session的生命周期范围内。

Scope失效

为什么失效

案例演示：

创建F1，设置为多例，

package com.cys.spring.chapter07;

import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

@Component
@Scope("prototype")
public class F1 {
}

在配置类中注入F1：

package com.cys.spring.chapter07;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;


@Component
public class E {

    @Autowired
    private F1 f1;

    private F1 getF1() {
        return f1;
    }

}

测试类

package com.cys.spring.chapter07;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.ComponentScan;


@ComponentScan("com.cys.spring.chapter07")
public class TestScope {

    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(TestScope.class);
        E e = context.getBean(E.class);

        // 打印两次观察两个F1是否是同一个
      	System.out.println(e.getF1().getClass());
        System.out.println(e.getF1());
        System.out.println(e.getF1());

        context.close();

    }
}

运行结果两个对象是同一个

class com.cys.spring.chapter07.F1$$EnhancerBySpringCGLIB$$6816bc69
com.cys.spring.chapter07.F1@2d710f1a
com.cys.spring.chapter07.F1@2d710f1a

而我们期望的是多例，不同对象。

那是因为E是单例的，单例对象的依赖注入只会执行一次，因此E的f1属性总是第一次依赖注入的对象。

问题就是单例对象注入多例对象时，多例注入失效，注入的是同一个对象。

那么如何解决呢？

失效解决

使用@Lazy 进行代理生成对象

@Lazy 是一个Spring框架中的注解，用于实现延迟加载（懒加载）的Bean。当我们在Spring配置中标记一个Bean为@Lazy时，这个Bean的初始化会被推迟到第一次使用时才进行，而不是在容器启动时立即进行。

这个注解通常与@Component、@Service、@Repository等注解一起使用，来标记类为Spring容器管理的Bean。当这些类被标记为@Lazy时，它们的实例化会在第一次被注入或使用时才进行，而不是在容器启动时。

此外，@Lazy注解还可以用于方法上，特别是与@Bean注解一起使用时。当方法上标记了@Lazy，该方法返回的Bean对象会在第一次使用时才进行初始化。

修改E如下：

package com.cys.spring.chapter07;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Component;


@Component
public class E {

    @Lazy
    @Autowired
    private F1 f1;

    public F1 getF1() {
        return f1;
    }

}

再次运行结果如下：

com.cys.spring.chapter07.F1@53f3bdbd
com.cys.spring.chapter07.F1@7d61eb55

指定Scope的proxyMode属性

proxyMode 属性是 Spring 框架中 @Scope 注解的一个属性，它用于配置当前类的代理模式。这个属性主要用于非 Singleton 作用域的 Bean。因为在非 Singleton 作用域中，Spring 并不会立即创建 Bean 的实例，而是根据需要才创建。当需要注入时就产生一个代理对象，这时 proxyMode 属性就起作用了。

proxyMode 属性有几个可选值：

  1. DEFAULT（或 NO）：这是默认值，表示不使用代理。如果需要 Bean 的实例，Spring 会立即创建它。
  2. INTERFACES：表示使用 JDK 提供的动态代理来实现代理。这通常适用于 Bean 实现了至少一个接口的情况。
  3. TARGET_CLASS：表示使用 CGLib 库来实现动态代理。这通常适用于 Bean 没有实现任何接口的情况。

使用 proxyMode 属性可以在不改变原有代码结构的情况下，通过声明开启作用域代理来实现一些高级功能，比如在单例 Bean 中使用多实例 Bean。

需要注意的是，proxyMode 属性的设置应该根据具体的业务需求和 Bean 的特点来选择。同时，还需要注意代理模式可能对性能产生的影响，因此在选择代理模式时需要权衡利弊。

这里我们指定Scope的proxyMode属性为ScopedProxyMode.TARGET_CLASS，

新建F2如下：

package com.cys.spring.chapter07;

import org.springframework.context.annotation.Scope;
import org.springframework.context.annotation.ScopedProxyMode;
import org.springframework.stereotype.Component;


@Component
@Scope(value = "prototype", proxyMode = ScopedProxyMode.TARGET_CLASS)
public class F2 {
}

修改E

package com.cys.spring.chapter07;

import org.springframework.beans.factory.ObjectFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Component;


@Component
public class E {

    @Lazy
    @Autowired
    private F1 f1;

    @Autowired
    private F2 f2;


    public F1 getF1() {
        return f1;
    }

    public F2 getF2() {
        return f2;
    }

}

测试类：

package com.cys.spring.chapter07;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.ComponentScan;

@ComponentScan("com.cys.spring.chapter07")
public class TestScope {

    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(TestScope.class);
        E e = context.getBean(E.class);

        // 打印两次观察两个F1是否是同一个
//        System.out.println(e.getF1().getClass());
//        System.out.println(e.getF1());
//        System.out.println(e.getF1());

        System.out.println(e.getF2().getClass());
        System.out.println(e.getF2());
        System.out.println(e.getF2());

        context.close();

    }
}

运行结果如下：

class com.cys.spring.chapter07.F2$$EnhancerBySpringCGLIB$$cedb4f5a
com.cys.spring.chapter07.F2@5170bcf4
com.cys.spring.chapter07.F2@2812b107

使用工厂来创建

如下，创建一个F3，指定多例，在E中代码如下：

package com.cys.spring.chapter07;

import org.springframework.beans.factory.ObjectFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Component;


@Component
public class E {

    @Lazy
    @Autowired
    private F1 f1;

    @Autowired
    private F2 f2;

    @Autowired
    private ObjectFactory<F3> f3;

    public F1 getF1() {
        return f1;
    }

    public F2 getF2() {
        return f2;
    }

    public F3 getF3() {
        return f3.getObject();
    }

}

测试类

package com.cys.spring.chapter07;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.ComponentScan;


@ComponentScan("com.cys.spring.chapter07")
public class TestScope {

    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(TestScope.class);
        E e = context.getBean(E.class);

        System.out.println(e.getF3().getClass());
        System.out.println(e.getF3());
        System.out.println(e.getF3());

        context.close();
    }
}

运行结果如下：

class com.cys.spring.chapter07.F3
com.cys.spring.chapter07.F3@6304101a
com.cys.spring.chapter07.F3@2812b107

直接使用容器中获取

将容器注入到E，在E中直接从容器中获取

修改E如下：

package com.cys.spring.chapter07;

import org.springframework.beans.factory.ObjectFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Component;

@Component
public class E {

    @Lazy
    @Autowired
    private F1 f1;

    @Autowired
    private F2 f2;

    @Autowired
    private ObjectFactory<F3> f3;

    @Autowired
    private ApplicationContext applicationContext;

    public F1 getF1() {
        return f1;
    }

    public F2 getF2() {
        return f2;
    }

    public F3 getF3() {
        return f3.getObject();
    }

    public F4 getF4() {
        return applicationContext.getBean(F4.class);
    }

}

将applicationContext注入到E中，然后通过applicationContext获取F4的对象。

Ethan-running
关注
  • 24
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
SPRING FRAMEWORK BEAN作用域和生命周期原理解析
08-25
主要介绍了SPRING FRAMEWORK BEAN作用域和生命周期原理解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
spring bean 的作用域（scope）
04-22
spring bean 的作用域（scope）， SPringle bean的作用域
Spring实战之Bean的作用域request用法分析
08-25
主要介绍了Spring实战之Bean的作用域request用法,结合实例形式分析了spring中Bean的request作用域相关使用技巧与操作注意事项,需要的朋友可以参考下
JSP 中Spring Bean 的作用域详解
01-08
JSP 中Spring Bean 的作用域详解 Bean元素有一个scope属性，用于定义Bean的作用域，该属性有如下五个值： 1>singleton： 单例模式，在整个spring IOC容器中，单例模式作用域的Bean都将只生成一个实例。一般Spring容器默认Bean的作用域为singleton 2>prototype： 与singleton相反， 每次通过容器的getBean()方法获取该作用域下的Bean时都将产生一个新的Bean实例 3>request： 对于同一次Http请求，request作用域下的Bean都将只生成一个实例。这种作用域只有在Web应用中使用Spring容
【spring】Bean的Scope与自定义Scope
morris
03-14 3276
Bean的作用域 在Spring中，那些组成应用程序的主体及由Spring IoC容器所管理的对象，被称之为Bean。简单地讲，bean就是由IoC容器初始化、装配及管理的对象，除此之外，bean就与应用程序中的其他对象没有什么区别了。而bean的定义以及bean相互间的依赖关系将通过配置元数据来描述。 Bean的五种作用域 在Spring中，那些组成应用程序的主体及由Spring IoC容器所管理的对象，被称之为Bean。简单地讲，bean就是由IoC容器初始化、装配及管理的对象，除此之外，bean就与应
Spring框架Bean作用域
Wanna的博客
08-12 611
Spring框架现有的Bean作用域 （ 1 ） singleton ：默认的作用域，仅为每个 Bean 对象创建一个实例。 （ 2 ） prototype ：可以根据需要为每个 Bean 对象创建多个实例。 （ 3 ） request ：为每个 HTTP 请求创建它自有的一个 Bean 实例，仅在 Web 相关的 ApplicationContext 中生效。 （ 4 ）
Spring-bean的作用域
Lin_XXiang的博客
12-21 300
1、单例模式（Spring默认机制） scope="singleton" 单线程使用 <bean id="user3" class="lin.pojo.User" scope="singleton"> <property name="name" value="XX林"/> <property name="age" value="18"/> </bean> @Test public...
Spring5 07 Bean作用域和自动装配
小哞^同^学的技术博客
07-06 67
：让其 是单例，即唯一的 对象。：原型模式，即 非单例模式。不唯一！ 这样的话，每次 getBean 的时候，都会 自动再生成 一个新的对象。以下的作用，必须再 MVC 框架里，WEB 开发中 才能使用。：该对象在一次请求中创建，当请求完之后，该对象就会自动销毁，即失效！：该对象 存储在 session 里面，并且只要 session 不消失，或手动销毁。对象 就不会消失。：该对象 存储在 整个 WEB 项目 application 容器中，并且 整个项目不 停止运行，或手动销毁。那么 就 不会消失。这里要
Spring Bean作用域，设计模式，通知类型+Spring注解种类
weixin_56638151的博客
11-08 183
目录 2.1 Spring的两大核心是什么?谈一谈你对IOC的理解? 谈一谈你对DI的理解?谈一谈你对 AOP 的理解?(必会) 2.2 Spring 的生命周期?(高薪常问) 2.3 Spring 支持 bean 的作用域有几种吗? 每种作用域是什么样的?(必会) 2.5 Spring 框架中都用到了哪些设计模式?(必会) 2.6 你知道的 Spring 的通知类型有哪些,分别在什么时候执行?(了解) 2.1 Spring的两大核心是什么?谈一谈你对IOC的理解? 谈一谈你对DI的理解?
简单了解spring bean作用域属性singleton和prototype的区别
08-25
主要介绍了简单了解spring bean作用域属性singleton和prototype的区别,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Spring bean的作用域之间的区别
just love code
06-05 849
spring容器中的bean可以分为5个范围（默认单例模式）： scope=singlton：单例模式，对象在容器中全局唯一，在IOC容器初始化的时候该对象就会被创建 scope=prototype：多例模式，在每一次调用getBean的时候IOC容器才会创建该对象的实体，并且每次创建都是不同的对象 request：在请求bean范围内会会对每一个来自客户端的网络请求创建一个实例，在请求完成...
Spring Bean作用域
m0_46550105的博客
04-13 162
@Single 单例的 在Spring容器创建一个组件的时候，默认情况下只会创建一次，不同的组件公用一个对象，即单例的模式。 代码一 public interface Dao { void query(); } 代码二 @Component public class daoImpl implements Dao { public void query() { Sy...
从自定义一个作用域开始来了解SpringBean的作用域
欢迎关注公众号“雨林寻北”，添加个人微信codetrend（备注技术）。
05-01 894
Spring6提供了多种Bean作用域。本文从作用域demo、自定义设计作用域到作用域Spring实现来全方位了解作用域。以及说明了单例bean里面注入了原型bean这种bug级操作怎么解决。
Spring之Scope以及失效的场景
z318913的博客
10-07 375
spring的scope和单例注入其他失效场景以及解决方法
Spring AI 抢先体验，5 分钟玩转 Java AI 应用开发
阿里巴巴云原生的博客
04-29 1045
Spring Cloud Alibaba AI 以 Spring AI 为基础，并在此基础上提供阿里云通义系列大模型全面适配，让用户在 5 分钟内开发基于通义大模型的 Java AI 应用。
springboot集成-mybatis-puls
csy08845的博客
04-29 308
Spring Boot中集成MyBatis Plus是一个相对简单的过程，MyBatis Plus是一个MyBatis的增强工具，它简化了CRUD操作，并且提供了一些额外的功能，比如性能优化、自动填充等。3.配置MyBatis Plus：通常，MyBatis Plus的配置与MyBatis类似，不需要额外的配置，因为它会自动配置。6.使用Mapper：在你的Service中注入Mapper，并使用它。7.配置扫描：确保Spring Boot扫描到你的Mapper接口。
SpringBoot中实现发送邮件
hac1322的博客
04-30 738
当你添加了spring-boot-starter-mail依赖后，Spring Boot会自动配置JavaMailSender实例，并根据application.yml文件中的属性来配置这个实例。你可以直接在需要发送邮件的地方通过@Autowired注解将JavaMailSender实例注入到你的类中，然后使用它来发送邮件。：首先，需要在你的pom.xml文件中添加Spring Boot的邮件发送器依赖。，简化了在Spring Boot应用程序中发送电子邮件的设置过程。Spring Boot的。
SpringBoot之@Conditional注解实现选择性的创建Bean操作
最新发布
qq_52822387的博客
05-01 423
Condition 是在Spring 4.0增加的条件判断功能，通过这个功能可以实现选择性的创建Bean操作。需求：在Spring的IOC容器中有一个User的Bean，现要求：导入Jedis坐标后，加载该Bean，没导入，则不加载。2、创建ClassCondition类实现Condition接口，重写matches方法。参数context：上下文对象，用于获取环境、IOC容器、ClassLoader对象。我们在代码中加入一个@Conditional注解，查看这个注解。3、获取user，打印出来。
spring中bean作用域
05-13
在 Spring 中，Bean 的作用域指的是 Bean 实例的生命周期及其可见范围。Spring Framework 提供了以下五种 Bean 的作用域： 1. singleton：单例模式，一个 Bean 容器中只存在一个实例，所有引用都指向同一个对象。 2. prototype：原型模式，每次请求都会创建一个新的实例。 3. request：Web 应用中，每个请求都会创建一个新的实例，仅在当前请求内有效。 4. session：Web 应用中，每个会话都会创建一个新的实例，仅在当前会话内有效。 5. global session：仅适用于 Portlet 环境，全局会话作用域，可以跨多个 Portlet 应用共享一个 Bean 实例。 一般情况下，大部分的 Bean 都可以使用 singleton 作用域，但是对于一些需要频繁创建和销毁的 Bean，比如线程池、数据库连接等，应该使用 prototype 作用域。对于 Web 应用中的 Bean，可以根据其生命周期选择 request 和 session 作用域。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Ethan-running

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值