Spring 配置使用 - Bean 作用域

基本概念

Scope，也称作用域，在 Spring IoC 容器是指其创建的 Bean 对象相对于其他 Bean 对象的请求可见范围。

在 Spring IoC 容器中具有以下几种作用域：基本作用域（request、prototype），Web 作用域（reqeust、session、globalsession），自定义作用域。

Spring 的作用域在装配 Bean 时就必须在配置文件中指明，配置方式如下（以 xml 配置文件为例）：

<!-- 具体的作用域需要在 scope 属性中定义 --><bean id="animals" class="com.demo.Animals" scope="xxx" />

---

基本作用域

1.singleton

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

需要注意的是，若一个 Bean 未指定 scope 属性，默认也为 singleton 。

• 在配置文件中定义：

<bean id="animals" class="com.demo.Animals" scope="singleton" />

• 调用验证：

String location = ...ApplicationContext factory = new FileSystemXmlApplicationContext(location);// 获取 BeanAnimals animals = (Animals) factory.getBean("animals");Animals animals2 = (Animals) factory.getBean("animals");System.out.println(animals);System.out.println(animals2);//输出结果：//com.demo.Animals@2151b0a5//com.demo.Animals@2151b0a5

观察输出结果，发现多次获取 Bean，返回的都是同一个 Bean，再次验证了其在 Spring IoC 容器中有且只有一个实例。

---

2.prototype

prototype，也称原型作用域。每次向 Spring IoC 容器请求获取 Bean 都返回一个全新的Bean。相对于 singleton 来说就是不缓存 Bean，每次都是一个根据 Bean 定义创建的全新 Bean。

• 在配置文件中定义：

<bean id="animals" class="com.demo.Animals" scope="prototype" />

• 调用验证，参照 singleton 的例子，观察输出结果，发现每次调用返回不同的实例。

---

Web 作用域

1.reqeust

request，表示每个请求需要容器创建一个全新Bean。

在 Spring IoC 容器，即XmlWebApplicationContext 会为每个 HTTP 请求创建一个全新的 RequestPrecessor 对象。当请求结束后，该对象的生命周期即告结束。当同时有 10 个 HTTP 请求进来的时候，容器会分别针对这 10 个请求创建 10 个全新的 RequestPrecessor 实例，且他们相互之间互不干扰，从不是很严格的意义上说，request 可以看做 prototype 的一种特例，除了场景更加具体之外，语意上差不多。

• 在配置文件中定义：

<bean id="animals" class="com.demo.Animals" scope="request" />

• 调用验证（这里以 SpringMVC 为例，模拟了不同的两个请求）

