Bean配置文件之scope元素

最新推荐文章于 2024-07-15 15:14:58 发布
最新推荐文章于 2024-07-15 15:14:58 发布
阅读量106 收藏
点赞数
分类专栏： Spring 文章标签： spring ioc java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44781206/article/details/121785777
版权

前言：

  • Spring容器在创建bean对象时，一般默认创建的都是单例对象，在整个容器中仅仅只存在一个该类型的bean对象
  • 若有需求是要求每次调用的bean对象都是不同的bean对象，则需要配置作用域为prototype
  • 在Spring Web容器中，作用域则有request、session、application三种类型
  • 有时候，Spring容器内置的作用域并不能满足我们的需求，则可以通过自定义作用域来扩展

案例源码：码云仓库的base-004

1、Scope属性

  • 基本格式：

    <bean id="bean名称" class="完整类路径" scope="作用域" />
    • scope值：有singleton、prototype、request、session、application等，默认值为singleton。而request、session、application三者皆在Spring Web容器中才存在

2、作用域singleton

  • 基本格式：

    <bean id="bean名称" class="完整类路径" scope="singleton" />

  • scope值为singleton时，Spring容器创建的bean对象为单例对象，在该容器仅且只存在一个该类型的bean对象

  • Spring容器在启动时，会自动创建好单例对象，放在容器中，以供使用。注意：若bean元素的lazy值为true时，即懒加载，bean对象的创建则是在被使用时才创建，与作用域值为prototype时相同

  • 案例

    • 实体类

      package com.spring.study;

public class BeanScope {
    /**
     * bean对象的作用域的值，用于打印Spring容器创建bean对象的方式--单例 or 多例
     */
    private String beanScope;

    public String getBeanScope() {
        return beanScope;
    }

    public void setBeanScope(String beanScope) {
        this.beanScope = beanScope;
    }

    public BeanScope(String beanScope) {
        this.beanScope = beanScope;
        System.out.println(String.format("正在创建bean对象{作用域=%s,内存地址=%s}",beanScope,this));
    }
}

    • 配置文件

      <?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值为singleton-->
    <bean id="beanScope1" class="com.spring.study.BeanScope" scope="singleton">
        <constructor-arg index="0" value="singleton" />
    </bean>

</beans>

    • 测试类

      package com.spring.test;

import org.junit.BeforeClass;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestSingleton {
    /**
     * ClassPathXmlApplicationContext容器
     */
    static ClassPathXmlApplicationContext context;

    /**
     * junit提供--@BeforeClass：初始化方法，在所有的方法被调用之前仅且只执行一次
     * 构建Spring容器，初始化bean对象
     */
    @BeforeClass
    public  static void createBean(){
        System.out.println("Spring容器准备启动......");

        // 1、定义bean配置文件
        String classPathXml = "classpath:applicationContext.xml";

        // 2、创建ClassPathXmlApplicationContext容器，加载配置文件
        context = new ClassPathXmlApplicationContext(classPathXml);

        System.out.println("Spring容器启动完毕！！！");
    }

    /**
     * junit提供--@Test:测试方法
     * 用于测试
     */
    @Test
    public void printResult(){

        // 3、获取所有bean对象的bean名称
        String[] beanNames = context.getBeanDefinitionNames();

        // 4、多次获取bean对象，并打印输出bean对象的内存地址，来确认调用的是否是同一个对象
        for (String beanName : beanNames){
            for (int i = 1; i <= 2; i++){
                System.out.println(String.format("第%d次调用%s对象，其内存地址:%s",i,beanName,context.getBean(beanName)));
            }
        }

    }

}

    • 运行结果

      Spring容器准备启动......
正在创建bean对象{作用域=singleton,内存地址=com.spring.study.BeanScope@29b5cd00}
Spring容器启动完毕！！！
第1次调用beanScope1对象，其内存地址:com.spring.study.BeanScope@29b5cd00
第2次调用beanScope1对象，其内存地址:com.spring.study.BeanScope@29b5cd00
      • 从打印结果来看，单例对象的初始化，是在Spring容器启动阶段完成的。多次调用的该类型对象，都是同一个对象

3、作用域prototype

  • 基本格式：

    <bean id="bean名称" class="完整类路径" scope="prototype" />

  • scope值为prototype时，Spring容器创建的bean对象为多例对象，每次从容器获得的该类型对象都是不同的，因为容器每次都会重新创建该类型的对象

  • 案例

    • 实体类同上例的BeanScope类

    • 配置文件

      <?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值为prototype-->
    <bean id="beanScope2" class="com.spring.study.BeanScope" scope="prototype">
        <constructor-arg index="0" value="prototype"/>
    </bean>
