Spring Bean的范围

标签：

当你配置一个bean的时候，你会通过bean的配置为实际的类实例创建一个配方（recipe ）。bean的配置是一个配方的想法是很重要，因为它意味着，就像类一样，你可以通过一个配方来创建很多个实例。

你不仅可以控制被注入到由特定bean配置创建的对象的依赖和配置值，而且也可以控制对象的范围。这个方式是强大和灵活的，通过这种方式你可以通过配置文件来选择对象的范围，而不用放到Java类的级别。可以用多个范围内的一个来定义bean加载的范围：开箱即用，Spring支持5类范围，其中3个是只有你用到web-aware的ApplicationContext时才会有用。

下列的范围都是可以直接使用的。你也可以创建一个自定义范围（a custom scope）。

Table 6.3. Bean scopes

	在spring 3.0中，线程范围的bean也是可用的，但不是默认注册的。想了解更多信息，请参考SimpleThreadScope文档。为了说明如何注册或定义任何其他的范围，参考“使用自定义范围”（“Using a custom scope”.）章节。

单例范围（The singleton scope）

只维护一个共享的bean实例，任何通过id或ids匹配的bean的请求，Spring都会返一个特定的bean的实例。

换种方式说，当你定义一个bean的范围为singleton时，Spring容器会根据bean的配置恰好创建一个对象实例。这个单例bean被存在这些单例bean的缓存中，任何后续对于同一个bean的请求或者引用都会返回缓存对象。

Spring概念的单例bean和设计模式中的单例是不同的。设计模式的单例是通过硬编码的方式使一个对象在每一个ClassLoder中只会创建仅仅一个特定类的实例。Spring Bean的单例范围是对一个容器一个bean的最好描述。这意味着如果你在一个Spring容器中只为一个类定义了一个bean，那么Spring只会根据配置文件创建一个指定类的实例。singleton 范围是Spring默认的范围。用XML定义单例bean，你应该如例子中的写法：

<bean id="accountService" class="com.foo.DefaultAccountService"/>

<!-- the following is equivalent, though redundant (singleton scope is the default) -->
<bean id="accountService" class="com.foo.DefaultAccountService" scope="singleton"/>

原型范围

下面的例子用XML定义bean为prototype范围

<bean id="accountService" class="com.foo.DefaultAccountService" scope="prototype"/>

和其他范围不同，Spring不会管理prototype的完整的生命周期：容器初始化，配置，和另外的装配prototype 对象，分配给客户端，就不会再有这个原型实例更多的记录了。因此，尽管所有不分范围的对象都会调用初始化生命周期回调方法，对于原型bean，注册的生命周期的销毁阶段是不会被调用的。客户端代码必须清除原型范围（prototype-scoped）的对象并且释放那些被prototype Bean保持的昂贵的资源。希望Spring容器来释放被原型bean保持的对象，试一下使用自定义bean后处理（custom bean post-processor），这个后处理保持了需要被清理bean的引用。

拥有原型bean依赖的单例bean

Request范围，Session范围和global session范围

初始化web配置

<web-app>
    ...
    <listener>
        <listener-class>
            org.springframework.web.context.request.RequestContextListener
        </listener-class>
    </listener>
    ...
</web-app>

<web-app>
    ...
    <filter>
        <filter-name>requestContextFilter</filter-name>
        <filter-class>org.springframework.web.filter.RequestContextFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>requestContextFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
    ...
</web-app>

Request范围

考虑下面的Bean定义：

<bean id="loginAction" class="com.foo.LoginAction" scope="request"/>

Session范围

<bean id="userPreferences" class="com.foo.UserPreferences" scope="session"/>

Global session范围

<bean id="userPreferences" class="com.foo.UserPreferences" scope="globalSession"/>

Application范围

<bean id="appPreferences" class="com.foo.AppPreferences" scope="application"/>

 作为依赖时的Bean范围

Spring容器不仅管理你的对象（Bean）的初始化，而且连接他们之间的协作关系（或依赖）。如果你 想把一个HTTP request范围的Bean注入到另一个拥有更长的范围的Bean，你应该选择注入AOP代理而不是范围Bean。也就是，你需要注入一个和范围Bean暴露相同公共接口的代理对象，这个代理可以给实际的目标对象映射一个相同范围（例如HTTP request范围），代理实际对象的方法调用。

