`HttpSession` 集成

Spring Session 提供了与 HttpSession 的透明集成。这意味着开发者可以将 HttpSession 的实现切换为由 Spring Session 提供支持的实现。

为何选择 Spring Session 和 `HttpSession`？

我们已经提到了 Spring Session 提供了与 HttpSession 的透明集成，但这样做有什么好处呢？

集群会话：Spring Session 使得支持集群会话变得轻而易举，而无需绑定到特定的应用容器解决方案。
RESTful API：Spring Session 支持在请求头中提供会话 ID，以便与RESTful API配合使用。

使用 Redis 的 `HttpSession`

通过在任何使用 HttpSession 的代码之前添加一个 Servlet Filter，可以启用 Spring Session 与 HttpSession 的集成。您可以选择使用以下方式之一启用：

基于 Java 的配置
基于 XML 的配置

Redis 基于 Java 的配置

本节介绍如何使用基于 Java 的配置来使用 Redis 作为 HttpSession 的后端存储。

HttpSession 示例提供了一个工作示例，展示了如何使用 Java 配置集成 Spring Session 和 HttpSession。您可以在接下来的几节中阅读集成的基本步骤，但我们鼓励您在与自己的应用集成时，参考详细的 HttpSession 指南。

Spring Java 配置

添加所需的依赖后，我们可以创建 Spring 配置。Spring 配置负责创建一个 Servlet 过滤器，用 Spring Session 支持的实现替换 HttpSession 的实现。为此，添加以下 Spring 配置：

@Configuration(proxyBeanMethods = false)
@EnableRedisHttpSession (1)
public class Config {

	@Bean
	public LettuceConnectionFactory connectionFactory() {
		return new LettuceConnectionFactory(); (2)
	}

}

1	`@EnableRedisHttpSession` 注解创建一个名为 `springSessionRepositoryFilter` 的 Spring Bean，它实现了 `Filter` 接口。此过滤器负责将 `HttpSession` 的实现替换为由 Spring Session 提供支持的实现。在此示例中，Spring Session 由 Redis 提供支持。
2	我们创建一个 `RedisConnectionFactory` 来将 Spring Session 连接到 Redis 服务器。我们将连接配置为连接到默认端口 (6379) 上的 localhost。有关配置 Spring Data Redis 的更多信息，请参阅参考文档。

Java Servlet 容器初始化

我们的 Spring 配置创建了一个名为 springSessionRepositoryFilter 的 Spring Bean，它实现了 Filter 接口。springSessionRepositoryFilter Bean 负责将 HttpSession 替换为由 Spring Session 提供支持的自定义实现。

为了让我们的 Filter 起作用，Spring 需要加载我们的 Config 类。最后，我们需要确保我们的 Servlet 容器（即 Tomcat）对每个请求都使用我们的 springSessionRepositoryFilter。幸运的是，Spring Session 提供了一个名为 AbstractHttpSessionApplicationInitializer 的工具类，可以轻松完成这两个步骤。以下示例展示了如何做到这一点：

src/main/java/sample/Initializer.java

public class Initializer extends AbstractHttpSessionApplicationInitializer { (1)

	public Initializer() {
		super(Config.class); (2)
	}

}

我们的类名（Initializer）无关紧要。重要的是我们要扩展 AbstractHttpSessionApplicationInitializer。

1	第一步是扩展 `AbstractHttpSessionApplicationInitializer`。这样做可以确保名为 `springSessionRepositoryFilter` 的 Spring Bean 已注册到我们的 Servlet 容器中，用于处理每个请求。
2	`AbstractHttpSessionApplicationInitializer` 还提供了一种机制来确保 Spring 加载我们的 `Config`。

Redis 基于 XML 的配置

本节介绍如何使用基于 XML 的配置来使用 Redis 作为 HttpSession 的后端存储。