</beans>

    • 测试类同上例的TestSingleton类

    • 运行结果

      Spring容器准备启动......
Spring容器启动完毕！！！
正在创建bean对象{作用域=prototype,内存地址=com.spring.study.BeanScope@64485a47}
第1次调用beanScope2对象，其内存地址:com.spring.study.BeanScope@64485a47
正在创建bean对象{作用域=prototype,内存地址=com.spring.study.BeanScope@25bbf683}
第2次调用beanScope2对象，其内存地址:com.spring.study.BeanScope@25bbf683
      • 从运行结果来看，多例对象的初始化，是在被调用时才创建的。且每次都会重新创建新的对象

4、作用域request、session、application

  • request

    • 基本格式：

      <bean id="bean名称" class="完整类路径" scope="request" />

    • 存在环境：Spring容器的web环境

    • 当scope值为request时，该容器会针对每一次HTTP请求都会产生一个新的bean，同时该bean仅在当前HTTP request内有效

  • session

    • 基本格式：

      <bean id="bean名称" class="完整类路径" scope="session" />

    • 存在环境：Spring容器的web环境

    • 当scope值为session时，每个会话会对应一个bean实例，不同的session对应不同的bean实例

  • application

    • 基本格式：

      <bean id="bean名称" class="完整类路径" scope="application" />

    • 存在环境：Spring容器的web环境

    • 当scope值为application时，一个web应用程序对应一个bean实例，通常情况下和singleton效果类似的。但是也有区别：singleton是每个Spring容器中只有一个bean实例，不同的Spring容器中可以有同名的bean对象；而application是所有的Spring容器中仅且只有一个bean对象，不可以存在其它同名的bean对象

5、自定义作用域

  • 若内置的作用域不能满足需求的时候，可以自定义作用域

  • 实现步骤：

    • 第一步：实现org.springframework.beans.factory.config.Scope 接口，以此来自定义作用域

      package org.springframework.beans.factory.config;

import org.springframework.beans.factory.ObjectFactory;
import org.springframework.lang.Nullable;

public interface Scope {
    
    /**
    * 返回当前作用域中name对应的bean对象
    * name：需要检索的bean名称
    * objectFactory：如果name对应的bean对象在当前作用域中没有找到，那么可以调用这个ObjectFactory来创建这个对象
    **/
    Object get(String name, ObjectFactory<?> objectFactory);
    
    /**
     * 将name对应的bean对象从当前作用域中移除
     **/
    @Nullable
    Object remove(String name);
    
    /**
     * 用于注册销毁回调，如果想要销毁相应的对象,则由Spring容器注册相应的销毁回调，而由自定义作用域选择是不是要销毁相应的对象
     */
    void registerDestructionCallback(String name, Runnable callback);
    
    /**
     * 用于解析相应的上下文数据，比如request作用域将返回request中的属性。
     */
    @Nullable
    Object resolveContextualObject(String key);
    
    /**
     * 作用域的会话标识，比如session作用域将是sessionId
     */
    @Nullable
    String getConversationId();
}

    • 第二步：将自定义作用域注册到容器中，需要用到org.springframework.beans.factory.config.ConfigurableBeanFactory的registerScope方法

      /**
* 向容器中注册自定义的Scope
* scopeName：作用域名称
* scope：作用域对象
*/
void registerScope(String scopeName, Scope scope);

    • 第三步：在配置文件中，指定bean元素的scope值为第二步注册到容器的自定义作用域名称scopeName

      <bean id="bean名称" class="完整类路径" scope="自定义作用域名称"/>

  • 自定义作用域的关键在于Scope接口的get方法中是如何处理返回bean对象的

  • 案例

    • 需求：采用多线程来访问容器中的bean对象，实现不同线程的bean对象是不同的对象，相同线程的bean对象是相同的对象。并与singleton作对比

    • 实体类为BeanScope类

    • 自定义作用域类

      package com.spring.study;

import org.springframework.beans.factory.ObjectFactory;
import org.springframework.beans.factory.config.Scope;

import java.util.HashMap;
import java.util.Map;

public class ThreadScope implements Scope {

    /**
     *  自定义作用域Scope名称常量
     */
    public static final String THREAD_SCOPE = "thread_scope";

