`
uule
  • 浏览: 6351787 次
  • 性别: Icon_minigender_1
  • 来自: 一片神奇的土地
社区版块
存档分类
最新评论

Bean作用域

 
阅读更多

跟开涛学Spring

附:单例模式的DoubleCheckLock讨论 

 

侵入式设计

注册表方式

SingletonBeanRegistry 

单例缓存池 - 单例对象

 

本文介绍了单例模式的两种实现,同时还模拟了Spring是如何实现单例和原型对象的,简单明了。

SingletonBeanRegistry 

BeanDefinition

 

 Bean的作用域

       什么是作用域呢?即“scope”,在面向对象程序设计中一般指对象或变量之间的可见范围。而在Spring容器中是指其创建的Bean对象相对于其他Bean对象的请求可见范围。

 

Spring提供“singleton”和“prototype”两种基本作用域,另外提供“request”、“session”、“global session”三种web作用域;Spring还允许用户定制自己的作用域。

 

3.4.1  基本的作用域

       一、singleton指“singleton”作用域的Bean只会在每个Spring IoC容器中存在一个实例,而且其完整生命周期完全由Spring容器管理。对于所有获取该Bean的操作Spring容器将只返回同一个Bean。

 

GoF单例设计模式指“保证一个类仅有一个实例,并提供一个访问它的全局访问点”,介绍了两种实现:通过在类上定义静态属性保持该实例和通过注册表方式。

       

1)通过在类上定义静态属性保持该实例:一般指一个Java虚拟机 ClassLoader装载的类只有一个实例,一般通过类静态属性保持该实例,这样就造成需要单例的类都需要按照单例设计模式进行编码;Spring没采用这种方式,因为该方式属于侵入式设计;代码样例如下:

 

java代码:
  1. package cn.javass.spring.chapter3.bean;  
  2. public class Singleton {  
  3.     //1.私有化构造器  
  4.     private Singleton() {}  
  5.     //2.单例缓存者,惰性初始化,第一次使用时初始化  
  6.     private static class InstanceHolder {  
  7.         private static final Singleton INSTANCE = new Singleton();  
  8.     }  
  9.     //3.提供全局访问点  
  10.     public static Singleton getInstance() {  
  11.         return InstanceHolder.INSTANCE;  
  12.     }  
  13.     //4.提供一个计数器来验证一个ClassLoader一个实例  
  14.     private int counter=0;  
  15. }  

 

 

以上定义个了个单例类,首先要私有化类构造器;其次使用InstanceHolder静态内部类持有单例对象,这样可以得到惰性初始化好处;最后提供全局访问点getInstance,使得需要该单例实例的对象能获取到;我们在此还提供了一个counter计数器来验证一个ClassLoader一个实例。具体一个ClassLoader有一个单例实例测试请参考代码“cn.javass.spring.chapter3. SingletonTest”中的“testSingleton”测试方法,里边详细演示了一个ClassLoader有一个单例实例。

 

 

1)  通过注册表方式: 首先将需要单例的实例通过唯一键注册到注册表,然后通过键来获取单例,让我们直接看实现吧,注意本注册表实现了Spring接口“SingletonBeanRegistry”,该接口定义了操作共享的单例对象,Spring容器实现将实现此接口;所以共享单例对象通过“registerSingleton”方法注册通过“getSingleton”方法获取,消除了编程方式单例,注意在实现中不考虑并发:

 

 

java代码:
  1. package cn.javass.spring.chapter3;  
  2. import java.util.HashMap;  
  3. import java.util.Map;  
  4. import org.springframework.beans.factory.config.SingletonBeanRegistry;  
  5. public class SingletonBeanRegister implements SingletonBeanRegistry {  
  6.     //单例Bean缓存池,此处不考虑并发  
  7.     private final Map<String, Object> BEANS = new HashMap<String, Object>();  
  8.     public boolean containsSingleton(String beanName) {  
  9.         return BEANS.containsKey(beanName);  
  10.     }  
  11.     public Object getSingleton(String beanName) {  
  12.         return BEANS.get(beanName);  
  13.     }  
  14.     @Override  
  15.     public int getSingletonCount() {  
  16.         return BEANS.size();  
  17.     }  
  18.     @Override  
  19.     public String[] getSingletonNames() {  
  20.         return BEANS.keySet().toArray(new String[0]);  
  21.     }  
  22.     @Override  
  23.     public void registerSingleton(String beanName, Object bean) {  
  24.         if(BEANS.containsKey(beanName)) {  
  25.             throw new RuntimeException("[" + beanName + "] 已存在");  
  26.         }  
  27.         BEANS.put(beanName, bean);  
  28. }  
  29. }  
  30.    

 

Spring是注册表单例设计模式的实现,消除了编程式单例,而且对代码是非入侵式。

接下来让我们看看在Spring中如何配置单例Bean吧,在Spring容器中如果没指定作用域默认就是“singleton”,配置方式通过scope属性配置,具体配置如下:

 

java代码:
  1. <bean  class="cn.javass.spring.chapter3.bean.Printer" scope="singleton"/>  

 

       Spring管理单例对象在Spring容器中存储如图3-5所示,Spring不仅会缓存单例对象,Bean定义也是会缓存的,对于惰性初始化的对象是在首次使用时根据Bean定义创建并存放于单例缓存池

 

图3-5 单例处理

 

二、prototype即原型,指每次向Spring容器请求获取Bean都返回一个全新的Bean,相对于“singleton”来说就是不缓存Bean,每次都是一个根据Bean定义创建的全新Bean。

 

GoF原型设计模式,指用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象。

 

Spring中的原型和GoF中介绍的原型含义是不一样的:

         GoF通过用原型实例指定创建对象的种类,而Spring容器用Bean定义指定创建对象的种类;

         GoF通过拷贝这些原型创建新的对象,而Spring容器根据Bean定义创建新对象。

其相同地方都是根据某些东西创建新东西,而且GoF原型必须显示实现克隆操作,属于侵入式,而Spring容器只需配置即可,属于非侵入式。

 

接下来让我们看看Spring如何实现原型呢?

 

1)首先让我们来定义Bean“原型”:Bean定义,所有对象将根据Bean定义创建;在此我们只是简单示例一下,不会涉及依赖注入等复杂实现:BeanDefinition类定义属性“class”表示原型类,“id”表示唯一标识,“scope”表示作用域,具体如下:

 

java代码:
  1. package cn.javass.spring.chapter3;  
  2. public class BeanDefinition {  
  3.     //单例  
  4.     public static final int SCOPE_SINGLETON = 0;  
  5.     //原型  
  6.     public static final int SCOPE_PROTOTYPE = 1;  
  7.     //唯一标识  
  8.     private String id;  
  9.     //class全限定名  
  10.     private String clazz;  
  11.     //作用域  
  12. private int scope = SCOPE_SINGLETON;  
  13.     //鉴于篇幅,省略setter和getter方法;  
  14. }  

 

2)接下来让我们看看Bean定义注册表,类似于单例注册表:

 

java代码:
  1. package cn.javass.spring.chapter3;  
  2. import java.util.HashMap;  
  3. import java.util.Map;  
  4. public class BeanDifinitionRegister {  
  5.     //bean定义缓存,此处不考虑并发问题  
  6. private final Map<String, BeanDefinition> DEFINITIONS =  
  7.  new HashMap<String, BeanDefinition>();  
  8.     public void registerBeanDefinition(String beanName, BeanDefinition bd) {  
  9.         //1.本实现不允许覆盖Bean定义  
  10.         if(DEFINITIONS.containsKey(bd.getId())) {  
  11.             throw new RuntimeException("已存在Bean定义,此实现不允许覆盖");  
  12.         }  
  13.         //2.将Bean定义放入Bean定义缓存池  
  14.         DEFINITIONS.put(bd.getId(), bd);  
  15.     }  
  16.     public BeanDefinition getBeanDefinition(String beanName) {  
  17.         return DEFINITIONS.get(beanName);  
  18.     }  
  19. public boolean containsBeanDefinition(String beanName) {        
  20.  return DEFINITIONS.containsKey(beanName);  
  21.     }  
  22. }  

 

3)接下来应该来定义BeanFactory了:

 

java代码:
  1. package cn.javass.spring.chapter3;  
  2. import org.springframework.beans.factory.config.SingletonBeanRegistry;  
  3. public class DefaultBeanFactory {  
  4.     //Bean定义注册表  
  5.     private BeanDifinitionRegister DEFINITIONS = new BeanDifinitionRegister();  
  6.    
  7.     //单例注册表  
  8.     private final SingletonBeanRegistry SINGLETONS = new SingletonBeanRegister();  
  9.      
  10.     public Object getBean(String beanName) {  
  11.         //1.验证Bean定义是否存在  
  12.         if(!DEFINITIONS.containsBeanDefinition(beanName)) {  
  13.             throw new RuntimeException("不存在[" + beanName + "]Bean定义");  
  14.         }  
  15.         //2.获取Bean定义  
  16.         BeanDefinition bd = DEFINITIONS.getBeanDefinition(beanName);  
  17.         //3.是否该Bean定义是单例作用域  
  18.         if(bd.getScope() == BeanDefinition.SCOPE_SINGLETON) {  
  19.             //3.1 如果单例注册表包含Bean,则直接返回该Bean  
  20.             if(SINGLETONS.containsSingleton(beanName)) {  
  21.                 return SINGLETONS.getSingleton(beanName);  
  22.             }  
  23.             //3.2单例注册表不包含该Bean,  
  24.             //则创建并注册到单例注册表,从而缓存  
  25.             SINGLETONS.registerSingleton(beanName, createBean(bd));  
  26.             return SINGLETONS.getSingleton(beanName);  
  27.         }  
  28.         //4.如果是原型Bean定义,则直接返回根据Bean定义创建的新Bean,  
  29. //每次都是新的,无缓存  
  30.         if(bd.getScope() == BeanDefinition.SCOPE_PROTOTYPE) {  
  31.             return createBean(bd);  
  32.         }  
  33.         //5.其他情况错误的Bean定义  
  34.         throw new RuntimeException("错误的Bean定义");  
  35.     }  
  36.    

 

 

java代码:
  1. public void registerBeanDefinition(BeanDefinition bd) {  
  2.      DEFINITIONS.registerBeanDefinition(bd.getId(), bd);  
  3.  }  
  4.   
  5.  private Object createBean(BeanDefinition bd) {  
  6.      //根据Bean定义创建Bean  
  7.      try {  
  8.          Class clazz = Class.forName(bd.getClazz());  
  9.          //通过反射使用无参数构造器创建Bean  
  10.          return clazz.getConstructor().newInstance();  
  11.      } catch (ClassNotFoundException e) {  
  12.          throw new RuntimeException("没有找到Bean[" + bd.getId() + "]类");  
  13.      } catch (Exception e) {  
  14.          throw new RuntimeException("创建Bean[" + bd.getId() + "]失败");  
  15.      }  
  16.  }  

 

       其中方法getBean用于获取根据beanName对于的Bean定义创建的对象,有单例和原型两类Bean;registerBeanDefinition方法用于注册Bean定义,私有方法createBean用于根据Bean定义中的类型信息创建Bean。

 

3)测试一下吧,在此我们只测试原型作用域Bean,对于每次从Bean工厂中获取的Bean都是一个全新的对象,代码片段(BeanFatoryTest)如下:

 

java代码:
  1. @Test  
  2. public void testPrototype () throws Exception {  
  3. //1.创建Bean工厂  
  4. DefaultBeanFactory bf = new DefaultBeanFactory();  
  5. //2.创建原型 Bean定义  
  6. BeanDefinition bd = new BeanDefinition();  
  7. bd.setId("bean");  
  8. bd.setScope(BeanDefinition.SCOPE_PROTOTYPE);  
  9. bd.setClazz(HelloImpl2.class.getName());  
  10. bf.registerBeanDefinition(bd);  
  11. //对于原型Bean每次应该返回一个全新的Bean  
  12. System.out.println(bf.getBean("bean") != bf.getBean("bean"));  
  13. }  

 

 

最后让我们看看如何在Spring中进行配置吧,只需指定<bean>标签属性“scope”属性为“prototype”即可:

 

java代码:
  1. <bean class="cn.javass.spring.chapter3.bean.Printer" scope="prototype"/>  

 

 

       Spring管理原型对象在Spring容器中存储如图3-6所示,Spring不会缓存原型对象,而是根据Bean定义每次请求返回一个全新的Bean:

 

图3-6 原型处理

       单例和原型作用域我们已经讲完,接下来让我们学习一些在Web应用中有哪些作用域:

 

3.4.2  Web应用中的作用域

在Web应用中,我们可能需要将数据存储到request、session、global session。因此Spring提供了三种Web作用域:request、session、globalSession。

 

一、request作用域:表示每个请求需要容器创建一个全新Bean比如提交表单的数据必须是对每次请求新建一个Bean来保持这些表单数据,请求结束释放这些数据。

 

二、session作用域:表示每个会话需要容器创建一个全新Bean比如对于每个用户一般会有一个会话,该用户的用户信息需要存储到会话中,此时可以将该Bean配置为web作用域。

 

三、globalSession类似于session作用域,只是其用于portlet环境的web应用。如果在非portlet环境将视为session作用域。

 

配置方式和基本的作用域相同,只是必须要有web环境支持,并配置相应的容器监听器或拦截器从而能应用这些作用域,我们会在集成web时讲解具体使用,大家只需要知道有这些作用域就可以了。

 

3.4.4 自定义作用域

在日常程序开发中,几乎用不到自定义作用域,除非又必要才进行自定义作用域。

首先让我们看下Scope接口吧:

 

java代码:
  1. package org.springframework.beans.factory.config;  
  2. import org.springframework.beans.factory.ObjectFactory;  
  3. public interface Scope {  
  4.        Object get(String name, ObjectFactory<?> objectFactory);  
  5.        Object remove(String name);  
  6.        void registerDestructionCallback(String name, Runnable callback);  
  7.        Object resolveContextualObject(String key);  
  8.        String getConversationId();  
  9. }  

 

1)Object get(String name, ObjectFactory<?> objectFactory)用于从作用域中获取Bean,其中参数objectFactory是当在当前作用域没找到合适Bean时使用它创建一个新的Bean;

 

2)void registerDestructionCallback(String name, Runnable callback)用于注册销毁回调,如果想要销毁相应的对象则由Spring容器注册相应的销毁回调,而由自定义作用域选择是不是要销毁相应的对象;

 

3)Object resolveContextualObject(String key)用于解析相应的上下文数据,比如request作用域将返回request中的属性。

 

4)String getConversationId()作用域的会话标识,比如session作用域将是sessionId。

 

 

java代码:
  1. package cn.javass.spring.chapter3;  
  2. import java.util.HashMap;  
  3. import java.util.Map;  
  4. import org.springframework.beans.factory.ObjectFactory;  
  5. import org.springframework.beans.factory.config.Scope;  
  6. public class ThreadScope implements Scope {  
  7. private final ThreadLocal<Map<String, Object>> THREAD_SCOPE =  
  8. new ThreadLocal<Map<String, Object>>() {  
  9.       protected Map<String, Object> initialValue() {  
  10.           //用于存放线程相关Bean  
  11.           return new HashMap<String, Object>();  
  12.       }  
  13.     };  

 

       让我们来实现个简单的thread作用域,该作用域内创建的对象将绑定到ThreadLocal内。

 

java代码:
  1.     @Override  
  2.     public Object get(String name, ObjectFactory<?> objectFactory) {  
  3.         //如果当前线程已经绑定了相应Bean,直接返回  
  4.         if(THREAD_SCOPE.get().containsKey(name)) {  
  5.            return THREAD_SCOPE.get().get(name);  
  6.         }  
  7.         //使用objectFactory创建Bean并绑定到当前线程上  
  8.         THREAD_SCOPE.get().put(name, objectFactory.getObject());  
  9.         return THREAD_SCOPE.get().get(name);  
  10.     }  
  11.     @Override  
  12.     public String getConversationId() {  
  13.         return null;  
  14.     }  
  15.     @Override  
  16.     public void registerDestructionCallback(String name, Runnable callback) {  
  17.         //此处不实现就代表类似proytotype,容器返回给用户后就不管了  
  18.     }  
  19.     @Override  
  20.     public Object remove(String name) {  
  21.         return THREAD_SCOPE.get().remove(name);  
  22.     }  
  23.     @Override  
  24.     public Object resolveContextualObject(String key) {  
  25.         return null;  
  26.     }  
  27. }  
  28.    

 

Scope已经实现了,让我们将其注册到Spring容器,使其发挥作用:

 

java代码:
  1. <bean class="org.springframework.beans.factory.config.CustomScopeConfigurer">  
  2.         <property name="scopes">  
  3.            <map><entry>  
  4.                    <!-- 指定scope关键字 --><key><value>thread</value></key>  
  5.                    <!-- scope实现 -->      <bean class="cn.javass.spring.chapter3.ThreadScope"/>  
  6.            </entry></map>      
  7.         </property>  
  8.     </bean>  

 

通过CustomScopeConfigurer的scopes属性注册自定义作用域实现,在此需要指定使用作用域的关键字“thread”,并指定自定义作用域实现。来让我们来定义一个“thread”作用域的Bean,配置(chapter3/threadScope.xml)如下:

 

java代码:
  1. <bean id="helloApi"  
  2.     class="cn.javass.spring.chapter2.helloworld.HelloImpl"  
  3.     scope="thread"/>  

 

最后测试(cn.javass.spring.chapter3.ThreadScopeTest)一下吧,首先在一个线程中测试,在同一线程中获取的Bean应该是一样的;再让我们开启两个线程,然后应该这两个线程创建的Bean是不一样:

 

 

自定义作用域实现其实是非常简单的,其实复杂的是如果需要销毁Bean,自定义作用域如何正确的销毁Bean。

 

原创内容 转载请注明出处【http://sishuok.com/forum/blogPost/list/2454.html

分享到:
| DI
评论

相关推荐

    spring的bean作用域

    在Spring中,有五种主要的Bean作用域: 1. **Singleton作用域**: - Singleton是Spring默认的Bean作用域。这意味着,无论何时,只要Spring容器被初始化,它都会创建一个Bean实例,并将其缓存起来。后续对相同ID的...

    Spring Bean 作用域.pdf

    spring Bean 作用域.pdf

    spring-aware接口实现与bean作用域(spring多容器层面)

    关于`bean的作用域`,Spring支持多种Bean的作用域,包括单例(Singleton)、原型(Prototype)、会话(Session)和请求(Request)。这些作用域定义了Bean的生命周期和创建行为: 1. **单例(Singleton)**:默认...

    Spring Bean的作用域.docx

    Spring提供了五种不同的Bean作用域,每种都有其特定的使用场景和行为。 1. **Singleton作用域**:这是Spring的默认作用域,意味着无论何时从容器中请求一个特定的Bean,都会返回同一个实例。在配置文件中,可以使用...

    SPRING FRAMEWORK BEAN作用域和生命周期原理解析

    SPRING FRAMEWORK BEAN作用域和生命周期原理解析 Spring Framework 是一个流行的 Java Web 应用程序框架,它提供了一个强大的依赖注入机制,称为 Bean 容器。Bean 容器管理着应用程序中的所有对象,并提供了一些...

    Spring 的bean的作用域总结

    Spring 的bean的作用域总结,详细的总结了 Spring 的bean的作用域

    简单了解spring bean作用域属性singleton和prototype的区别

    Spring Bean作用域属性singleton和prototype的区别详解 Spring Framework中,Bean的作用域属性是指Bean实例的生命周期和作用域。Spring提供了五种作用域:singleton、prototype、request、session和global session...

    详解Spring中bean的作用域

    Spring中bean的作用域详解 Spring 中 bean 的作用域是指 Spring IoC 容器中 bean 的生命周期和实例化方式。bean 的作用域决定了 bean 的实例化和生命周期的管理方式。在 Spring 中,bean 的作用域可以分为五种:...

    基于java的企业级应用开发:Bean的作用域.ppt

    在企业级应用开发中,Java 是一种广泛使用的编程语言,特别是在Spring框架的支持下,能够构建高效、可扩展的系统。Spring框架的核心特性之一是...选择正确的Bean作用域是实现高效且健壮的企业级应用开发的关键步骤。

    Spring IOC原理补充说明(循环依赖、Bean作用域等)

    Spring IOC,即控制反转(Inversion of Control),...综上所述,Spring通过一系列机制解决了循环依赖问题,并提供了丰富的Bean作用域来满足不同场景的需求。理解这些原理对于优化Spring应用的性能和可维护性至关重要。

    Spring实战之Bean的作用域request用法分析

    主要介绍了Spring实战之Bean的作用域request用法,结合实例形式分析了spring中Bean的request作用域相关使用技巧与操作注意事项,需要的朋友可以参考下

    spring Bean的作用域之间有什么区别1

    Spring Bean 的作用域之间有什么区别:Bean的作用域: 可以通过scope 属性来指定bean的作用域 ①singleton: 默认值。当IOC容器

    详解Spring中Bean的生命周期和作用域及实现方式

    Spring中Bean的生命周期和作用域及实现方式 Spring是一个非常流行的Java应用程序框架,它提供了一个灵活的机制来管理Bean的生命周期和作用域。Bean的生命周期和作用域是Spring框架中两个非常重要的概念,它们决定了...

    spring bean 的作用域(scope)

    spring bean 的作用域(scope), SPringle bean的作用域

    JSP 中Spring Bean 的作用域详解

    在JSP(Java Server Pages)开发中,经常需要与Spring框架进行交互,而Spring框架中的Bean作用域定义了该Bean的生命周期以及在应用程序中的共享范围。Spring Bean的作用域有以下几种: 1. Singleton(单例) 单例是...

    SSH笔记-bean的作用域

    在Spring框架中,Bean的作用域是管理对象生命周期和作用范围的关键概念。Bean的定义通常包含在XML配置文件中,通过`&lt;bean&gt;`标签进行配置。当我们谈论"SSH笔记-bean的作用域"时,这里SSH指的是Spring、Struts和...

    Spring容器中Bean的作用域编程开发技术共3页.pd

    在Spring框架中,Bean的作用域是其生命周期管理的关键部分,它决定了Bean的创建、共享以及销毁方式。本篇内容将深入探讨Spring容器中Bean的作用域编程开发技术,以帮助开发者更好地理解和利用这些特性来优化应用的...

    Spring实战之Bean的作用域singleton和prototype用法分析

    在Spring框架中,Bean的作用域是决定如何管理和创建Bean实例的关键概念。本篇文章将深入探讨两种主要的作用域:singleton和prototype,并通过实例分析其用法和注意事项。 首先,`singleton`是Spring默认的作用域,...

Global site tag (gtag.js) - Google Analytics