HttpSession XML 示例提供了一个工作示例，展示了如何使用 XML 配置集成 Spring Session 和 HttpSession。您可以在接下来的几节中阅读集成的基本步骤，但我们鼓励您在与自己的应用集成时，参考详细的 HttpSession XML 指南。

Spring XML 配置

src/main/webapp/WEB-INF/spring/session.xml

(1)
<context:annotation-config/>
<bean class="org.springframework.session.data.redis.config.annotation.web.http.RedisHttpSessionConfiguration"/>

(2)
<bean class="org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory"/>

1 我们结合使用 <context:annotation-config/> 和 RedisHttpSessionConfiguration，因为 Spring Session 尚未提供 XML Namespace 支持（参见 gh-104）。这将创建一个名为 springSessionRepositoryFilter 的 Spring Bean，它实现了 Filter 接口。此过滤器负责将 HttpSession 的实现替换为由 Spring Session 提供支持的实现。在此示例中，Spring Session 由 Redis 提供支持。

2 我们创建一个 RedisConnectionFactory 来将 Spring Session 连接到 Redis 服务器。我们将连接配置为连接到默认端口 (6379) 上的 localhost。有关配置 Spring Data Redis 的更多信息，请参阅参考文档。

XML Servlet 容器初始化

为了让我们的 Filter 起作用，我们需要指示 Spring 加载我们的 session.xml 配置。我们可以通过以下配置来完成：

src/main/webapp/WEB-INF/web.xml

<context-param>
	<param-name>contextConfigLocation</param-name>
	<param-value>
		/WEB-INF/spring/session.xml
	</param-value>
</context-param>
<listener>
	<listener-class>
		org.springframework.web.context.ContextLoaderListener
	</listener-class>
</listener>

ContextLoaderListener 读取 contextConfigLocation 并加载我们的 session.xml 配置。

最后，我们需要确保我们的 Servlet 容器（即 Tomcat）对每个请求都使用我们的 springSessionRepositoryFilter。以下代码片段为我们完成了最后一步：

src/main/webapp/WEB-INF/web.xml

<filter>
	<filter-name>springSessionRepositoryFilter</filter-name>
	<filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
