Bean 作用域

当你创建一个 bean 定义时，你实际上是创建了一个用于创建由该 bean 定义所定义的类的实际实例的“配方”。bean 定义是“配方”这个概念非常重要，因为它意味着，就像一个类一样，你可以从一个“配方”创建许多对象实例。

你不仅可以控制要插入从特定 bean 定义创建的对象的各种依赖项和配置值，还可以控制从特定 bean 定义创建的对象的范围。这种方法功能强大且灵活，因为你可以通过配置来选择创建对象的范围，而不必在 Java 类级别硬编码对象的范围。Bean 可以被定义为部署在多种范围中的一个。Spring 框架支持六种范围，其中四种只有在使用 web 感知 ApplicationContext 时才可用。你还可以创建自定义范围。

下表描述了支持的范围

表1. Bean 作用域
作用域	描述
singleton（单例）	（默认）为每个 Spring IoC 容器将单个 bean 定义限定为单个对象实例。
prototype（原型）	将单个 bean 定义限定为任意数量的对象实例。
request（请求）	将单个 bean 定义限定为单个 HTTP 请求的生命周期。也就是说，每个 HTTP 请求都有其自己的 bean 实例，该实例根据单个 bean 定义创建。仅在 web 感知 Spring `ApplicationContext` 的上下文中有效。
session（会话）	将单个 bean 定义限定为 HTTP `Session` 的生命周期。仅在 web 感知 Spring `ApplicationContext` 的上下文中有效。
application	application（应用）
websocket	将单个 bean 定义限定为 `WebSocket` 的生命周期。仅在 web 感知 Spring `ApplicationContext` 的上下文中有效。

线程作用域可用，但默认情况下未注册。有关更多信息，请参阅 SimpleThreadScope 的文档。有关如何注册此作用域或任何其他自定义作用域的说明，请参阅使用自定义作用域。

单例作用域

只管理一个单例 bean 的共享实例，所有对与该 bean 定义匹配的 ID 的 bean 的请求都会导致 Spring 容器返回该一个特定的 bean 实例。

换句话说，当你定义一个 bean 定义并将其作用域设置为单例时，Spring IoC 容器会精确地创建由该 bean 定义定义的对象的单个实例。这个单个实例存储在此类单例 bean 的缓存中，所有后续对该命名 bean 的请求和引用都返回缓存的对象。下图显示了单例作用域的工作原理

Spring 对单例 bean 的概念与设计模式（Gang of Four (GoF) patterns）书中定义的单例模式不同。GoF 单例硬编码了对象的范围，使得每个 ClassLoader 只创建一个特定类的实例。Spring 单例的范围最好描述为“每个容器和每个 bean”。这意味着，如果你在一个 Spring 容器中为某个特定类定义了一个 bean，Spring 容器将只创建由该 bean 定义定义的类的一个实例。单例作用域是 Spring 中的默认作用域。要在 XML 中将 bean 定义为单例，你可以按以下示例所示定义 bean

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

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

原型作用域

非单例原型 bean 部署的作用域会导致每次请求该特定 bean 时都创建一个新的 bean 实例。也就是说，bean 会被注入到另一个 bean 中，或者你通过容器上的 getBean() 方法调用来请求它。通常，对于所有有状态的 bean，你应该使用原型作用域；对于无状态的 bean，则使用单例作用域。

下图展示了 Spring 原型作用域

（数据访问对象 (DAO) 通常不配置为原型，因为典型的 DAO 不持有任何会话状态。为了方便，我们重用了单例图的核心部分。）

以下示例在 XML 中将 bean 定义为原型

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

与其他作用域不同，Spring 不管理原型 bean 的完整生命周期。容器实例化、配置并组装一个原型对象并将其交给客户端，此后不再保留该原型实例的任何记录。因此，虽然无论作用域如何，所有对象都会调用初始化生命周期回调方法，但在原型的情况下，不会调用配置的销毁生命周期回调。客户端代码必须清理原型作用域的对象并释放原型 bean 持有的昂贵资源。要让 Spring 容器释放原型作用域 bean 持有的资源，可以尝试使用自定义的 bean 后处理器，该处理器持有需要清理的 bean 的引用。

在某些方面，Spring 容器对于原型作用域 bean 的作用是 Java new 运算符的替代品。此后的所有生命周期管理都必须由客户端处理。（有关 Spring 容器中 bean 生命周期详细信息，请参阅生命周期回调。）

单例 Bean 与原型 Bean 的依赖关系

当你在单例作用域 bean 中使用原型 bean 依赖项时，请注意依赖项是在实例化时解析的。因此，如果你将一个原型作用域 bean 依赖注入到单例作用域 bean 中，一个新的原型 bean 将被实例化，然后依赖注入到单例 bean 中。原型实例是唯一提供给单例作用域 bean 的实例。

