💎一站式轻松地调用各大LLM模型接口,支持GPT4、智谱、星火、月之暗面及文生图 广告
# 【第三章】 DI 之 3.4 Bean的作用域 ——跟我学spring3 ## 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没采用这种方式,因为该方式属于侵入式设计;代码样例如下: 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”方法获取,消除了编程方式单例,注意在实现中不考虑并发: 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. }   Spring是注册表单例设计模式的实现,消除了编程式单例,而且对代码是非入侵式。 接下来让我们看看在Spring中如何配置单例Bean吧,在Spring容器中如果没指定作用域默认就是“singleton”,配置方式通过scope属性配置,具体配置如下: 1. <bean  class="cn.javass.spring.chapter3.bean.Printer" scope="singleton"/>   Spring管理单例对象在Spring容器中存储如图3-5所示,Spring不仅会缓存单例对象,Bean定义也是会缓存的,对于惰性初始化的对象是在首次使用时根据Bean定义创建并存放于单例缓存池。 ![](https://box.kancloud.cn/2016-05-12_57348071dc556.JPG) 图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”表示作用域,具体如下: 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定义注册表,类似于单例注册表: 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了: 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();   7. //单例注册表   8. private final SingletonBeanRegistry SINGLETONS = new SingletonBeanRegister();   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. }   1. public void registerBeanDefinition(BeanDefinition bd) {   2. DEFINITIONS.registerBeanDefinition(bd.getId(), bd);   3. }   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)如下: 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”即可: 1. <bean class="cn.javass.spring.chapter3.bean.Printer" scope="prototype"/>   Spring管理原型对象在Spring容器中存储如图3-6所示,Spring不会缓存原型对象,而是根据Bean定义每次请求返回一个全新的Bean: ![](https://box.kancloud.cn/2016-05-13_5735471cc6084.JPG) 图3-6 原型处理 单例和原型作用域我们已经讲完,接下来让我们学习一些在Web应用中有哪些作用域: ### 3.4.2  Web应用中的作用域 在Web应用中,我们可能需要将数据存储到request、session、 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接口吧: 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。 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内。 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. }   Scope已经实现了,让我们将其注册到Spring容器,使其发挥作用: 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)如下: 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](http://sishuok.com/forum/blogPost/list/2454.html#7084)】