# 【第三章】 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定义创建并存放于单例缓存池。
图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：
图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)】
- 跟我学 Spring3
- 【第二章】 IoC 之 2.1 IoC基础 ——跟我学Spring3
- 【第二章】 IoC 之 2.2 IoC 容器基本原理 ——跟我学Spring3
- 【第二章】 IoC 之 2.3 IoC的配置使用——跟我学Spring3
- 【第三章】 DI 之 3.1 DI的配置使用 ——跟我学spring3
- 【第三章】 DI 之 3.2 循环依赖 ——跟我学spring3
- 【第三章】 DI 之 3.3 更多DI的知识 ——跟我学spring3
- 【第三章】 DI 之 3.4 Bean的作用域 ——跟我学spring3
- 【第四章】 资源 之 4.1 基础知识 ——跟我学spring3
- 【第四章】 资源 之 4.2 内置Resource实现 ——跟我学spring3
- 【第四章】 资源 之 4.3 访问Resource ——跟我学spring3
- 【第四章】 资源 之 4.4 Resource通配符路径 ——跟我学spring3
- 【第五章】Spring表达式语言 之 5.1 概述 5.2 SpEL基础 ——跟我学spring3
- 【第五章】Spring表达式语言 之 5.3 SpEL语法 ——跟我学spring3
- 【第五章】Spring表达式语言 之 5.4在Bean定义中使用EL—跟我学spring3
- 【第六章】 AOP 之 6.1 AOP基础 ——跟我学spring3
- 【第六章】 AOP 之 6.2 AOP的HelloWorld ——跟我学spring3
- 【第六章】 AOP 之 6.3 基于Schema的AOP ——跟我学spring3
- 【第六章】 AOP 之 6.4 基于@AspectJ的AOP ——跟我学spring3
- 【第六章】 AOP 之 6.5 AspectJ切入点语法详解 ——跟我学spring3
- 【第六章】 AOP 之 6.6 通知参数 ——跟我学spring3
- 【第六章】 AOP 之 6.7 通知顺序 ——跟我学spring3
- 【第六章】 AOP 之 6.8 切面实例化模型 ——跟我学spring3
- 【第六章】 AOP 之 6.9 代理机制 ——跟我学spring3
- 【第七章】 对JDBC的支持 之 7.1 概述 ——跟我学spring3
- 【第七章】 对JDBC的支持 之 7.2 JDBC模板类 ——跟我学spring3
- 【第七章】 对JDBC的支持 之 7.3 关系数据库操作对象化 ——跟我学spring3
- 【第七章】 对JDBC的支持 之 7.4 Spring提供的其它帮助 ——跟我学spring3【私塾在线原创】
- 【第七章】 对JDBC的支持 之 7.5 集成Spring JDBC及最佳实践 ——跟我学spring3
- 【第八章】 对ORM的支持 之 8.1 概述 ——跟我学spring3
- 【第八章】 对ORM的支持 之 8.2 集成Hibernate3 ——跟我学spring3
- 【第八章】 对ORM的支持 之 8.3 集成iBATIS ——跟我学spring3
- 【第八章】 对ORM的支持 之 8.4 集成JPA ——跟我学spring3
- 【第九章】 Spring的事务 之 9.1 数据库事务概述 ——跟我学spring3
- 【第九章】 Spring的事务 之 9.2 事务管理器 ——跟我学spring3
- 【第九章】 Spring的事务 之 9.3 编程式事务 ——跟我学spring3
- 【第九章】 Spring的事务 之 9.4 声明式事务 ——跟我学spring3
- 【第十章】集成其它Web框架 之 10.1 概述 ——跟我学spring3
- 【第十章】集成其它Web框架 之 10.2 集成Struts1.x ——跟我学spring3
- 【第十章】集成其它Web框架 之 10.3 集成Struts2.x ——跟我学spring3
- 【第十章】集成其它Web框架 之 10.4 集成JSF ——跟我学spring3
- 【第十一章】 SSH集成开发积分商城 之 11.1 概述 ——跟我学spring3
- 【第十一章】 SSH集成开发积分商城 之 11.2 实现通用层 ——跟我学spring3
- 【第十一章】 SSH集成开发积分商城 之 11.3 实现积分商城层 ——跟我学spring3
- 【第十二章】零配置 之 12.1 概述 ——跟我学spring3
- 【第十二章】零配置 之 12.2 注解实现Bean依赖注入 ——跟我学spring3
- 【第十二章】零配置 之 12.3 注解实现Bean定义 ——跟我学spring3
- 【第十二章】零配置 之 12.4 基于Java类定义Bean配置元数据 ——跟我学spring3
- 【第十二章】零配置 之 12.5 综合示例-积分商城 ——跟我学spring3
- 【第十三章】 测试 之 13.1 概述 13.2 单元测试 ——跟我学spring3
- 【第十三章】 测试 之 13.3 集成测试 ——跟我学spring3
- 跟我学 Spring MVC
- SpringMVC + spring3.1.1 + hibernate4.1.0 集成及常见问题总结
- Spring Web MVC中的页面缓存支持 ——跟我学SpringMVC系列
- Spring3 Web MVC下的数据类型转换（第一篇）——《跟我学Spring3 Web MVC》抢先看
- Spring3 Web MVC下的数据格式化（第二篇）——《跟我学Spring3 Web MVC》抢先看
- 第一章 Web MVC简介 —— 跟开涛学SpringMVC
- 第二章 Spring MVC入门 —— 跟开涛学SpringMVC
- 第三章 DispatcherServlet详解 ——跟开涛学SpringMVC
- 第四章 Controller接口控制器详解（1）——跟着开涛学SpringMVC
- 第四章 Controller接口控制器详解（2）——跟着开涛学SpringMVC
- 第四章 Controller接口控制器详解（3）——跟着开涛学SpringMVC
- 第四章 Controller接口控制器详解 （4）——跟着开涛学SpringMVC
- 第四章 Controller接口控制器详解（5）——跟着开涛学SpringMVC
- 跟着开涛学SpringMVC 第一章源代码下载
- 第二章 Spring MVC入门 源代码下载
- 第四章 Controller接口控制器详解 源代码下载
- 第四章 Controller接口控制器详解（6）——跟着开涛学SpringMVC
- 第四章 Controller接口控制器详解（7 完）——跟着开涛学SpringMVC
- 第五章 处理器拦截器详解——跟着开涛学SpringMVC
- 源代码下载 第五章 处理器拦截器详解——跟着开涛学SpringMVC
- 注解式控制器运行流程及处理器定义 第六章 注解式控制器详解——跟着开涛学SpringMVC
- 源代码下载 第六章 注解式控制器详解
- SpringMVC3强大的请求映射规则详解 第六章 注解式控制器详解——跟着开涛学SpringMVC
- Spring MVC 3.1新特性 生产者、消费者请求限定 —— 第六章 注解式控制器详解——跟着开涛学SpringMVC
- SpringMVC强大的数据绑定（1）——第六章 注解式控制器详解——跟着开涛学SpringMVC
- SpringMVC强大的数据绑定（2）——第六章 注解式控制器详解——跟着开涛学SpringMVC
- SpringMVC数据类型转换——第七章 注解式控制器的数据验证、类型转换及格式化——跟着开涛学SpringMVC
- SpringMVC数据格式化——第七章 注解式控制器的数据验证、类型转换及格式化——跟着开涛学SpringMVC
- SpringMVC数据验证——第七章 注解式控制器的数据验证、类型转换及格式化——跟着开涛学SpringMVC