然而，假设你希望单例作用域 bean 在运行时反复获取原型作用域 bean 的新实例。你不能将原型作用域 bean 依赖注入到你的单例 bean 中，因为这种注入只发生一次，即在 Spring 容器实例化单例 bean 并解析和注入其依赖项时。如果你需要在运行时多次获取原型 bean 的新实例，请参阅方法注入。

请求、会话、应用和 WebSocket 作用域

request、session、application 和 websocket 作用域仅在你使用支持 web 的 Spring ApplicationContext 实现（例如 XmlWebApplicationContext）时可用。如果你将这些作用域与常规 Spring IoC 容器（例如 ClassPathXmlApplicationContext）一起使用，则会抛出 IllegalStateException，抱怨未知 bean 作用域。

初始 Web 配置

为了支持 request、session、application 和 websocket 级别的 bean 作用域（Web 作用域 bean），在定义 bean 之前需要进行一些简单的初始配置。（对于标准作用域：singleton 和 prototype，不需要此初始设置。）

如何完成此初始设置取决于你特定的 Servlet 环境。

如果你在 Spring Web MVC 中（实际上是在 Spring DispatcherServlet 处理的请求中）访问作用域 bean，则无需特殊设置。DispatcherServlet 已经公开了所有相关状态。

如果你使用 Servlet Web 容器，并且请求在 Spring 的 DispatcherServlet 之外处理（例如，使用 JSF 时），则需要注册 org.springframework.web.context.request.RequestContextListener ServletRequestListener。这可以通过使用 WebApplicationInitializer 接口进行编程完成。或者，将以下声明添加到你的 Web 应用程序的 web.xml 文件中

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

或者，如果你的监听器设置存在问题，请考虑使用 Spring 的 RequestContextFilter。过滤器映射取决于周围的 Web 应用程序配置，因此你必须根据需要进行更改。以下列表显示了 Web 应用程序的过滤器部分

<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>

DispatcherServlet、RequestContextListener 和 RequestContextFilter 的功能完全相同，即它们将 HTTP 请求对象绑定到正在处理该请求的 Thread。这使得请求和会话作用域的 bean 在调用链中进一步可用。

请求作用域

考虑以下用于 bean 定义的 XML 配置

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

Spring 容器为每个 HTTP 请求使用 loginAction bean 定义创建一个新的 LoginAction bean 实例。也就是说，loginAction bean 的作用域在 HTTP 请求级别。你可以随意更改创建的实例的内部状态，因为从同一 loginAction bean 定义创建的其他实例不会看到这些状态更改。它们是特定于单个请求的。当请求完成处理时，限定到请求的 bean 将被丢弃。

使用注解驱动组件或 Java 配置时，可以使用 @RequestScope 注解将组件分配给 request 作用域。以下示例展示了如何实现：

Java
Kotlin

@RequestScope
@Component
public class LoginAction {
	// ...
}

@RequestScope
@Component
class LoginAction {
	// ...
}

会话作用域

考虑以下用于 bean 定义的 XML 配置

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

Spring 容器将使用 userPreferences bean 定义为单个 HTTP Session 的生命周期创建一个新的 UserPreferences bean 实例。换句话说，userPreferences bean 的作用域实际上是 HTTP Session 级别。与请求作用域 bean 一样，你可以随意更改创建的实例的内部状态，因为你知道其他 HTTP Session 实例（它们也使用从同一 userPreferences bean 定义创建的实例）不会看到这些状态更改，因为它们是特定于单个 HTTP Session 的。当 HTTP Session 最终被丢弃时，限定到该特定 HTTP Session 的 bean 也将被丢弃。

使用注解驱动组件或 Java 配置时，可以使用 @SessionScope 注解将组件分配给 session 作用域。

Java
Kotlin

@SessionScope
@Component
public class UserPreferences {
	// ...
}

@SessionScope
@Component
class UserPreferences {
	// ...
}

应用作用域

考虑以下用于 bean 定义的 XML 配置

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

Spring 容器为整个 Web 应用程序使用 appPreferences bean 定义一次性创建一个新的 AppPreferences bean 实例。也就是说，appPreferences bean 的作用域在 ServletContext 级别，并作为常规的 ServletContext 属性存储。这有点类似于 Spring 单例 bean，但在两个重要方面有所不同：它是一个 ServletContext 的单例，而不是每个 Spring ApplicationContext 的单例（在任何给定的 Web 应用程序中可能存在多个 ApplicationContext），并且它实际上是暴露的，因此作为 ServletContext 属性可见。

使用注解驱动组件或 Java 配置时，可以使用 @ApplicationScope 注解将组件分配给 application 作用域。以下示例展示了如何实现：