    /**
     * 初始化线程局部变量
     */
    private final ThreadLocal<Map<String,Object>> threadLocal = new ThreadLocal(){
        @Override
        protected Object initialValue() {
            System.out.println("正在初始化线程局部变量ThreadLocal......");
            return new HashMap<>();
        }
    };

    /**
     * 返回当前作用域中name对应的bean对象
     * @param name
     * @param objectFactory
     * @return
     */
    @Override
    public Object get(String name, ObjectFactory<?> objectFactory) {
        System.out.println(String.format("正在获取该作用域中的%s对象......",name));

        Object bean = threadLocal.get().get(name);
        if (bean == null){
            System.out.println(String.format("%s对象不存在，正在创建中......",name));
            bean = objectFactory.getObject();
            threadLocal.get().put(name,bean);
            System.out.println(String.format("%s对象创建完毕！！！",name));
        }

        System.out.println(String.format("已获取到%s对象，over!!!",name));
        return bean;
    }

    @Override
    public Object remove(String name) {
        return null;
    }

    @Override
    public void registerDestructionCallback(String name, Runnable callback) {

    }

    @Override
    public Object resolveContextualObject(String key) {
        return null;
    }

    @Override
    public String getConversationId() {
        return null;
    }
}

    • 测试类（在测试类中将自定义作用域注册到Spring容器中）

      package com.spring.test;

import com.spring.study.ThreadScope;
import org.junit.Before;
import org.junit.Test;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.util.concurrent.TimeUnit;

public class TestThreadScope {

    /**
     * ClassPathXmlApplicationContext容器
     */
    ClassPathXmlApplicationContext context;
	
    /**
     * 在测试方法之前执行此方法
     */
    @Before
    public void registerThreadScope(){
        
        System.out.println("Spring容器准备启动......");

        // 1、设置配置文件的位置
        String classPathXml = "classpath:applicationContext.xml";

        // 2、手动创建容器
        context = new ClassPathXmlApplicationContext(){
            // 向容器中注册自定义的作用域
            @Override
            public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
                beanFactory.registerScope(ThreadScope.THREAD_SCOPE,new ThreadScope());
                super.postProcessBeanFactory(beanFactory);
            }
        };

        // 3、设置配置文件位置
        context.setConfigLocation(classPathXml);

        // 4、启动容器
        context.refresh();
        
        System.out.println("Spring容器启动完毕！！！");
    }
	
    /**
     * 测试方法
     * @throws InterruptedException
     */
    @Test
    public void ThreadScopeTest() throws InterruptedException {
        
        // 获取容器中所有的bean对象的bean名称
        String[] beanNames = context.getBeanDefinitionNames();

        for (String beanName : beanNames) {
            for (int i = 0; i < 2; i++) {
                new Thread(() -> {
                    for (int j = 1; j <= 2; j++) {
                        System.out.println(String.format("当前线程:%s，第%d次获取%s对象，内存地址:%s", Thread.currentThread(), j, beanName,context.getBean(beanName)));
                    }
                }).start();
				//间隔1秒
                TimeUnit.SECONDS.sleep(1);
            }
        }

    }
}

    • 配置文件

      <?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值为singleton-->
    <bean id="beanScope1" class="com.spring.study.BeanScope" scope="singleton">
        <constructor-arg index="0" value="singleton" />
    </bean>
	
    <!--    自定义作用域-->
    <bean id="threadScope" class="com.spring.study.BeanScope" scope="thread_scope">
        <constructor-arg index="0" value="thread_scope"/>
    </bean>
</beans>

    • 运行结果

      Spring容器准备启动......
