精华内容
下载资源
问答
  • spring创建对象的作用域
    2022-03-23 12:51:56

    1.1 Bean的作用域
      Spring 3中为Bean定义了5中作用域,分别为singleton(单例)、prototype(原型)、request、session和global session,5种作用域说明如下:

    singleton:单例模式,Spring IoC容器中只会存在一个共享的Bean实例,无论有多少个Bean引用它,始终指向同一对象。Singleton作用域是Spring中的缺省作用域,也可以显示的将Bean定义为singleton模式,配置为:

    prototype:原型模式,每次通过Spring容器获取prototype定义的bean时,容器都将创建一个新的Bean实例,每个Bean实例都有自己的属性和状态,而singleton全局只有一个对象。根据经验,对有状态的bean使用prototype作用域,而对无状态的bean使用singleton作用域。
    request:在一次Http请求中,容器会返回该Bean的同一实例。而对不同的Http请求则会产生新的Bean,而且该bean仅在当前Http Request内有效。
    ,针对每一次Http请求,Spring容器根据该bean的定义创建一个全新的实例,且该实例仅在当前Http请求内有效,而其它请求无法看到当前请求中状态的变化,当当前Http请求结束,该bean实例也将会被销毁。
    session:在一次Http Session中,容器会返回该Bean的同一实例。而对不同的Session请求则会创建新的实例,该bean实例仅在当前Session内有效。
    ,同Http请求相同,每一次session请求创建新的实例,而不同的实例之间不共享属性,且实例仅在自己的session请求内有效,请求结束,则实例将被销毁。
    global Session:在一个全局的Http Session中,容器会返回该Bean的同一个实例,仅在使用portlet context时有效。

    更多相关内容
  • Spring 对象作用域

    千次阅读 2017-05-21 20:28:12
    默认情况下, Spring创建对象放在它的容器中缓存,当我们需要某个对象时,Spring 将缓存的对象返回给我们,并不会创建对象,如果你想让 Spring 每次返回一个新对象该怎么办呢?看看下面的例子吧。package ...

    – Start
    点击此处观看本系列配套视频。


    默认情况下, Spring 将创建的对象放在它的容器中缓存,当我们需要某个对象时,Spring 将缓存的对象返回给我们,并不会创建新对象,如果你想让 Spring 每次返回一个新对象该怎么办呢?看看下面的例子吧。

    package shangbo.spring.core.example7;
    
    public class OutPutService {
    
    	public void outPut() {
    		System.out.println("Hello World");
    	}
    
    }
    
    
    <?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     默认值
    		prototype     每次返回新对象
    		request       Web下可用
    		session       Web下可用
    		globalSession Web下可用
    		application   Web下可用
    		websocket     Web下可用
    	-->
    	<bean class="shangbo.spring.core.example7.OutPutService" scope = "prototype"/>
    
    </beans>
    
    package shangbo.spring.core.example7;
    
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class App {
    	public static void main(String[] args) {
    		// 实例化 Spring IoC 容器
    		ApplicationContext context = new ClassPathXmlApplicationContext("example.xml", OutPutService.class);
    
    		// 从容器中获得 OutPutService 对象
    		OutPutService printer = context.getBean(OutPutService.class);
    
    		// 使用对象
    		printer.outPut();
    	}
    }
    
    

    如果你使用 Java 配置元数据,使用 @Scope 注解即可。

    package shangbo.spring.core.example8;
    
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.context.annotation.Scope;
    
    @Configuration
    public class AppConfig {
    
    	@Bean
    	@Scope(value = "prototype")
    	public OutPutService outPutService() {
    		return new OutPutService();
    	}
    }
    
    

    更多参见:Spring Framework 精萃
    – 声 明:转载请注明出处
    – Last Updated on 2017-06-17
    – Written by ShangBo on 2017-05-21
    – End

    展开全文
  • 主要介绍了浅谈spring中scope作用域,具有一定借鉴价值,需要的朋友可以参考下。
  • Spring Bean的作用域以及注解使用

    千次阅读 多人点赞 2021-02-22 18:00:00
    点击上方 Java学习之道,选择 设为星标每天12点,干货准时奉上!Spring Bean的作用域Spring Bean 的作用域即为对象的作用范围。Spring Bean的作用域由配置项...

    点击上方 Java学习之道,选择 设为星标

    每天12点,干货准时奉上!

    Spring Bean的作用域

    Spring Bean 的作用域即为对象的作用范围。Spring Bean的作用域由配置项 scope 来限定。

    Scope配置项

    作用域限定了 Spring Bean 的作用范围,在 Spring 配置文件定义 Bean 时,通过声明 scope 配置项,可以灵活定义 Bean 的作用范围。

    想要容器创建的 bean 为单例模式,就设置 Scope 为 singleton;想要每次创建的 bean 都是不同的对象则使用 prototype

    六大作用域

    官方文档给出的bean作用域的简单介绍。文档的表格写着是六个作用域,但是很多时候都会被认为只有五个作用域。因为 applicationwebsocket 的作用差不多。所以会被认为是一个。

    范围描述
    singleton(默认)将每个Spring IoC容器的单个 bean 定义范围限定为单个对象实例。
    prototype将单个 bean 定义的作用域限定为任意数量的对象实例。
    request将单个 bean 定义的范围限定为单个 HTTP 请求的生命周期。也就是说,每个 HTTP 请求都有一个自己的 bean 实例,它是在单个 bean 定义的后面创建的。仅在可感知网络的 Spring 上下文中有效 ApplicationContext
    session将单个 bean 定义的范围限定为 HTTP 的生命周期 Session。仅在可感知网络的 Spring 上下文中有效 ApplicationContext
    application将单个 bean 定义的作用域限定为的生命周期 ServletContext。仅在可感知网络的Spring上下文中有效 ApplicationContext
    websocket将单个 bean 定义的作用域限定为的生命周期 WebSocket。仅在可感知网络的Spring上下文中有效 ApplicationContext

    本文重点放在 singleton 和 prototype ,后面四个是对于WebMVC而言的,这里暂不进行详细阐述。

    单例作用域

    先来说说第一个单例范围,单例范围即无论使用多少个 Dao 去获取 bean ,每次获取到的都是一个相同的 bean对象。「singleton」 这与我们所说的单例模式基本是相同的,singleton 也是默认的作用域,如果没用指定 bean 对象的作用域则在整个上下文环境中通过 Spring IOC 获取到的 bean 都是同一个实例。

    配置 bean 为 singleton 作用域代码:

    <bean id="accountService" class="com.something.DefaultAccountService" scope="singleton"/>
    

    接下来定义一个POJO类 -- User来演示 scope 属性对实例的影响。

    public class User {
        private String name;
        private int age;
    
        public User() {
        }
    
        public User(String name, int age) {
            this.name = name;
            this.age = age;
        }
        /*toString和getter/setter*/
        @Override
        public String toString() {
            return "User{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    }
    

    再显示的把该 bean 的作用域设置为 singleton。

    <?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:p="http://www.springframework.org/schema/p"
           xsi:schemaLocation="http://www.springframework.org/schema/beans
            https://www.springframework.org/schema/beans/spring-beans.xsd ">
    
            <bean id="user" class="com.javastudyway.pojo.User" p:name="Java学习之道" p:age="4" scope="singleton"/>
    
    </beans>
    

    最后就是测试类了:

    import com.javastudyway.pojo.Student;
    import com.javastudyway.pojo.User;
    import org.junit.Test;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    public class MyTest {
        @Test
        public void testSingleton(){
            ApplicationContext context = new ClassPathXmlApplicationContext("userbean.xml");
            User user1 = context.getBean("user",User.class);
            User user2 = context.getBean("user",User.class);
            System.out.println(user1 == user2);
        }
    }
    

    测试结果如下:从比较结果可以看出,程序两次从 IOC 容器中获取的 User 实例「地址比较结果相同」,说明 IOC 容器返回的是「同一个实例」

    原型作用域

    与 singleton 刚好相反,prototype,是程序每次从 IOC 容器获取的 Bean 都是一个新的实例。这次把 bean 的配置修改成 「prototype」,再进行测试。

    <bean id="user" class="com.javastudyway.pojo.User" p:name="Java学习之道" p:age="4" scope="prototype"/>
    

    在测试类中增加一个测试方法:

    @Test
    public void testPrototype(){
        ApplicationContext context = new ClassPathXmlApplicationContext("userbean.xml");
        User user1 = context.getBean("user", User.class);
        User user2 = context.getBean("user", User.class);
        System.out.println("两次对象地址比较结果为:" + (user1 == user2));
        System.out.println("user1 的hasCode为:" + user1.hashCode());
        System.out.println("user2 的hasCode为:" + user2.hashCode());
    }
    

    测试结果为:可以看到,程序两次从 IOC 容器中获取的 user1 和 user2 实例的 hashCode 不相同,说明 User 添加 prototype 作用域后,IOC 容器每次返回的都是一个新的实例。

    对于作用域使用场景的总结:

    有状态的bean应该使用prototype作用域;

    对无状态的bean则应该使用singleton作用域。

    使用注解声明bean的作用域

    大多数时候,我们都不想很麻烦的去修改 applicationContext.xml ,因为修改文件总是烦躁得让人抗拒。

    所以我们可以使用注解来配置 bean 的作用范围。具体步骤为

    • 使用 「@Component」 注解将 POJO 类声明为一个 bean;

    • 使用 「@Scope」 注解声明 bean 的作用域;

    • 修改 「applicationContext.xml」 开启扫描 POJO 包中的所有类的注解。

    修改POJO类

    在 POJO 类上增加 @Component,让 Spring 将 User 视为一个 bean。

    在 POJO 类上增加 @Scope 注解,标识 该 bean 的作用域为 singleton。

    package com.javastudyway.pojo;
    
    import org.springframework.context.annotation.Scope;
    import org.springframework.stereotype.Component;
    @Component("user")
    @Scope("singleton")
    public class User {
        private String name;
        private int age;
    
        public User() {
        }
    
        public User(String name, int age) {
            this.name = name;
            this.age = age;
        }
    
        @Override
        public String toString() {
            return "User{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    }
    

    开启注解扫描

    增加完注解后我们只需要对 applicationContext.xml 这个 Spring 的配置文件做上一小部分修改,即可实现注解开发了。

    开启 com.javastudyway.pojo 包中的所有类的注解扫描。

    <?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:context="http://www.springframework.org/schema/context"
           xmlns:p="http://www.springframework.org/schema/p"
           xmlns:c="http://www.springframework.org/schema/c"
           xsi:schemaLocation="http://www.springframework.org/schema/beans
            https://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
    
        <!-- 开启注解扫描 -->
        <context:component-scan base-package="com.javastudyway.pojo"/>
    
    </beans>
    

    测试

    对 POJO 类加上注解和开启注解扫描后,我们就可以通过简单的注解来设置 bean 的作用域而不再需要去配置文件中慢慢修找修改了。用刚刚 测试原型作用域的方法 来测试用注解修改成 singleton 的 bean。

    结果从原来的 「false,hashCode 不相等」变成了 「true,hashCode 相等」了。

    -- END --

     | 更多精彩文章 -


    《Java学习-进阶手册》

    公众号后台回复「手册」获取资料

    ▽加我微信,交个朋友长按/扫码添加↑↑↑
    
    
    
    展开全文
  • Spring Bean 的作用域

    2022-02-17 15:30:00
    Spring中,那些组成...Spring中的bean默认都是单例的,对于Web应用来说,Web容器对于每个用户请求都创建一个单独的Sevlet线程来处理请求,引入Spring框架之后,每个Action都是单例的,那么对于Spring托管的单例Se.

    在Spring中,那些组成应用程序的主体及由Spring IoC容器所管理的对象,被称之为bean。简单地讲,bean就是由IoC容器初始化、装配及管理的对象,除此之外,bean就与应用程序中的其他对象没有什么区别了。而bean的定义以及bean相互间的依赖关系将通过配置元数据来描述。
     

    Spring中的bean默认都是单例的,对于Web应用来说,Web容器对于每个用户请求都创建一个单独的Sevlet线程来处理请求,引入Spring框架之后,每个Action都是单例的,那么对于Spring托管的单例Service Bean,Spring的单例是基于BeanFactory也就是Spring容器的,单例Bean在此容器内只有一个,Java的单例是基于JVM,每个JVM内只有一个实例。
     

    Spring Framework支持五种作用域,分别阐述如下表。

      五种作用域中,request、session和global session三种作用域仅在基于web的应用中使用(不必关心你所采用的是什么web应用框架),只能用在基于web的Spring ApplicationContext环境。

    一、singleton

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

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

    二、prototype

    当一个bean的作用域为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

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

    <bean id="loginAction" class=com.foo.LoginAction" scope="request"/>
    


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

    四、session

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

    <bean id="loginAction" class=com.foo.LoginAction" scope="request"/>
    

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

    五、global session

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

    <bean id="user" class="com.foo.Preferences "scope="globalSession"/>
    

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

    展开全文
  • 文章目录一、概念和历史二、hellospring三、IOC创建对象的方式四、Spring配置五、set注入–属性注入六、c命名和p命名空间注入七 、bean的作用域 一、概念和历史 Spring的形成,最初来自Rod Jahnson所著的一本很有...
  • 7.spring之Bean的作用域

    千次阅读 2019-08-26 10:24:31
    1.Bean的作用域 什么是作用域呢?即“scope”,在面向对象...Spring提供“singleton”和“prototype”两种基本作用域,另外提供“request”、“session”、“global session”三种web作用域Spring还允许用户定制...
  • spring的bean作用域

    2012-11-20 09:01:37
    讲解了spring的6种作用域:singleton(单例)、non-singleton(也称 prototype),Spring2.0以后,增加了session、request、global session三种专用于Web应用程序上下文的Bean
  • Spring中的作用域

    千次阅读 2018-12-09 20:44:05
    如何使用spring作用域: 这里的scope就是用来配置spring bean的作用域,它标识bean的作用域。在spring2.0之前bean只有2种作用域即:singleton(单例)、non-singleton(也称 prototype), Spring2.0以后,增加了...
  • Spring Boot作用域(PROJECT01_DAY02_01)

    千次阅读 2021-08-12 15:16:51
    Spring 框架中,Spring 为由它创建和管理的对象,设计了一些特性,例如作用域, 延迟加载,生命周期方法等,基于这些特性实现对 Bean 对象的管理。 package com.cy.pj.common.cache; @Component @Scope(...
  • 主要介绍了简单了解spring bean作用域属性singleton和prototype的区别,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • Spring中bean的作用域

    千次阅读 2021-08-09 16:42:54
    本篇介绍Spring Bean实例的...作用域限定了Spring Bean的作用范围,在Spring配置文件定义Bean时,通过声明scope配置项,可以灵活定义Bean的作用范围。例如,当你希望每次IOC容器返回的Bean是同一个实例时,可以设置s
  • Spring Bean的作用域.docx

    2022-06-19 20:56:02
    如果bean的作用域的属性被声明为 singleton, 那么Spring Ioc容器只会创建一个共享的bean实例。对于所有的bean请求,只要id与该bean定义的相匹配,那么Spring在每次需要时都返回同一个bean实例。 Singleton是单例...
  • spring中bean的五种作用域

    千次阅读 2022-02-21 10:07:19
    1、singleton:单例,默认的作用域 2、prototype:原型,每次使用(注入或调用getBean()方法都会new一个新的对象...4、session:会话作用域,每次一次新的会话都会产生一个新的对象 5、globalSession:global session
  • Spring中Bean的作用域

    千次阅读 2022-04-11 17:28:44
    Spring Bean的作用域 单例Bean与原型Bean对比 单例bean非线程安全 单例Bean并不是指Spring容器中只能存在一个该类型的Bean
  • Spring中Bean的五种作用域

    千次阅读 2021-07-11 00:11:23
    Bean简介: 在Spring中,那些组成你应用程序的主体...Bean的作用域 创建一个bean定义,其实质是用该bean定义对应的类来创建真正实例的“配方(recipe)”。把bean定义看成一个配方很有意义,它与class很类似,只根据
  • Spring Bean的作用域

    万次阅读 多人点赞 2018-08-25 14:05:02
    Spring中,bean作用域用于确定哪种类型的bean实例应该从Spring容器中返回给调用者。 目前Spring Bean的作用域或者说范围主要有五种。 作用域 描述 singleton 在spring IoC容器仅存在一个Bean实例,Bean...
  • Spring Bean的作用域(作用范围)

    千次阅读 2021-01-15 10:23:54
    Spring中使用 scope来表示一个bean定义对应产生实例的类型,也可以说是对应实例的作用范围。Spring中 指定scope的方法分以下两种: 采用XML配置方式时,可以用<bean />标签中的scope属性可以指定bean的作用...
  • 主要介绍了Spring IOC原理补充说明(循环依赖、Bean作用域等),具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • Spring~Bean的作用域、生命周期

    多人点赞 热门讨论 2022-04-10 18:20:26
    文章目录作用域普通spring环境下:singletonprototypespring web环境下:requestsessionapplication全局作用域和单例作用域不同如何声明bean的作用域通过xml配置文件通过注解生命周期初始化和实例化的区别: 作用域 ...
  • 5w字长文带你彻底看懂Spring是怎么创建对象的!附10几张图,在创作这篇文章的过程中给官方提交了两个issue
  • Spring Bean的作用域之prototype

    千次阅读 2020-06-04 18:47:55
    Spring中Bean的默认最用是单例,即singleton prototype是只在每次getBean的时候都去重新创建一个对象。下面我们来掩饰一下这种场景 使用SpringBoot项目。创建两个Controller一个service和一个实现类 @Controller ...
  • * 1)、包扫描+组件标注注解(@Controller/@Service/@Repository/@Component)[自己写的类] ...参考博客:Spring注解@Scope-设置组件作用域及bean的创建时间 参考博客:Spring懒加载(延迟加载)@...
  • spring bean 的作用域request和session

    千次阅读 2018-06-29 17:11:45
    原文转自:https://blog.csdn.net/qq_36951116/article/details/79121887先了解一下request和session这两个作用域是干嘛的以下是官方文档中文翻译:请求作用域考虑如下的bean定义:&lt;bean id="loginAction...
  • scope=singlton:单例模式,对象在容器中全局唯一,在IOC容器初始化的时候该对象就会被创建 scope=prototype:多例模式,在每一次调用getBean的时候IOC容器才会创建对象的实体,并且每次创建都是不同的对象 ...
  • Spring bean 作用域默认是 单例 singleton;可以通过配置 prototype实现多例; 被注入到Spring中的类 Account.java @Scope("singleton") @Component public class Account { } User.java @Scope("prototype") @...
  • 主要介绍了浅谈Spring中Bean的作用域、生命周期,具有一定借鉴价值,需要的朋友可以参考下
  • Spring对象作用域

    千次阅读 2013-06-04 22:52:52
    * 在配置文件中,scope为  "singleton"   * 默认值  * spring产生的bean只有一个实例  * 处于单例模式的bean的创建、初始化、销毁都是受spring容器管理的
  • spring bean的作用域

    千次阅读 2018-09-19 13:13:25
    spring中,那些组成用用程序的主体以及由springIOC容器所管理的对象称之为bean。也就是说bean是由IOC容器初始化、装配以及管理的对象,除此之外,bean就跟普通的对象一样。然而bean的定义以及bean之间的相互依赖...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 64,675
精华内容 25,870
关键字:

spring创建对象的作用域

spring 订阅