开涛spring3(3.4) - DI 之 3.4 Bean的作用域

最新推荐文章于 2024-06-15 10:13:23 发布

dengkuituo0680

最新推荐文章于 2024-06-15 10:13:23 发布

阅读量77

点赞数

文章标签：设计模式测试数据库

原文链接：http://www.cnblogs.com/crazylqy/p/4305380.html

版权

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没采用这种方式，因为该方式属于侵入式设计；代码样例如下：

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

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

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

package cn.javass.spring.chapter3;  
import java.util.HashMap;  
import java.util.Map;  
import org.springframework.beans.factory.config.SingletonBeanRegistry;  
public class SingletonBeanRegister implements SingletonBeanRegistry {  
    //单例Bean缓存池，此处不考虑并发  
    private final Map<String, Object> BEANS = new HashMap<String, Object>();  
    public boolean containsSingleton(String beanName) {  
        return BEANS.containsKey(beanName);  
    }  
    public Object getSingleton(String beanName) {  
        return BEANS.get(beanName);  
    }  
    @Override  
    public int getSingletonCount() {  
        return BEANS.size();  
    }  
    @Override  
    public String[] getSingletonNames() {  
        return BEANS.keySet().toArray(new String[0]);  
    }  
    @Override  
    public void registerSingleton(String beanName, Object bean) {  
        if(BEANS.containsKey(beanName)) {  
            throw new RuntimeException("[" + beanName + "] 已存在");  
        }  
        BEANS.put(beanName, bean);  
}  
}

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

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

<bean  class="cn.javass.spring.chapter3.bean.Printer" scope="singleton"/>

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

二、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”表示作用域，具体如下：

    package cn.javass.spring.chapter3;  
    public class BeanDefinition {  
        //单例  
        public static final int SCOPE_SINGLETON = 0;  
        //原型  
        public static final int SCOPE_PROTOTYPE = 1;  
        //唯一标识  
        private String id;  
        //class全限定名  
        private String clazz;  
        //作用域  
    private int scope = SCOPE_SINGLETON;  
        //鉴于篇幅，省略setter和getter方法；  
    }

2）接下来让我们看看Bean定义注册表，类似于单例注册表：

    package cn.javass.spring.chapter3;  
    import java.util.HashMap;  
    import java.util.Map;  
    public class BeanDifinitionRegister {  
        //bean定义缓存，此处不考虑并发问题  
    private final Map<String, BeanDefinition> DEFINITIONS =  
     new HashMap<String, BeanDefinition>();  
        public void registerBeanDefinition(String beanName, BeanDefinition bd) {  
            //1.本实现不允许覆盖Bean定义  
            if(DEFINITIONS.containsKey(bd.getId())) {  
                throw new RuntimeException("已存在Bean定义，此实现不允许覆盖");  
            }  
            //2.将Bean定义放入Bean定义缓存池  
            DEFINITIONS.put(bd.getId(), bd);  
        }  
        public BeanDefinition getBeanDefinition(String beanName) {  
            return DEFINITIONS.get(beanName);  
        }  
    public boolean containsBeanDefinition(String beanName) {        
     return DEFINITIONS.containsKey(beanName);  
        }  
    }

3）接下来应该来定义BeanFactory了：

package cn.javass.spring.chapter3;  
import org.springframework.beans.factory.config.SingletonBeanRegistry;  
public class DefaultBeanFactory {  
    //Bean定义注册表  
    private BeanDifinitionRegister DEFINITIONS = new BeanDifinitionRegister();  
   
    //单例注册表  
    private final SingletonBeanRegistry SINGLETONS = new SingletonBeanRegister();  
     