@RequestMapping(value = "/hello1")public void hello1(HttpServletRequest request) throws Exception {    // 在 Web 程序取得 Ioc 容器    ApplicationContext context = (ApplicationContext) WebApplicationContextUtils.getWebApplicationContext(request.getServletContext());    Animals  animals1 = (Animals) context.getBean(Animals.class);    animals1.setName("animals");    Animals  animals2 = (Animals) context.getBean(Animals.class);    System.out.println(animals1.getName());    System.out.println(animals2.getName());    // 输出结果：    // animals    // animals}@RequestMapping(value = "/hello2")public void hello2(HttpServletRequest request) throws Exception {    ApplicationContext context = (ApplicationContext) WebApplicationContextUtils.getWebApplicationContext(request.getServletContext());    Animals  animals = (Animals) context.getBean(Animals.class);    System.out.println(animals1.getName());    // 输出结果：    // null}

观察输出结果，发现在同一个请求中（hello1 ）多次获取 Bean 返回的是同一个实例，而在不同请求（hello2）中获取 Bean 返回的是不同的 Bean。

---

2.session

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

• 在配置文件中定义：

<bean id="animals" class="com.demo.Animals" scope="session" />

• 调用验证（使用不同的浏览器发起该请求）

@RequestMapping(value = "/hello1")public void hello1(HttpServletRequest request) throws Exception {    // 在 Web 程序取得 Ioc 容器    ApplicationContext context = (ApplicationContext) WebApplicationContextUtils.getWebApplicationContext(request.getServletContext());    Animals  animals1 = (Animals) context.getBean(Animals.class);    animals1.setName("animals");    Animals  animals2 = (Animals) context.getBean(Animals.class);    System.out.println(animals1);    System.out.println(animals2);}

观察输出结果，会发现不同浏览器（不同会话）返回的 Bean 实例不同，而同一个浏览器（同一会话）多次发起请求返回的是同一个 Bean 实例。

---

3.globalSession

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

---

自定义作用域

1.实例探究

自定义作用域，需要实现 Scope 接口。

首先来看该接口的定义：

public interface Scope {    // 从作用域中获取Bean， objectFactory 表示当在当前作用域没找到合适Bean时使用它创建一个新的Bean    Object get(String name, ObjectFactory<?> objectFactory);    // 从作用域中移除 Bean    Object remove(String name);    // 用于注册销毁回调，如果想要销毁相应的对象则由Spring容器注册相应的销毁回调，而由自定义作用域选择是不是要销毁相应的对象；    void registerDestructionCallback(String name, Runnable callback);    // 用于解析相应的上下文数据，比如request作用域将返回request中的属性。    Object resolveContextualObject(String key);    // 作用域的会话标识，比如session作用域将是sessionId。    String getConversationId();}

接下来看看如何使用自定义的作用域

• 自定义作用域 ThreadScope，表示 Bean 作用范围为同一个线程：

public class ThreadScope implements Scope {    // 用于存放线程中的 Bean    private final ThreadLocal<Map<String, Object>> THREAD_SCOPE = new ThreadLocal<Map<String, Object>>() {        protected Map<String, Object> initialValue() {            return new HashMap<String, Object>();        }    };    @Override    public Object get(String name, ObjectFactory<?> objectFactory) {        Map<String, Object> map = THREAD_SCOPE.get();        if (!map.containsKey(name)) {            map.put(name, objectFactory.getObject());        }        return map.get(name);    }    @Override    public Object remove(String name) {        Map<String, Object> map = THREAD_SCOPE.get();        return map.remove(name);    }    @Override    public void registerDestructionCallback(String name, Runnable callback) {    }    @Override    public Object resolveContextualObject(String key) {        return null;    }    @Override    public String getConversationId() {        return null;    }}

• 在配置文件定义：

<!-- CustomScopeConfigurer 的 scopes 属性注册自定义作用域实现 --><bean class="org.springframework.beans.factory.config.CustomScopeConfigurer">    <property name="scopes">        <map>            <entry key="thread" >                <bean class="scope.ThreadScope"/>            </entry>        </map>    </property></bean>  <bean  id="animals" class="com.demo.Animals"  scope="thread"/>

• 调用验证：

public static void main(String [ ] args) {    String location = "WebRoot/WEB-INF/spring-bean.xml";    ApplicationContext factory = new FileSystemXmlApplicationContext(location);    // 在 main 线程获取 Bean     Animals animals1 = (Animals) factory.getBean("animals");    Animals animals2 = (Animals) factory.getBean("animals");    System.out.println(animals1);    System.out.println(animals2);    // 新建线程获取 Bean    Thread thread = new Thread() {        public void run() {            String location = "WebRoot/WEB-INF/spring-bean.xml";            ApplicationContext factory = new FileSystemXmlApplicationContext(location);            Animals animals =  (Animals) factory.getBean("animals");            System.out.println(animals);        }    };    thread.start();    // 输出结果：    // com.demo.Animals@3ddfd90f    // com.demo.Animals@3ddfd90f    // com.demo.Animals@153b2cb}

观察输出结果，发现同一线程多次获取 Bean 返回的是同一个实例，而不同线程获取 Bean 返回的是不同实例。

---

2.原理探究

这里以自定义作用域为例，探究下 scope 的基本原理。在 Spring 中对于 Bean 的 scope（作用域）的检查发生在【获取 Bean】的过程中。获取方法如下：

Animals animals1 = (Animals) factory.getBean("animals");

由此可见，获取 Bean 的入口在 BeanFacotry 中定义。而 BeanFacotry 的基本功能实现都在它的基本实现类 AbstractBeanFactory 中，具体的调用过程这里不再探究，简单的调用流程如下： getBean -> doGetBean。因此这里重点来看下 doGetBean 这个方法：

protected <T> T doGetBean(final String name, final Class<T> requiredType, final Object [ ] args, boolean typeCheckOnly) throws BeansException {    final String beanName = transformedBeanName(name);    // 省略部分源码...        try {            // 省略部分源码...            // 判断 scope 作用域            // 若既不是 singleton 也不是 prototype，表明该 Bean 的作用域是自定义作用域或 web 作用域            if (mbd.isSingleton()) {                // 省略部分源码...            }else if (mbd.isPrototype()) {                // 省略部分源码...            }else {                // 取得 Bean 的 scope 名称，这里指 thread                String scopeName = mbd.getScope();                // 取得在 CustomScopeConfigurer 中定义的 scope 对象，这里指 ThreadScope 对象                final Scope scope = this.scopes.get(scopeName);                if (scope == null) {                    // 抛出异常...                }                try {                    // 调用 scope 的 get 方法                    Object scopedInstance = scope.get(beanName, new ObjectFactory<Object>() {                        // 若不存在该标识的 bean，则触发 map.put(name, objectFactory.getObject()) 的 getObject 方法                        @Override                        public Object getObject() throws BeansException {                            beforePrototypeCreation(beanName);                            try {                                // 创建 Bean 实例                                 return createBean(beanName, mbd, args);                            } finally {                                afterPrototypeCreation(beanName);                            }                        }                    });                    bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);                } catch (IllegalStateException ex) {                    // 抛出异常...                }            }        } catch (BeansException ex) {            cleanupAfterBeanCreationFailure(beanName);            throw ex;        }    }    // 省略部分源码...}

---

参考

• http://jinnianshilongnian.iteye.com/blog/1415463