正在创建bean对象{作用域=singleton,内存地址=com.spring.study.BeanScope@5f3a4b84}
Spring容器启动完毕！！！
当前线程:Thread[Thread-1,5,main]，第1次获取beanScope1对象，内存地址:com.spring.study.BeanScope@5f3a4b84
当前线程:Thread[Thread-1,5,main]，第2次获取beanScope1对象，内存地址:com.spring.study.BeanScope@5f3a4b84
当前线程:Thread[Thread-2,5,main]，第1次获取beanScope1对象，内存地址:com.spring.study.BeanScope@5f3a4b84
当前线程:Thread[Thread-2,5,main]，第2次获取beanScope1对象，内存地址:com.spring.study.BeanScope@5f3a4b84
正在获取该作用域中的threadScope对象......
正在初始化线程局部变量ThreadLocal......
threadScope对象不存在，正在创建中......
正在创建bean对象{作用域=thread_scope,内存地址=com.spring.study.BeanScope@43b3a2ba}
threadScope对象创建完毕！！！
已获取到threadScope对象，over!!!
当前线程:Thread[Thread-3,5,main]，第1次获取threadScope对象，内存地址:com.spring.study.BeanScope@43b3a2ba
正在获取该作用域中的threadScope对象......
已获取到threadScope对象，over!!!
当前线程:Thread[Thread-3,5,main]，第2次获取threadScope对象，内存地址:com.spring.study.BeanScope@43b3a2ba
正在获取该作用域中的threadScope对象......
正在初始化线程局部变量ThreadLocal......
threadScope对象不存在，正在创建中......
正在创建bean对象{作用域=thread_scope,内存地址=com.spring.study.BeanScope@2432e026}
threadScope对象创建完毕！！！
已获取到threadScope对象，over!!!
当前线程:Thread[Thread-4,5,main]，第1次获取threadScope对象，内存地址:com.spring.study.BeanScope@2432e026
正在获取该作用域中的threadScope对象......
已获取到threadScope对象，over!!!
当前线程:Thread[Thread-4,5,main]，第2次获取threadScope对象，内存地址:com.spring.study.BeanScope@2432e026
      • 从运行结果来看
        • 自定义的作用域与singleton作用域的相同点：在同一个线程中，两者从容器中多次获取的同一个bean对象都是同一个对象
        • 自定义的作用域与singleton作用域的不同点：在不同线程中，自定义作用域从容器中多次获取的同一个bean对象是不同的对象，而singleton作用域从容器中多次获取的同一个bean对象始终是是同一个对象

参考：Java充电社、笑得好虚伪