Java
Kotlin

@ApplicationScope
@Component
public class AppPreferences {
	// ...
}

@ApplicationScope
@Component
class AppPreferences {
	// ...
}

WebSocket 作用域

WebSocket 作用域与 WebSocket 会话的生命周期相关联，适用于基于 WebSocket 的 STOMP 应用程序，详情请参阅 WebSocket 作用域。

作为依赖项的作用域 Bean

Spring IoC 容器不仅管理对象的实例化 (beans)，还管理协作者（或依赖项）的连接。如果你想将（例如）一个 HTTP 请求作用域的 bean 注入到另一个生命周期更长的作用域的 bean 中，你可以选择注入一个 AOP 代理来代替作用域 bean。也就是说，你需要注入一个代理对象，该对象公开与作用域对象相同的公共接口，但也可以从相关作用域（例如 HTTP 请求）检索真实的目标对象并将方法调用委托给真实对象。

你还可以在作用域为 singleton 的 bean 之间使用 <aop:scoped-proxy/>，然后通过一个可序列化的中间代理进行引用，从而能够在反序列化时重新获取目标单例 bean。

当对作用域为 prototype 的 bean 声明 <aop:scoped-proxy/> 时，共享代理上的每次方法调用都会导致创建一个新的目标实例，然后将调用转发给该实例。

此外，作用域代理并非以生命周期安全的方式访问短作用域 bean 的唯一方法。你还可以将注入点（即构造函数或 setter 参数或自动装配字段）声明为 ObjectFactory<MyTargetBean>，从而允许每次需要时按需调用 getObject() 来检索当前实例 — 而无需持有实例或单独存储它。

作为一种扩展变体，你可以声明 ObjectProvider<MyTargetBean>，它提供多种额外的访问变体，包括 getIfAvailable 和 getIfUnique。

JSR-330 版本称之为 Provider，它与 Provider<MyTargetBean> 声明一起使用，并且每次检索尝试都会调用相应的 get()。有关 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
		https://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/aop
		https://www.springframework.org/schema/aop/spring-aop.xsd">

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

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

定义代理的那一行。

要创建这样一个代理，你需要在一个作用域 bean 定义中插入一个子 <aop:scoped-proxy/> 元素（请参阅选择要创建的代理类型和基于 XML Schema 的配置）。

为什么在常见场景中，在 request、session 和自定义作用域级别的 bean 定义需要 <aop:scoped-proxy/> 元素？考虑以下单例 bean 定义，并将其与你为上述作用域需要定义的进行对比（请注意，以下 userPreferences bean 定义就其本身而言是不完整的）

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

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

在前面的示例中，单例 bean (userManager) 被注入了 HTTP Session 作用域 bean (userPreferences) 的引用。这里的关键点是 userManager bean 是一个单例：它在每个容器中只实例化一次，并且它的依赖项（在这种情况下只有一个，即 userPreferences bean）也只注入一次。这意味着 userManager bean 只操作完全相同的 userPreferences 对象（即最初注入的那个）。

这不是当你将一个生命周期较短的作用域 bean 注入到生命周期较长的作用域 bean 中（例如，将一个 HTTP Session 作用域的协作 bean 作为依赖项注入到单例 bean 中）时所期望的行为。相反，你需要一个单独的 userManager 对象，并且在 HTTP Session 的生命周期内，你需要一个特定于 HTTP Session 的 userPreferences 对象。因此，容器创建一个对象，该对象公开与 UserPreferences 类完全相同的公共接口（理想情况下是一个 UserPreferences 实例），该对象可以从作用域机制（HTTP 请求、Session 等）中获取真实的 UserPreferences 对象。容器将此代理对象注入到 userManager bean 中，而 userManager bean 并不知道此 UserPreferences 引用是一个代理。在此示例中，当 UserManager 实例调用依赖注入的 UserPreferences 对象上的方法时，它实际上是在调用代理上的方法。然后，代理从（在此情况下）HTTP Session 中获取真实的 UserPreferences 对象，并将方法调用委托给检索到的真实 UserPreferences 对象。

因此，当将 request- 和 session-scoped bean 注入协作对象时，需要以下（正确且完整）配置，如以下示例所示

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

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

选择要创建的代理类型

默认情况下，当 Spring 容器为带有 <aop:scoped-proxy/> 元素标记的 bean 创建代理时，会创建一个基于 CGLIB 的类代理。

CGLIB 代理不会拦截私有方法。尝试在此类代理上调用私有方法不会委托给实际的作用域目标对象。