    public Object getBean(String beanName) {  
        //1.验证Bean定义是否存在  
        if(!DEFINITIONS.containsBeanDefinition(beanName)) {  
            throw new RuntimeException("不存在[" + beanName + "]Bean定义");  
        }  
        //2.获取Bean定义  
        BeanDefinition bd = DEFINITIONS.getBeanDefinition(beanName);  
        //3.是否该Bean定义是单例作用域  
        if(bd.getScope() == BeanDefinition.SCOPE_SINGLETON) {  
            //3.1 如果单例注册表包含Bean，则直接返回该Bean  
            if(SINGLETONS.containsSingleton(beanName)) {  
                return SINGLETONS.getSingleton(beanName);  
            }  
            //3.2单例注册表不包含该Bean，  
            //则创建并注册到单例注册表，从而缓存  
            SINGLETONS.registerSingleton(beanName, createBean(bd));  
            return SINGLETONS.getSingleton(beanName);  
        }  
        //4.如果是原型Bean定义,则直接返回根据Bean定义创建的新Bean，  
//每次都是新的，无缓存  
        if(bd.getScope() == BeanDefinition.SCOPE_PROTOTYPE) {  
            return createBean(bd);  
        }  
        //5.其他情况错误的Bean定义  
        throw new RuntimeException("错误的Bean定义");  
    }

    public void registerBeanDefinition(BeanDefinition bd) {  
         DEFINITIONS.registerBeanDefinition(bd.getId(), bd);  
     }  
      
     private Object createBean(BeanDefinition bd) {  
         //根据Bean定义创建Bean  
         try {  
             Class clazz = Class.forName(bd.getClazz());  
             //通过反射使用无参数构造器创建Bean  
             return clazz.getConstructor().newInstance();  
         } catch (ClassNotFoundException e) {  
             throw new RuntimeException("没有找到Bean[" + bd.getId() + "]类");  
         } catch (Exception e) {  
             throw new RuntimeException("创建Bean[" + bd.getId() + "]失败");  
         }  
     }

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

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

    @Test  
    public void testPrototype () throws Exception {  
    //1.创建Bean工厂  
    DefaultBeanFactory bf = new DefaultBeanFactory();  
    //2.创建原型 Bean定义  
    BeanDefinition bd = new BeanDefinition();  
    bd.setId("bean");  
    bd.setScope(BeanDefinition.SCOPE_PROTOTYPE);  
    bd.setClazz(HelloImpl2.class.getName());  
    bf.registerBeanDefinition(bd);  
    //对于原型Bean每次应该返回一个全新的Bean  
    System.out.println(bf.getBean("bean") != bf.getBean("bean"));  
    }

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

    <bean class="cn.javass.spring.chapter3.bean.Printer" scope="prototype"/>

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接口吧：

    package org.springframework.beans.factory.config;  
    import org.springframework.beans.factory.ObjectFactory;  
    public interface Scope {  
           Object get(String name, ObjectFactory<?> objectFactory);  
           Object remove(String name);  
           void registerDestructionCallback(String name, Runnable callback);  
           Object resolveContextualObject(String key);  
           String getConversationId();  
    }

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。

    package cn.javass.spring.chapter3;  
    import java.util.HashMap;  
    import java.util.Map;  
    import org.springframework.beans.factory.ObjectFactory;  
    import org.springframework.beans.factory.config.Scope;  
    public class ThreadScope implements Scope {  
    private final ThreadLocal<Map<String, Object>> THREAD_SCOPE =  
    new ThreadLocal<Map<String, Object>>() {  
          protected Map<String, Object> initialValue() {  
              //用于存放线程相关Bean  
              return new HashMap<String, Object>();  
          }  
        };

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

 @Override  
    public Object get(String name, ObjectFactory<?> objectFactory) {  
        //如果当前线程已经绑定了相应Bean，直接返回  
        if(THREAD_SCOPE.get().containsKey(name)) {  
           return THREAD_SCOPE.get().get(name);  
        }  
        //使用objectFactory创建Bean并绑定到当前线程上  
        THREAD_SCOPE.get().put(name, objectFactory.getObject());  
        return THREAD_SCOPE.get().get(name);  
    }  
    @Override  
    public String getConversationId() {  
        return null;  
    }  
    @Override  
    public void registerDestructionCallback(String name, Runnable callback) {  
        //此处不实现就代表类似proytotype，容器返回给用户后就不管了  
    }  
    @Override  
    public Object remove(String name) {  
        return THREAD_SCOPE.get().remove(name);  
    }  
    @Override  
    public Object resolveContextualObject(String key) {  
        return null;  
    }  
}

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

