注册 登录
> 编程技术

【第三章】 DI 之 3.4 Bean的作用域 ——跟我学

系统 1773 0

3.4  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定义创建并存放于单例缓存池。

  【第三章】 DI 之 3.4 Bean的作用域 ——跟我学spring3

图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：

  【第三章】 DI 之 3.4 Bean的作用域 ——跟我学spring3

图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 之 3.4 Bean的作用域 ——跟我学spring3


更多文章、技术交流、商务合作、联系博主

微信扫码或搜索：z360901061

微信扫一扫加我为好友

QQ号联系： 360901061

您的支持是博主写作最大的动力，如果您喜欢我的文章，感觉我的文章对您有帮助，请用微信扫描下面二维码支持博主2元、5元、10元、20元等您想捐的金额吧，狠狠点击下面给点支持吧，站长非常感激您！手机微信长按不能支付解决办法：请将微信支付二维码保存到相册，切换到微信，然后点击微信右上角扫一扫功能，选择支付二维码完成支付。

【本文对您有帮助就好】元

您的支持是博主写作最大的动力，如果您喜欢我的文章，感觉我的文章对您有帮助，请用微信扫描上面二维码支持博主2元、5元、10元、自定义金额等您想捐的金额吧，站长会非常 感谢您的哦！！！

发表我的评论
最新评论 总共0条评论