小小的阿遥
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
配置bean之scope
@siye
09-08 194
springioc-bean-scope
bean元素scope属性配置Bean的作用域
叶月伊人
01-05 3928
为什么spring中配置bean是不允许用singleton属性？ 版本问题，应该是属性scope=“singleton”或者scope=“prototype” spring新版本中取消了singleton="true/false"的设置，增加了更多选择行。 bean元素scope属性配置Bean的作用域 元素scope属性,在spring规范中scope属性有五个取值: 1. sc
Spring配置文件的bean元素，scope属性值说明
lchina1314的专栏
04-08 179
Spring 配置文件的bean元素，scope属性值说明： 1、singleton，单例。 2、prototype，表示每次从容器中取出bean时，都会生出一个新实例，相当于一个new出来一个对象。 3、request，该属性是基于web的，表示每次接受一个请求时，都会生出一个新实例，在这种情况下，request与prototype一样。 4、session，表示在每个sessi...
SpringBoot两种配置文件和三种Bean配置方式
weixin_46529416的博客
01-05 3705
SpringBoot两种配置文件 application.properties, application.yml application.properties 配置： spring.profiles.active=dev spring.datasource.data-username=root spring.datasource.data-password=root application.yml 配置 spring: profiles:
Spring bean中的scope属性
weixin_45491031的博客
02-26 1981
1，scope属性说明 在spring中，在xml中定义bean时，scope属性是用来声明bean的作用域的。对于这个属性，你也许已经很熟悉了，singleton和prototype信手捏来，甚至还能说出request、session、global session，scope不就只有这么几个值吗。 singleton singleton是scope属性的默认值，当我们把bean的scope属性...
Spring基于xml文件配置Bean过程详解
08-25
Bean的配置文件是Spring框架的核心组件之一，它定义了Bean的创建过程，包括Bean的类名、属性、构造器参数、依赖关系等信息。在xml文件中，我们可以使用<bean>元素来定义一个Bean，该元素有多个属性，例如id、class...
Spring如何在xml文件中配置Bean
08-25
Spring容器支持两种格式的配置文件：xml文件和properties文件，其中xml文件是最常用的配置文件格式。在xml文件中，Bean的配置主要通过根元素和<bean>元素来实现。 Bean的配置 在xml文件中，<bean>元素是配置Bean的...
Spring装配Bean教程之XML安装配置bean详解
08-29
此外，XML配置还支持许多其他特性，如`init-method`和`destroy-method`用于指定Bean的初始化和销毁方法，`scope`属性用于设置Bean的作用域（如单例、原型等），以及`<import>`元素用于导入其他配置文件。 虽然现代...
pring配置文件共5页.pdf.zip
10-30
Bean定义是Spring配置文件的核心元素，它包括bean的ID、类名、属性值、依赖关系等信息。例如： ```xml <bean id="exampleBean" class="com.example.ExampleClass"> </bean> ``` 这里的`id`属性为bean提供了唯一...
dwr配置文件详解
08-09
`<dwr>`是配置文件的根元素，包含了所有其他配置元素。 3. **init元素**： `<init>`部分用于定义`creator`和`converter`。`creator`是用来创建服务器端对象的，例如Spring Bean，而`converter`则负责将Java对象...
Spring源码(三) Spring IoC之BeanFactory创建bean和获取bean
一生编程，快乐编程
07-11 951
bean 对象主要放在 map 里面，map 作为缓存。map 的key 是 bean对象的名称， value 是 bean 对象或者对象工厂。代码详情见： https://blog.csdn.net/sinat_32502451/article/details/140155044。详情见： https://blog.csdn.net/sinat_32502451/article/details/140247662。根据 bean 名称，返回已经注册的单例对象，如果没有注册，则创建并注册一个新对象。
springmvc1
benpaodeDD的博客
07-14 160
以前的servlet程序：
springboot start.aliyun.com java8
最新发布
JavaUpgrade
07-15 51
springboot 2.3.12.RELEASE alibaba cloud RDS alibaba cloud Redis alibaba cloud oss alibaba cloud sms alibaba cloud schedulerX spring cloud alibaba
Spring常见的自定义和扩展的方法
Casual_Lei的博客
07-12 232
通过类和@Bean方法，自定义Bean的创建过程。@Bean使用Spring AOP（Aspect-Oriented Programming）自定义注解和拦截方法调用。通过实现接口，在Bean的初始化前后添加自定义逻辑。@Component@Override@Override通过实现接口，可以在Bean定义加载后但在Bean实例化前修改Bean定义。@Component@Override通过实现接口，监听Spring应用上下文事件。
5.SpringBoot核心源码-启动类源码分析
流月up的博客
07-12 400
SpringBoot核心源码-启动类源码分析
六、 SpringBoot 配置⽂件 ★ ✔【value的引号注意事项、@ConfigurationProperties 、】
蓝天it（让亿万孩子在蓝天下共享优质教育）
07-12 966
Kaptcha 是Google的⼀个⾼度可配置的实⽤验证码⽣成⼯具. 代码:⽹上有很多⼈甚⾄公司基于Google的kaptcha进⾏了⼆次开发. 我们选择⼀个直接适配SpringBoot的开源项⽬由于作者的⽂档写的不是很全, 下⾯简单介绍下插件的使⽤原理验证码可以客⼾端⽣成, 也可以服务器⽣成. 对于普通的字符验证码, 后端通常分两部分.⼀是⽣成验证码内容, 根据验证码内容和⼲扰项等, ⽣成图⽚, 返回给客⼾端。
解决springboot整合jpa启动类报错：Not a managed type: class com.example.entity.Xxx
DN金猿的博客
07-15 43
【代码】解决springboot整合jpa启动类报错：Not a managed type: class com.example.entity.Xxx。
玩转springboot之springboot集成redis乱码问题
Lxn2zh的博客
07-15 124
在使用redis操作字符串时发现会变成乱码，这是因为RedisTemplate默认是使用的是JdkSerializationRedisSerializer序列化方式，这里可以使用StringRedisTemplate来进行操作，StringRedisTemplate中默认使用的是StringRedisSerializer。也可以对RedisTemplate进行配置，设置其序列化方式。springboot集成redis乱码问题。
基于SpringBoot+MySQL的租房项目+文档
欧阳小白闯天涯
07-11 941
在当今快节奏的生活中，房屋租赁市场的需求与日俱增。为了有效管理租房流程、提升用户体验，本文基于SpringBoot+MySQL技术栈，设计并实现了一套全方位的租房系统。该系统融合了经纪人、维修员、管理员和用户四个角色，各自拥有独特的功能模块，包括房源管理、维修处理、员工用户管理、统计分析等。经纪人角色能够方便地添加房源、管理自己的房源、处理房源出租事务，并通过系统提供的月出租量统计功能进行业绩分析与优化。其次，维修员可以及时响应待处理的房源报修请求，有效地管理已处理的房源维修记录。
在Spring配置文件中<bean>元素的bean的作用域scope属性的默认取值为singleton.
06-08
在Spring配置文件中，如果没有为`<bean>`元素的scope属性显式指定取值，那么其默认值就是`singleton`。这意味着在整个应用程序的生命周期中，只会创建一个Bean实例，所有对该Bean的请求都将返回同一个实例。如果需要...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值