或者，你可以通过将 <aop:scoped-proxy/> 元素的 proxy-target-class 属性值指定为 false，来配置 Spring 容器为这些作用域 bean 创建基于标准 JDK 接口的代理。使用基于 JDK 接口的代理意味着你的应用程序类路径中不需要额外的库来影响这种代理。但是，这也意味着作用域 bean 的类必须实现至少一个接口，并且所有注入作用域 bean 的协作对象都必须通过其接口之一引用该 bean。以下示例展示了一个基于接口的代理

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

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

有关选择基于类或基于接口的代理的更详细信息，请参阅代理机制。

直接注入请求/会话引用

作为工厂作用域的替代方案，Spring WebApplicationContext 还支持将 HttpServletRequest、HttpServletResponse、HttpSession、WebRequest 和（如果存在 JSF）FacesContext 和 ExternalContext 注入到 Spring 管理的 bean 中，只需通过基于类型的自动装配，就像其他 bean 的常规注入点一样。Spring 通常会为这些请求和会话对象注入代理，其优点是也可以在单例 bean 和可序列化 bean 中工作，类似于工厂作用域 bean 的作用域代理。

自定义作用域

Bean 作用域机制是可扩展的。你可以定义自己的作用域，甚至可以重新定义现有作用域，尽管后者被认为是糟糕的做法，并且你无法覆盖内置的 singleton 和 prototype 作用域。

创建自定义作用域

要将你的自定义作用域集成到 Spring 容器中，你需要实现 org.springframework.beans.factory.config.Scope 接口，本节将对此进行描述。为了了解如何实现你自己的作用域，请参阅 Spring 框架本身提供的 Scope 实现以及 Scope 的 Javadoc，其中更详细地解释了你需要实现的方法。

Scope 接口有四种方法：从作用域中获取对象、从作用域中删除对象以及让它们被销毁。

例如，会话作用域实现返回会话作用域的 bean（如果不存在，该方法会返回一个新的 bean 实例，并在将其绑定到会话以供将来引用）。以下方法从底层作用域返回对象

Java
Kotlin

Object get(String name, ObjectFactory<?> objectFactory)

fun get(name: String, objectFactory: ObjectFactory<*>): Any

例如，会话作用域实现将从底层会话中删除会话作用域的 bean。对象应该被返回，但如果找不到指定名称的对象，你可以返回 null。以下方法从底层作用域中删除对象

Java
Kotlin

Object remove(String name)

fun remove(name: String): Any

以下方法注册一个回调，当作用域被销毁或作用域中指定对象被销毁时，作用域应调用此回调

Java
Kotlin

void registerDestructionCallback(String name, Runnable destructionCallback)

fun registerDestructionCallback(name: String, destructionCallback: Runnable)

有关销毁回调的更多信息，请参阅 Javadoc 或 Spring 作用域实现。

以下方法获取底层作用域的会话标识符

Java
Kotlin

String getConversationId()

fun getConversationId(): String

此标识符对每个作用域都不同。对于会话作用域实现，此标识符可以是会话标识符。

使用自定义作用域

在编写并测试了一个或多个自定义 Scope 实现之后，你需要让 Spring 容器知道你的新作用域。以下方法是向 Spring 容器注册新 Scope 的核心方法

Java
Kotlin

void registerScope(String scopeName, Scope scope);

fun registerScope(scopeName: String, scope: Scope)

此方法在 ConfigurableBeanFactory 接口上声明，可通过 Spring 附带的大多数具体 ApplicationContext 实现上的 BeanFactory 属性获得。

registerScope(..) 方法的第一个参数是与作用域关联的唯一名称。Spring 容器本身中的此类名称示例包括 singleton 和 prototype。registerScope(..) 方法的第二个参数是你希望注册和使用的自定义 Scope 实现的实际实例。

假设你编写了自定义 Scope 实现，然后按以下示例进行注册。

下一个示例使用 SimpleThreadScope，它包含在 Spring 中，但默认情况下未注册。你自己的自定义 Scope 实现的说明也是相同的。

Java
Kotlin

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

val threadScope = SimpleThreadScope()
beanFactory.registerScope("thread", threadScope)

然后，你可以创建符合自定义 Scope 作用域规则的 bean 定义，如下所示

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

使用自定义 Scope 实现，你不仅限于通过编程方式注册作用域。你还可以通过使用 CustomScopeConfigurer 类以声明方式进行 Scope 注册，如以下示例所示

<?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
		https://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/aop
		https://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="thing2" class="x.y.Thing2" scope="thread">
		<property name="name" value="Rick"/>
		<aop:scoped-proxy/>
	</bean>

	<bean id="thing1" class="x.y.Thing1">
		<property name="thing2" ref="thing2"/>
	</bean>

</beans>

当你在 FactoryBean 实现的 <bean> 声明中放置 <aop:scoped-proxy/> 时，是工厂 bean 本身具有作用域，而不是 getObject() 返回的对象。