</filter>
<filter-mapping>
	<filter-name>springSessionRepositoryFilter</filter-name>
	<url-pattern>/*</url-pattern>
	<dispatcher>REQUEST</dispatcher>
	<dispatcher>ERROR</dispatcher>
</filter-mapping>

DelegatingFilterProxy 通过名称 springSessionRepositoryFilter 查找一个 Bean 并将其转换为 Filter。对于 DelegatingFilterProxy 被调用的每个请求，springSessionRepositoryFilter 都会被调用。

使用 Mongo 的 HttpSession

通过在任何使用 HttpSession 的代码之前添加一个 Servlet Filter，可以启用 Spring Session 与 HttpSession 的集成。

本节介绍如何使用基于 Java 的配置来使用 Mongo 作为 HttpSession 的后端存储。

HttpSession Mongo 示例提供了一个工作示例，展示了如何使用 Java 配置集成 Spring Session 和 HttpSession。您可以在下方阅读集成的基本步骤，但我们鼓励您在与自己的应用集成时，参考详细的 HttpSession 指南。

您只需添加以下 Spring 配置：

@Configuration(proxyBeanMethods = false)
@EnableMongoHttpSession (1)
public class HttpSessionConfig {

	@Bean
	public JdkMongoSessionConverter jdkMongoSessionConverter() {
		return new JdkMongoSessionConverter(Duration.ofMinutes(30)); (2)
	}

}

1	`@EnableMongoHttpSession` 注解创建一个名为 `springSessionRepositoryFilter` 的 Spring Bean，它实现了 Filter 接口。此过滤器将默认的 `HttpSession` 替换为由 MongoDB 支持的 Bean。
2	将会话超时配置为 30 分钟。

会话序列化机制

为了能够在 MongoDB 中持久化会话对象，我们需要提供序列化/反序列化机制。

默认情况下，Spring Session MongoDB 将使用 JdkMongoSessionConverter。

但是，您可以通过简单地在您的 Boot 应用中添加以下代码来切换到 JacksonMongoSessionConverter：

@Bean
JacksonMongoSessionConverter mongoSessionConverter() {
    return new JacksonMongoSessionConverter();
}

JacksonMongoSessionConverter

此机制使用 Jackson 将会话对象序列化为 JSON 或从 JSON 反序列化。

通过创建以下 Bean：

@Bean
JacksonMongoSessionConverter mongoSessionConverter() {
    return new JacksonMongoSessionConverter();
}

…您就可以从默认（基于 JDK 的序列化）切换到使用 Jackson。

如果您正在与 Spring Security 集成（通过将您的会话存储在 MongoDB 中），此配置将注册适当的白名单组件，以便 Spring Security 正常工作。

如果您想提供自定义 Jackson 模块，可以通过显式注册模块来完成，如下所示：

Unresolved include directive in modules/ROOT/pages/http-session.adoc - include::example$spring-session-data-mongodb-dir/src/integration-test/java/org/springframework/session/data/mongo/integration/MongoRepositoryJacksonITest.java[]

JdkMongoSessionConverter

JdkMongoSessionConverter 使用标准的 Java 序列化将会话属性映射以二进制形式持久化到 MongoDB。然而，标准的会话元素（如 ID、访问时间等）仍然以纯 Mongo 对象形式写入，无需额外工作即可读取和查询。如果未定义显式的 AbstractMongoSessionConverter Bean，则使用 JdkMongoSessionConverter。

还有一个接受 Serializer 和 Deserializer 对象的构造函数，允许您传递自定义实现，这在使用非默认类加载器时尤其重要。

使用 JDBC 的 `HttpSession`

通过在任何使用 HttpSession 的代码之前添加一个 Servlet 过滤器，您可以使用 Spring Session 与 HttpSession。您可以通过以下任何一种方式进行：

基于 Java 的配置
基于 XML 的配置
基于 Spring Boot 的配置

JDBC 基于 Java 的配置

本节介绍如何在使用基于 Java 的配置时，使用关系型数据库作为 HttpSession 的后端存储。

HttpSession JDBC 示例提供了一个工作示例，展示了如何使用 Java 配置集成 Spring Session 和 HttpSession。您可以在接下来的几节中阅读集成的基本步骤，但我们鼓励您在与自己的应用集成时，参考详细的 HttpSession JDBC 指南。

Spring Java 配置

@Configuration(proxyBeanMethods = false)
@EnableJdbcHttpSession (1)
public class Config {

	@Bean
	public EmbeddedDatabase dataSource() {
		return new EmbeddedDatabaseBuilder() (2)
			.setType(EmbeddedDatabaseType.H2)
			.addScript("org/springframework/session/jdbc/schema-h2.sql")
			.build();
	}

	@Bean
	public PlatformTransactionManager transactionManager(DataSource dataSource) {
		return new DataSourceTransactionManager(dataSource); (3)
	}

}

1	`@EnableJdbcHttpSession` 注解创建一个名为 `springSessionRepositoryFilter` 的 Spring Bean。该 Bean 实现了 `Filter` 接口。此过滤器负责将 `HttpSession` 的实现替换为由 Spring Session 提供支持的实现。在此示例中，Spring Session 由关系型数据库提供支持。
2	我们创建一个 `dataSource` 来将 Spring Session 连接到 H2 数据库的嵌入式实例。我们将 H2 数据库配置为使用 Spring Session 中包含的 SQL 脚本创建数据库表。
3	我们创建一个 `transactionManager` 来管理先前配置的 `dataSource` 的事务。

有关如何配置数据访问相关内容的更多信息，请参阅 Spring Framework 参考文档。

Java Servlet 容器初始化

src/main/java/sample/Initializer.java

public class Initializer extends AbstractHttpSessionApplicationInitializer { (1)

	public Initializer() {
		super(Config.class); (2)
	}

}

我们的类名（Initializer）无关紧要。重要的是我们要扩展 AbstractHttpSessionApplicationInitializer。

1	第一步是扩展 `AbstractHttpSessionApplicationInitializer`。这样做可以确保名为 `springSessionRepositoryFilter` 的 Spring Bean 已注册到我们的 Servlet 容器中，用于处理每个请求。
2	`AbstractHttpSessionApplicationInitializer` 还提供了一种机制来确保 Spring 加载我们的 `Config`。

多个 DataSource

Spring Session 提供了 @SpringSessionDataSource 限定符，允许您明确声明应将哪个 DataSource Bean 注入到 JdbcIndexedSessionRepository 中。这在应用程序上下文中存在多个 DataSource Bean 的场景中特别有用。

以下示例展示了如何做到这一点：

Config.java

@EnableJdbcHttpSession
public class Config {

	@Bean
	@SpringSessionDataSource (1)
	public EmbeddedDatabase firstDataSource() {
		return new EmbeddedDatabaseBuilder()
				.setType(EmbeddedDatabaseType.H2).addScript("org/springframework/session/jdbc/schema-h2.sql").build();
	}

	@Bean
	public HikariDataSource secondDataSource() {
		// ...
	}
}

1	此限定符声明 `firstDataSource` 将被 Spring Session 使用。

JDBC 基于 XML 的配置

本节介绍如何在使用基于 XML 的配置时，使用关系型数据库作为 HttpSession 的后端存储。

HttpSession JDBC XML 示例提供了一个工作示例，展示了如何使用 XML 配置集成 Spring Session 和 HttpSession。您可以在接下来的几节中阅读集成的基本步骤，但我们鼓励您在与自己的应用集成时，参考详细的 HttpSession JDBC XML 指南。

Spring XML 配置

添加所需的依赖后，我们可以创建 Spring 配置。Spring 配置负责创建一个 Servlet 过滤器，用 Spring Session 支持的实现替换 HttpSession 的实现。以下清单展示了如何添加以下 Spring 配置：

src/main/webapp/WEB-INF/spring/session.xml

(1)
<context:annotation-config/>
<bean class="org.springframework.session.jdbc.config.annotation.web.http.JdbcHttpSessionConfiguration"/>

(2)
<jdbc:embedded-database id="dataSource" database-name="testdb" type="H2">
	<jdbc:script location="classpath:org/springframework/session/jdbc/schema-h2.sql"/>
</jdbc:embedded-database>

(3)
<bean class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
	<constructor-arg ref="dataSource"/>
</bean>

1	我们结合使用 `<context:annotation-config/>` 和 `JdbcHttpSessionConfiguration`，因为 Spring Session 尚未提供 XML Namespace 支持（参见 gh-104）。这将创建一个名为 `springSessionRepositoryFilter` 的 Spring Bean。该 Bean 实现了 `Filter` 接口。此过滤器负责将 `HttpSession` 的实现替换为由 Spring Session 提供支持的实现。在此示例中，Spring Session 由关系型数据库提供支持。
2	我们创建一个 `dataSource` 来将 Spring Session 连接到 H2 数据库的嵌入式实例。我们将 H2 数据库配置为使用 Spring Session 中包含的 SQL 脚本创建数据库表。
3	我们创建一个 `transactionManager` 来管理先前配置的 `dataSource` 的事务。

有关如何配置数据访问相关内容的更多信息，请参阅 Spring Framework 参考文档。

XML Servlet 容器初始化

为了让我们的 Filter 起作用，我们需要指示 Spring 加载我们的 session.xml 配置。我们可以通过以下配置来完成：

src/main/webapp/WEB-INF/web.xml

<context-param>
	<param-name>contextConfigLocation</param-name>
	<param-value>
		/WEB-INF/spring/session.xml
	</param-value>
</context-param>
<listener>
	<listener-class>
		org.springframework.web.context.ContextLoaderListener
	</listener-class>
</listener>

ContextLoaderListener 读取 contextConfigLocation 并加载我们的 session.xml 配置。

最后，我们需要确保我们的 Servlet 容器（即 Tomcat）对每个请求都使用我们的 springSessionRepositoryFilter。以下代码片段为我们完成了最后一步：

src/main/webapp/WEB-INF/web.xml

<filter>
	<filter-name>springSessionRepositoryFilter</filter-name>
	<filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
</filter>
<filter-mapping>
	<filter-name>springSessionRepositoryFilter</filter-name>
	<url-pattern>/*</url-pattern>
	<dispatcher>REQUEST</dispatcher>
	<dispatcher>ERROR</dispatcher>
</filter-mapping>

DelegatingFilterProxy 查找名为 springSessionRepositoryFilter 的 Bean 并将其转换为 Filter。对于 DelegatingFilterProxy 被调用的每个请求，springSessionRepositoryFilter 都会被调用。

JDBC 基于 Spring Boot 的配置

本节介绍如何在您使用 Spring Boot 时，使用关系型数据库作为 HttpSession 的后端存储。

HttpSession JDBC Spring Boot 示例提供了一个工作示例，展示了如何使用 Spring Boot 集成 Spring Session 和 HttpSession。您可以在接下来的几节中阅读集成的基本步骤，但我们鼓励您在与自己的应用集成时，参考详细的 HttpSession JDBC Spring Boot 指南。

Spring Boot 配置

添加所需的依赖后，我们可以创建 Spring Boot 配置。得益于一流的自动配置支持，只需添加依赖项，Spring Boot 就会为我们设置一个由关系型数据库支持的 Spring Session。

如果类路径上只有一个 Spring Session 模块，Spring Boot 会自动使用该存储实现。如果您有多个实现，您必须选择要用于存储会话的 StoreType，如上所示。

在底层，Spring Boot 应用的配置等同于手动添加 @EnableJdbcHttpSession 注解。这将创建一个名为 springSessionRepositoryFilter 的 Spring Bean。该 Bean 实现了 Filter 接口。此过滤器负责将 HttpSession 的实现替换为由 Spring Session 提供支持的实现。

您可以通过使用 application.properties 进行进一步自定义。以下清单展示了如何做到这一点：

src/main/resources/application.properties

server.servlet.session.timeout= # Session timeout. If a duration suffix is not specified, seconds are used.
spring.session.jdbc.initialize-schema=embedded # Database schema initialization mode.
spring.session.jdbc.schema=classpath:org/springframework/session/jdbc/schema-@@platform@@.sql # Path to the SQL file to use to initialize the database schema.
spring.session.jdbc.table-name=SPRING_SESSION # Name of the database table used to store sessions.

有关更多信息，请参阅 Spring Boot 文档中的 Spring Session 部分。

配置 `DataSource`

Spring Boot 自动创建一个 DataSource，将 Spring Session 连接到 H2 数据库的嵌入式实例。在生产环境中，您需要更新配置以指向您的关系型数据库。例如，您可以在 application.properties 中包含以下内容：

src/main/resources/application.properties

spring.datasource.url= # JDBC URL of the database.
spring.datasource.username= # Login username of the database.
spring.datasource.password= # Login password of the database.

有关更多信息，请参阅 Spring Boot 文档中的配置 DataSource 部分。

Servlet 容器初始化

我们的 Spring Boot 配置创建了一个名为 springSessionRepositoryFilter 的 Spring Bean，它实现了 Filter 接口。springSessionRepositoryFilter Bean 负责将 HttpSession 替换为由 Spring Session 提供支持的自定义实现。

为了让我们的 Filter 起作用，Spring 需要加载我们的 Config 类。最后，我们需要确保我们的 Servlet 容器（即 Tomcat）对每个请求都使用我们的 springSessionRepositoryFilter。幸运的是，Spring Boot 为我们处理了这两个步骤。

使用 Hazelcast 的 HttpSession

通过在任何使用 HttpSession 的代码之前添加一个 Servlet Filter，可以启用 Spring Session 与 HttpSession 的集成。

本节介绍如何使用基于 Java 的配置来使用 Hazelcast 作为 HttpSession 的后端存储。

Hazelcast Spring 示例提供了一个工作示例，展示了如何使用 Java 配置集成 Spring Session 和 HttpSession。您可以在接下来的几节中阅读集成的基本步骤，但我们鼓励您在与自己的应用集成时，参考详细的 Hazelcast Spring 指南。

Spring 配置

@EnableHazelcastHttpSession (1)
@Configuration
public class HazelcastHttpSessionConfig {

	@Bean
	public HazelcastInstance hazelcastInstance() {
		Config config = new Config();
		AttributeConfig attributeConfig = new AttributeConfig()
			.setName(HazelcastIndexedSessionRepository.PRINCIPAL_NAME_ATTRIBUTE)
			.setExtractorClassName(PrincipalNameExtractor.class.getName());
		config.getMapConfig(HazelcastIndexedSessionRepository.DEFAULT_SESSION_MAP_NAME) (2)
			.addAttributeConfig(attributeConfig)
			.addIndexConfig(
					new IndexConfig(IndexType.HASH, HazelcastIndexedSessionRepository.PRINCIPAL_NAME_ATTRIBUTE));
		SerializerConfig serializerConfig = new SerializerConfig();
		serializerConfig.setImplementation(new HazelcastSessionSerializer()).setTypeClass(MapSession.class);
		config.getSerializationConfig().addSerializerConfig(serializerConfig); (3)
		return Hazelcast.newHazelcastInstance(config); (4)
	}

}

1	`@EnableHazelcastHttpSession` 注解创建一个名为 `springSessionRepositoryFilter` 的 Spring Bean，它实现了 `Filter` 接口。此过滤器负责将 `HttpSession` 的实现替换为由 Spring Session 提供支持的实现。在此示例中，Spring Session 由 Hazelcast 提供支持。
2	为了支持按主体名称索引检索会话，需要注册适当的 `ValueExtractor`。Spring Session 为此提供了 `PrincipalNameExtractor`。
3	为了高效地序列化 `MapSession` 对象，需要注册 `HazelcastSessionSerializer`。如果未设置此项，Hazelcast 将使用原生 Java 序列化来序列化会话。
4	我们创建一个 `HazelcastInstance` 来将 Spring Session 连接到 Hazelcast。默认情况下，应用程序启动并连接到 Hazelcast 的嵌入式实例。有关配置 Hazelcast 的更多信息，请参阅参考文档。

如果首选 HazelcastSessionSerializer，则需要在所有 Hazelcast 集群成员启动之前为其配置。在 Hazelcast 集群中，所有成员应使用相同的会话序列化方法。此外，如果使用 Hazelcast 客户端/服务器拓扑，则成员和客户端都必须使用相同的序列化方法。可以通过 ClientConfig 注册序列化器，并使用成员相同的 SerializerConfiguration。

Servlet 容器初始化

为了让我们的 Filter 起作用，Spring 需要加载我们的 SessionConfig 类。由于我们的应用程序已经使用 SecurityInitializer 类加载 Spring 配置，我们可以将 SessionConfig 类添加到其中。以下清单展示了如何做到这一点：

src/main/java/sample/SecurityInitializer.java

public class SecurityInitializer extends AbstractSecurityWebApplicationInitializer {

	public SecurityInitializer() {
		super(SecurityConfig.class, SessionConfig.class);
	}

}

最后，我们需要确保我们的 Servlet 容器（即 Tomcat）对每个请求都使用我们的 springSessionRepositoryFilter。至关重要的是，Spring Session 的 springSessionRepositoryFilter 必须在 Spring Security 的 springSecurityFilterChain 之前被调用。这样做可以确保 Spring Security 使用的 HttpSession 由 Spring Session 提供支持。幸运的是，Spring Session 提供了一个名为 AbstractHttpSessionApplicationInitializer 的工具类，可以轻松完成此操作。以下示例展示了如何做到这一点：

src/main/java/sample/Initializer.java

public class Initializer extends AbstractHttpSessionApplicationInitializer {

}

我们的类名（Initializer）无关紧要。重要的是我们要扩展 AbstractHttpSessionApplicationInitializer。

通过扩展 AbstractHttpSessionApplicationInitializer，我们可以确保名为 springSessionRepositoryFilter 的 Spring Bean 在 Spring Security 的 springSecurityFilterChain 之前注册到我们的 Servlet 容器中，用于处理每个请求。

`HttpSession` 集成的工作原理

幸运的是，HttpSession 和 HttpServletRequest（获取 HttpSession 的 API）都是接口。这意味着我们可以为这些 API 中的每一个提供自己的实现。

本节描述了 Spring Session 如何提供与 HttpSession 的透明集成。我们提供此内容是为了让您了解底层发生的事情。此功能已集成，您无需自己实现此逻辑。

首先，我们创建一个自定义的 HttpServletRequest，它返回一个自定义的 HttpSession 实现。它看起来像这样：

public class SessionRepositoryRequestWrapper extends HttpServletRequestWrapper {

	public SessionRepositoryRequestWrapper(HttpServletRequest original) {
		super(original);
	}

	public HttpSession getSession() {
		return getSession(true);
	}

	public HttpSession getSession(boolean createNew) {
		// create an HttpSession implementation from Spring Session
	}

	// ... other methods delegate to the original HttpServletRequest ...
}

任何返回 HttpSession 的方法都被重写。所有其他方法都由 HttpServletRequestWrapper 实现，并委托给原始的 HttpServletRequest 实现。

我们通过使用一个名为 SessionRepositoryFilter 的 Servlet 过滤器来替换 HttpServletRequest 的实现。以下伪代码展示了其工作原理：

public class SessionRepositoryFilter implements Filter {

	public doFilter(ServletRequest request, ServletResponse response, FilterChain chain) {
		HttpServletRequest httpRequest = (HttpServletRequest) request;
		SessionRepositoryRequestWrapper customRequest =
			new SessionRepositoryRequestWrapper(httpRequest);

		chain.doFilter(customRequest, response, chain);
	}

	// ...
}

通过将自定义的 HttpServletRequest 实现传递到 FilterChain 中，我们确保在我们的 Filter 之后调用的任何内容都使用自定义的 HttpSession 实现。这突出了为什么将 Spring Session 的 SessionRepositoryFilter 放在任何与 HttpSession 交互的代码之前非常重要。

`HttpSession` 和 RESTful API

Spring Session 可以通过允许在请求头中提供会话来与 RESTful API 配合使用。

REST 示例提供了一个工作示例，展示了如何在 REST 应用程序中使用 Spring Session 来支持通过请求头进行身份验证。您可以按照接下来的几节中描述的基本集成步骤进行操作，但我们鼓励您在与自己的应用程序集成时，参考详细的 REST 指南。

Spring 配置

@Configuration
@EnableRedisHttpSession (1)
public class HttpSessionConfig {

	@Bean
	public LettuceConnectionFactory connectionFactory() {
		return new LettuceConnectionFactory(); (2)
	}

	@Bean
	public HttpSessionIdResolver httpSessionIdResolver() {
		return HeaderHttpSessionIdResolver.xAuthToken(); (3)
	}

}

1	`@EnableRedisHttpSession` 注解创建一个名为 `springSessionRepositoryFilter` 的 Spring Bean，它实现了 `Filter` 接口。此过滤器负责将 `HttpSession` 的实现替换为由 Spring Session 提供支持的实现。在此示例中，Spring Session 由 Redis 提供支持。
2	我们创建一个 `RedisConnectionFactory` 来将 Spring Session 连接到 Redis 服务器。我们将连接配置为连接到默认端口 (6379) 上的 localhost。有关配置 Spring Data Redis 的更多信息，请参阅参考文档。
3	我们自定义 Spring Session 的 HttpSession 集成，使其使用 HTTP 请求头而不是 Cookie 来传递当前会话信息。

Servlet 容器初始化

为了让我们的 Filter 起作用，Spring 需要加载我们的 Config 类。我们在 Spring MvcInitializer 中提供了配置，如下示例所示：

src/main/java/sample/mvc/MvcInitializer.java

@Override
protected Class<?>[] getRootConfigClasses() {
	return new Class[] { SecurityConfig.class, HttpSessionConfig.class };
}

最后，我们需要确保我们的 Servlet 容器（即 Tomcat）对每个请求都使用我们的 springSessionRepositoryFilter。幸运的是，Spring Session 提供了一个名为 AbstractHttpSessionApplicationInitializer 的工具类，可以轻松完成此操作。为此，可以使用默认构造函数扩展该类，如下示例所示：

src/main/java/sample/Initializer.java

public class Initializer extends AbstractHttpSessionApplicationInitializer {

}

我们的类名（Initializer）无关紧要。重要的是我们要扩展 AbstractHttpSessionApplicationInitializer。

使用 `HttpSessionListener`

Spring Session 通过声明 SessionEventHttpSessionListenerAdapter 并将 SessionDestroyedEvent 和 SessionCreatedEvent 转换为 HttpSessionEvent 来支持 HttpSessionListener。要使用此支持，您需要：

确保您的 SessionRepository 实现支持并配置为触发 SessionDestroyedEvent 和 SessionCreatedEvent。
将 SessionEventHttpSessionListenerAdapter 配置为 Spring Bean。
将每个 HttpSessionListener 注入到 SessionEventHttpSessionListenerAdapter 中。

如果您使用 Redis 支持并将 enableIndexingAndEvents 设置为 true，即 @EnableRedisHttpSession(enableIndexingAndEvents = true)，您只需将每个 HttpSessionListener 注册为 Bean。例如，假设您想支持 Spring Security 的并发控制并需要使用 HttpSessionEventPublisher。在这种情况下，您可以将 HttpSessionEventPublisher 添加为一个 Bean。在 Java 配置中，这可能如下所示：

@Configuration
@EnableRedisHttpSession
public class RedisHttpSessionConfig {

	@Bean
	public HttpSessionEventPublisher httpSessionEventPublisher() {
		return new HttpSessionEventPublisher();
	}

	// ...

}

在 XML 配置中，这可能如下所示：

<bean class="org.springframework.security.web.session.HttpSessionEventPublisher"/>

HttpSession 集成

为何选择 Spring Session 和 HttpSession？

使用 Redis 的 HttpSession

Redis 基于 Java 的配置

Spring Java 配置

Java Servlet 容器初始化

Redis 基于 XML 的配置

Spring XML 配置

XML Servlet 容器初始化

使用 Mongo 的 HttpSession

会话序列化机制

JacksonMongoSessionConverter

JdkMongoSessionConverter

使用 JDBC 的 HttpSession

JDBC 基于 Java 的配置

Spring Java 配置

Java Servlet 容器初始化

多个 DataSource

JDBC 基于 XML 的配置

Spring XML 配置

XML Servlet 容器初始化

JDBC 基于 Spring Boot 的配置

Spring Boot 配置

配置 DataSource

Servlet 容器初始化

使用 Hazelcast 的 HttpSession

Spring 配置

Servlet 容器初始化

HttpSession 集成的工作原理

HttpSession 和 RESTful API

Spring 配置

Servlet 容器初始化

使用 HttpSessionListener

`HttpSession` 集成

为何选择 Spring Session 和 `HttpSession`？

使用 Redis 的 `HttpSession`

使用 JDBC 的 `HttpSession`

配置 `DataSource`

`HttpSession` 集成的工作原理

`HttpSession` 和 RESTful API

使用 `HttpSessionListener`