你还可以在singletonBean之间使用<aop:scoped-proxy/> ，通过那个引用就可以获得一个立即序列化的代理，因此也可以通过反序列化重新获取目标的singleton Bean.当声明为<aop:scoped-proxy/>而不是 prototype，每一个共享的代理的方法调用都会导致一个新的目标实例的创建，然后这个调用才会被转发。 并且，范围代理不仅仅是唯一用一种生命周期安全的方式（lifecycle-safe fashion）在短生命周期的bean中访问长声明周期bean。你也可以把你的注入点（像构造方法，setter方法或者是自动装配字段）声明为ObjectFactory<MyTargetBean>，允许在每一次需要的时候调用getObject() 方法来获取当前需要的实例，而不需要一直保持实例或者单独存储实例。这个JSR-330 的变种叫做 Provider，用一个Provider<MyTargetBean> 来声明，对于每一次获取都会调用相应的get() 方法。从这里（ here）获取更多关于JSR-330的全部细节。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!-- an HTTP Session-scoped bean exposed as a proxy -->
    <bean id="userPreferences" class="com.foo.UserPreferences" scope="session">
        <!-- instructs the container to proxy the surrounding bean -->
        <aop:scoped-proxy/>
    </bean>

    <!-- a singleton-scoped bean injected with a proxy to the above bean -->
    <bean id="userService" class="com.foo.SimpleUserService">
        <!-- a reference to the proxied userPreferences bean -->
        <property name="userPreferences" ref="userPreferences"/>
    </bean>
</beans>

<bean id="userPreferences" class="com.foo.UserPreferences" scope="session"/>

<bean id="userManager" class="com.foo.UserManager">
    <property name="userPreferences" ref="userPreferences"/>
</bean>

<bean id="userPreferences" class="com.foo.UserPreferences" scope="session">
    <aop:scoped-proxy/>
</bean>

<bean id="userManager" class="com.foo.UserManager">
    <property name="userPreferences" ref="userPreferences"/>
</bean>

	CGLIB代理仅仅拦截公共方法调用！不会调用代理的非public方法；他们也不会代理到实际的范围目标对象上。

<!-- DefaultUserPreferences implements the UserPreferences interface -->
<bean id="userPreferences" class="com.foo.DefaultUserPreferences" scope="session">
    <aop:scoped-proxy proxy-target-class="false"/>
</bean>

<bean id="userManager" class="com.foo.UserManager">
    <property name="userPreferences" ref="userPreferences"/>
</bean>

自定义范围

bean的范围机制是可拓展的；你可以定义你自己的范围，或甚至重新定义存在的范围，尽管后者认为是不好的习惯，并且你不能重写内建的singleton  prototype范围。

创建一个自定义的范围

Object get(String name, ObjectFactory objectFactory)

Object remove(String name)

void registerDestructionCallback(String name, Runnable destructionCallback)

String getConversationId()

使用自定义范围

void registerScope(String scopeName, Scope scope);

这个方法声明在ConfigurableBeanFactory 接口，它在大多通过BeanFactory装配的Spring的ApplicationContext 实现都可用。

方法的第一个参数适合范围关联的唯一的名字；例如Spring框架自己的 singleton 和 prototype范围。第二个方法参数是你希望注册和使用的实际自定范围的实例。

假设你写了下面的自定义 Scope实现，并且像下面一样注册了它。

	下面的例子用了Spring包含的SimpleThreadScope例子，但是不是默认注册的。结构应该和你自己定义的 Scope实现是一样的。

Scope threadScope = new SimpleThreadScope();
beanFactory.registerScope("thread", threadScope);

你然后通过你自定义范围规则创建一个bean的定义：

<bean id="..." class="..." scope="thread">

对于你自己的 Scope实现，你不仅可以在程序里注册，你也可以通过CustomScopeConfigurer 类注册：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">

    <bean class="org.springframework.beans.factory.config.CustomScopeConfigurer">
        <property name="scopes">
            <map>
                <entry key="thread">
                    <bean class="org.springframework.context.support.SimpleThreadScope"/>
                </entry>
            </map>
        </property>
    </bean>

    <bean id="bar" class="x.y.Bar" scope="thread">
        <property name="name" value="Rick"/>
        <aop:scoped-proxy/>
    </bean>

    <bean id="foo" class="x.y.Foo">
        <property name="bar" ref="bar"/>
    </bean>

</beans>

	当你把<aop:scoped-proxy/>放到FactoryBean 实现时，工厂bean是被在范围内的，而不是通过getObject()返回的对象。

Spring Bean的范围

标签：

原文地址：http://blog.csdn.net/z1049186181/article/details/51451019