    <bean class="org.springframework.beans.factory.config.CustomScopeConfigurer">  
            <property name="scopes">  
               <map><entry>  
                       <!-- 指定scope关键字 --><key><value>thread</value></key>  
                       <!-- scope实现 -->      <bean class="cn.javass.spring.chapter3.ThreadScope"/>  
               </entry></map>      
            </property>  
        </bean>

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

    <bean id="helloApi"  
        class="cn.javass.spring.chapter2.helloworld.HelloImpl"  
        scope="thread"/>

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

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

番外1：

spring 的singleton 和prototype的区别和应用场合

1.
singleton作用域：当把一个Bean定义设置为singleton作用域是，Spring IoC容器中只会存在一个共享的Bean实例，并且所有对Bean的请求，只要id与该Bean定义相匹配，则只会返回该Bean的同一实例。值得强调的是singleton作用域是Spring中的缺省作用域。
prototype作用域：prototype作用域的Bean会导致在每次对该Bean请求（将其注入到另一个Bean中，或者以程序的方式调用容器的getBean()方法）时都会创建一个新的Bean实例。根据经验，对有状态的Bean应使用prototype作用域，而对无状态的Bean则应该使用singleton作用域。对于具有prototype作用域的Bean，有一点很重要，即Spring不能对该Bean的整个生命周期负责。具有prototype作用域的Bean创建后交由调用者负责销毁对象回收资源。简单的说：

    singleton 只有一个实例，也即是单例模式。

    prototype访问一次创建一个实例，相当于new。

他们的应用场合：

    1.需要回收重要资源(数据库连接等)的事宜配置为singleton，如果配置为prototype需要应用确保资源正常回收。

    2.有状态的Bean配置成singleton会引发未知问题，可以考虑配置为prototype。

singleton是单态模式的，有ioc容器管理，当然不是线程安全的啦，不过所谓的线程安全也是相对的

如果你的类是没有状态的，那用singleton 的性能要高一些，因为只有一个实例。
如果你的类是有状态的，那就必须显示的设置为prototype了

在ssh2 项目中， struts2的action交由spring管理的时候，spring默认是singleton的，而struts2的action显然是有状态的，所以必须显示设置为
scope=“prototype”

prototype为原型模式，每次action请求过来都会创建一个action

但是对那些Dao的实现类推介scope=“singleton” ，因为这些类没有状态，用singleton只需维护一个实例，显然性能高一些

有状态会话bean ：每个用户有自己特有的一个实例，在用户的生存期内，bean保持了用户的信息，即“有状态”；一旦用户灭亡（调用结束或实例结束），bean的生命期也告结束。即每个用户最初都会得到一个初始的bean。

无状态会话bean ：bean一旦实例化就被加进会话池中，各个用户都可以共用。即使用户已经消亡，bean 的生命期也不一定结束，它可能依然存在于会话池中，供其他用户调用。由于没有特定的用户，那么也就不能保持某一用户的状态，所以叫无状态bean。但无状态会话bean 并非没有状态，如果它有自己的属性（变量），那么这些变量就会受到所有调用它的用户的影响，这是在实际应用中必须注意的

番外2：

Spring MVC Controller单例陷阱

http://www.cnblogs.com/crazylqy/p/4305434.html

转载于:https://www.cnblogs.com/crazylqy/p/4305380.html

dengkuituo0680

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
开涛spring3(3.4) - DI 之 3.4 Bean的作用域

3.4 Bean的作用域什么是作用域呢？即“scope”，在面向对象程序设计中一般指对象或变量之间的可见范围。而在Spring容器中是指其创建的Bean对象相对于其他Bean对象的请求可见范围。Spring提供“singleton”和“prototype”两种基本作用域，另外提供“request”、“session”、“global session”三种web作用...
复制链接

扫一扫