HttpSession集成

Spring Session 提供与 . 这意味着开发人员可以使用 Spring Session 支持的实现来切换实现。HttpSessionHttpSessionspring-doc.cn

为什么选择 Spring Session 和 ？HttpSession

我们已经提到 Spring Session 提供了与 的透明集成，但是我们从中得到了什么好处呢？HttpSessionspring-doc.cn

  • 集群会话：Spring Session 使支持集群会话变得轻而易举，而无需绑定到特定于应用程序容器的解决方案。spring-doc.cn

  • RESTful API：Spring Session 允许在标头中提供会话 ID 与 RESTful API 一起使用spring-doc.cn

HttpSession使用 Redis

通过在使用 . 您可以使用以下任一方式选择启用此功能：HttpSessionHttpSessionspring-doc.cn

Redis 基于 Java 的配置

本节介绍如何使用基于 Java 的配置使用 Redis 进行备份。HttpSessionspring-doc.cn

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

Spring Java 配置

添加所需的依赖项后，我们可以创建 Spring 配置。 Spring 配置负责创建一个 servlet 过滤器，该过滤器将实现替换为 Spring Session 支持的实现。 为此，请添加以下 Spring Configuration：HttpSessionspring-doc.cn

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

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

}
1 该注释将创建一个名为 实现 的 Spring Bean。 过滤器负责替换 Spring Session 支持的实现。 在这种情况下， Spring Session 由 Redis 提供支持。@EnableRedisHttpSessionspringSessionRepositoryFilterFilterHttpSession
2 我们创建一个将 Spring Session 连接到 Redis 服务器。 我们将连接配置为连接到默认端口 （6379） 上的 localhost。 有关配置 Spring Data Redis 的更多信息，请参阅参考文档。RedisConnectionFactory

Java Servlet 容器初始化

我们的 Spring 配置创建了一个名为 的 Spring Bean，它实现了 . 该 bean 负责将 替换为由 Spring Session 支持的自定义实现。springSessionRepositoryFilterFilterspringSessionRepositoryFilterHttpSessionspring-doc.cn

为了让我们发挥它的魔力， Spring 需要加载我们的 class。 最后，我们需要确保我们的 Servlet 容器（即 Tomcat）对每个请求都使用我们的容器。 幸运的是，Spring Session 提供了一个名为 的实用程序类，使这两个步骤都变得容易。 示例如下：FilterConfigspringSessionRepositoryFilterAbstractHttpSessionApplicationInitializerspring-doc.cn

来源/main/java/sample/Initializer.java
public class Initializer extends AbstractHttpSessionApplicationInitializer { (1)

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

}
类的名称 （） 无关紧要。重要的是，我们将 .InitializerAbstractHttpSessionApplicationInitializer
1 第一步是扩展 . 这样做可以确保 name 的 Spring Bean 在每个请求的 Servlet 容器中注册。AbstractHttpSessionApplicationInitializerspringSessionRepositoryFilter
2 AbstractHttpSessionApplicationInitializer还提供了一种机制来确保 Spring 加载我们的 .Config

Redis 基于 XML 的配置

本节介绍如何使用基于 XML 的配置来使用 Redis 进行备份。HttpSessionspring-doc.cn

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

Spring XML 配置

添加所需的依赖项后，我们可以创建 Spring 配置。 Spring 配置负责创建一个 servlet 过滤器，该过滤器将实现替换为 Spring Session 支持的实现。 为此，请添加以下 Spring Configuration：HttpSessionspring-doc.cn

来源/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 我们使用 和 的组合，因为 Spring Session 尚不提供 XML 命名空间支持（参见 gh-104）。 这将创建一个名为 的 Spring Bean，该 implements . 过滤器负责替换 Spring Session 支持的实现。 在这种情况下， Spring Session 由 Redis 提供支持。<context:annotation-config/>RedisHttpSessionConfigurationspringSessionRepositoryFilterFilterHttpSession
2 我们创建一个将 Spring Session 连接到 Redis 服务器。 我们将连接配置为连接到默认端口上的 localhost （6379） 有关配置 Spring Data Redis 的更多信息，请参阅参考文档。RedisConnectionFactory

XML Servlet 容器初始化

我们的 Spring 配置创建了一个名为 的 Spring Bean，它实现了 . 该 bean 负责将 替换为由 Spring Session 支持的自定义实现。springSessionRepositoryFilterFilterspringSessionRepositoryFilterHttpSessionspring-doc.cn

为了让我们发挥它的魔力，我们需要指示 Spring 加载我们的配置。 我们可以使用以下配置来做到这一点：Filtersession.xmlspring-doc.cn

来源/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配置。spring-doc.cn

最后，我们需要确保我们的 Servlet 容器（即 Tomcat）对每个请求都使用我们的容器。 以下代码片段为我们执行了最后一步：springSessionRepositoryFilterspring-doc.cn

来源/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 按名称查找 Bean 并将其转换为 . 对于调用的每个请求，都会调用 the 。springSessionRepositoryFilterFilterDelegatingFilterProxyspringSessionRepositoryFilterspring-doc.cn

使用 Mongo 的 HttpSession

通过在使用 .HttpSessionHttpSessionspring-doc.cn

本节介绍如何使用 Mongo 来支持基于 Java 的配置。HttpSessionspring-doc.cn

HttpSession Mongo 示例提供了有关如何集成 Spring Session 和使用 Java 配置的工作示例。 您可以阅读下面的集成基本步骤，但建议您在与自己的应用程序集成时遵循详细的 HttpSession 指南。HttpSession

您所要做的就是添加以下 Spring Configuration：spring-doc.cn

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

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

}
1 该 Comments 会创建一个 Spring Bean，其名称为 implements Filter。 此过滤器是将 default 替换为 MongoDB 支持的 bean 的过滤器。@EnableMongoHttpSessionspringSessionRepositoryFilterHttpSession
2 将会话超时配置为 30 分钟。

会话序列化机制

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

默认情况下，Spring Session MongoDB 将使用 .JdkMongoSessionConverterspring-doc.cn

但是，您只需将以下代码添加到 Boot 应用程序即可切换到：JacksonMongoSessionConverterspring-doc.cn

@Bean
JacksonMongoSessionConverter mongoSessionConverter() {
    return new JacksonMongoSessionConverter();
}
JacksonMongoSession转换器

此机制使用 Jackson 将会话对象序列化为 JSON 或从 JSON 序列化会话对象。spring-doc.cn

通过创建以下 Bean：spring-doc.cn

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

…​您可以从默认（基于 JDK 的序列化）切换到使用 Jackson。spring-doc.cn

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

如果您想提供自定义 Jackson 模块，您可以通过显式注册模块来实现，如下所示：spring-doc.cn

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[]
JdkMongoSession转换器

JdkMongoSessionConverter使用标准 Java 序列化以二进制形式保留到 MongoDB 的会话属性映射。 但是，id 、 access time 等标准 session 元素仍然作为普通的 Mongo 对象写入，无需额外工作即可读取和查询。 如果未定义显式 Bean，则使用。JdkMongoSessionConverterAbstractMongoSessionConverterspring-doc.cn

还有一个构造函数 taking 和 objects，允许你传递自定义实现，这在你想使用非默认 classloader 时尤其重要。SerializerDeserializerspring-doc.cn

HttpSession使用 JDBC

您可以通过在使用 . 您可以选择通过以下任一方式执行：HttpSessionHttpSessionspring-doc.cn

基于 Java 的 JDBC 配置

本节介绍在使用基于 Java 的配置时如何使用关系数据库进行备份。HttpSessionspring-doc.cn

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

Spring Java 配置

添加所需的依赖项后，我们可以创建 Spring 配置。 Spring 配置负责创建一个 Servlet Filter，该 Servlet Filter 将实现替换为 Spring Session 支持的实现。 为此，请添加以下 Spring Configuration：HttpSessionspring-doc.cn

@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 该注解将创建一个名为 的 Spring Bean。 该 bean 实现 . 过滤器负责替换 Spring Session 支持的实现。 在这种情况下， Spring Session 由关系数据库提供支持。@EnableJdbcHttpSessionspringSessionRepositoryFilterFilterHttpSession
2 我们创建一个将 Spring Session 连接到 H2 数据库的嵌入式实例。 我们将 H2 数据库配置为使用 Spring Session 中包含的 SQL 脚本创建数据库表。dataSource
3 我们创建一个管理以前配置的事务的 .transactionManagerdataSource

有关如何配置数据访问相关关注点的更多信息，请参阅 Spring Framework 参考文档。spring-doc.cn

Java Servlet 容器初始化

我们的 Spring 配置创建了一个名为 的 Spring Bean，它实现了 . 该 bean 负责将 替换为由 Spring Session 支持的自定义实现。springSessionRepositoryFilterFilterspringSessionRepositoryFilterHttpSessionspring-doc.cn

为了让我们发挥它的魔力， Spring 需要加载我们的 class。 最后，我们需要确保我们的 Servlet 容器（即 Tomcat）对每个请求都使用我们的容器。 幸运的是，Spring Session 提供了一个名为 的实用程序类，使这两个步骤都变得容易。 以下示例显示了如何执行此操作：FilterConfigspringSessionRepositoryFilterAbstractHttpSessionApplicationInitializerspring-doc.cn

来源/main/java/sample/Initializer.java
public class Initializer extends AbstractHttpSessionApplicationInitializer { (1)

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

}
我们的类 （Initializer） 的名称无关紧要。 重要的是，我们将 .AbstractHttpSessionApplicationInitializer
1 第一步是扩展 . 这样做可以确保 Spring bean named 在每个请求中都注册到我们的 Servlet 容器中。AbstractHttpSessionApplicationInitializerspringSessionRepositoryFilter
2 AbstractHttpSessionApplicationInitializer还提供了一种机制来确保 Spring 加载我们的 .Config

多个数据源

Spring Session 提供了限定符，允许您显式声明应该注入哪个 bean。 这在应用程序上下文中存在多个 bean 的情况下特别有用。@SpringSessionDataSourceDataSourceJdbcIndexedSessionRepositoryDataSourcespring-doc.cn

以下示例显示了如何执行此操作：spring-doc.cn

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 的配置时如何使用关系数据库进行备份。HttpSessionspring-doc.cn

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

Spring XML 配置

添加所需的依赖项后，我们可以创建 Spring 配置。 Spring 配置负责创建一个 servlet 过滤器，该过滤器将实现替换为 Spring Session 支持的实现。 下面的清单显示了如何添加以下 Spring Configuration：HttpSessionspring-doc.cn

来源/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 我们使用 和 的组合，因为 Spring Session 尚不提供 XML 命名空间支持（参见 gh-104）。 这将创建一个名为 的 Spring Bean。 该 bean 实现 . 过滤器负责替换 Spring Session 支持的实现。 在这种情况下， Spring Session 由关系数据库提供支持。<context:annotation-config/>JdbcHttpSessionConfigurationspringSessionRepositoryFilterFilterHttpSession
2 我们创建一个将 Spring Session 连接到 H2 数据库的嵌入式实例。 我们将 H2 数据库配置为使用 Spring Session 中包含的 SQL 脚本创建数据库表。dataSource
3 我们创建一个管理以前配置的事务的 .transactionManagerdataSource

有关如何配置数据访问相关问题的更多信息，请参阅 Spring Framework 参考文档。spring-doc.cn

XML Servlet 容器初始化

我们的 Spring 配置创建了一个名为 的 Spring Bean，它实现了 . 该 bean 负责将 替换为由 Spring Session 支持的自定义实现。springSessionRepositoryFilterFilterspringSessionRepositoryFilterHttpSessionspring-doc.cn

为了让我们发挥它的魔力，我们需要指示 Spring 加载我们的配置。 我们使用以下配置执行此操作：Filtersession.xmlspring-doc.cn

来源/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读取并选择我们的session.xml配置。contextConfigLocationspring-doc.cn

最后，我们需要确保我们的 Servlet 容器（即 Tomcat）对每个请求都使用我们的容器。 以下代码片段为我们执行了最后一步：springSessionRepositoryFilterspring-doc.cn

来源/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 查找名为 的 bean 并将其转换为 . 对于调用的每个请求，都会调用 the。springSessionRepositoryFilterFilterDelegatingFilterProxyspringSessionRepositoryFilterspring-doc.cn

基于 JDBC Spring Boot 的配置

本节介绍如何在使用 Spring Boot 时使用关系数据库。HttpSessionspring-doc.cn

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

Spring Boot 配置

添加所需的依赖项后，我们可以创建 Spring Boot 配置。 多亏了一流的自动配置支持，只需添加依赖项 Spring Boot 就可以为我们设置由关系数据库支持的 Spring Session。spring-doc.cn

如果 Classpath 上存在单个 Spring Session 模块，则 Spring Boot 会自动使用该 store 实现。 如果您有多个实施，则必须选择要用于存储会话的 StoreType，如上所示。spring-doc.cn

在后台， Spring Boot 应用等效于手动添加 Comments 的配置。 这将创建一个名为 的 Spring Bean。该 bean 实现 . 过滤器负责替换 Spring Session 支持的实现。@EnableJdbcHttpSessionspringSessionRepositoryFilterFilterHttpSessionspring-doc.cn

您可以使用 进一步自定义。 下面的清单显示了如何做到这一点：application.propertiesspring-doc.cn

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 部分。spring-doc.cn

配置DataSource

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

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 文档的 Configure a DataSource 部分。spring-doc.cn

Servlet 容器初始化

我们的 Spring Boot 配置创建了一个名为 的 Spring Bean，它实现了 . 该 bean 负责将 替换为由 Spring Session 支持的自定义实现。springSessionRepositoryFilterFilterspringSessionRepositoryFilterHttpSessionspring-doc.cn

为了让我们发挥它的魔力， Spring 需要加载我们的 class。 最后，我们需要确保我们的 Servlet 容器（即 Tomcat）对每个请求都使用我们的容器。 幸运的是，Spring Boot 为我们处理了这两个步骤。FilterConfigspringSessionRepositoryFilterspring-doc.cn

HttpSession 与 Hazelcast

通过在使用 .HttpSessionHttpSessionspring-doc.cn

本节介绍如何使用基于 Java 的配置使用 Hazelcast 进行备份。HttpSessionspring-doc.cn

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

Spring 配置

添加所需的依赖项后，我们可以创建 Spring 配置。 Spring 配置负责创建一个 servlet 过滤器，该过滤器将实现替换为 Spring Session 支持的实现。 为此，请添加以下 Spring Configuration：HttpSessionspring-doc.cn

@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 该注释将创建一个名为 的 Spring Bean，该 Bean 实现 . 过滤器负责替换 Spring Session 支持的实现。 在这种情况下，Spring Session 由 Hazelcast 提供支持。@EnableHazelcastHttpSessionspringSessionRepositoryFilterFilterHttpSession
2 为了支持按主体名称索引检索会话，需要注册相应的会话。 Spring Session 为此提供了。ValueExtractorPrincipalNameExtractor
3 为了有效地序列化对象，需要注册。如果此 未设置，则 Hazelcast 将使用本机 Java 序列化序列化会话。MapSessionHazelcastSessionSerializer
4 我们创建了一个将 Spring Session 连接到 Hazelcast 的 IP 文件。 默认情况下，应用程序启动并连接到 Hazelcast 的嵌入式实例。 有关配置 Hazelcast 的更多信息，请参阅参考文档。HazelcastInstance
如果首选，则需要在开始之前为所有 Hazelcast 集群成员配置它。 在 Hazelcast 集群中，所有成员都应为会话使用相同的序列化方法。此外，如果 Hazelcast 客户端/服务器拓扑 ，则成员和客户端都必须使用相同的序列化方法。序列化程序可以通过 with same of members 进行注册。HazelcastSessionSerializerClientConfigSerializerConfiguration

Servlet 容器初始化

我们的 Spring 配置创建了一个名为 的 Spring Bean，它实现了 . 该 bean 负责将 替换为由 Spring Session 支持的自定义实现。springSessionRepositoryFilterFilterspringSessionRepositoryFilterHttpSessionspring-doc.cn

为了让我们发挥它的魔力， Spring 需要加载我们的 class。 由于我们的应用程序已经使用我们的类加载了 Spring 配置，因此我们可以将我们的类添加到其中。 下面的清单显示了如何做到这一点：FilterSessionConfigSecurityInitializerSessionConfigspring-doc.cn

src/main/java/sample/SecurityInitializer.java
public class SecurityInitializer extends AbstractSecurityWebApplicationInitializer {

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

}

最后，我们需要确保我们的 Servlet 容器（即 Tomcat）对每个请求都使用我们的容器。 在 Spring Security 之前调用 Spring Session 非常重要。 这样做可以确保 Spring Security 使用的由 Spring Session 支持。 幸运的是，Spring Session 提供了一个名为 的 Util 类，它使这项工作变得容易。 以下示例显示了如何执行此操作：springSessionRepositoryFilterspringSessionRepositoryFilterspringSecurityFilterChainHttpSessionAbstractHttpSessionApplicationInitializerspring-doc.cn

来源/main/java/sample/Initializer.java
public class Initializer extends AbstractHttpSessionApplicationInitializer {

}
类的名称 （） 无关紧要。重要的是，我们将 .InitializerAbstractHttpSessionApplicationInitializer

通过扩展 ，我们确保在 Spring Security 之前的每个请求中都向 Spring Bean 命名的 Spring Bean 注册到我们的 servlet 容器中。AbstractHttpSessionApplicationInitializerspringSessionRepositoryFilterspringSecurityFilterChainspring-doc.cn

集成的工作原理HttpSession

幸运的是，和 （用于获取 ） 的 API 都是接口。 这意味着我们可以为每个 API 提供自己的实现。HttpSessionHttpServletRequestHttpSessionspring-doc.cn

本节介绍 Spring Session 如何提供与 的透明集成。我们提供这些内容是为了让您了解幕后发生的事情。此功能已集成，您无需自己实现此 logic。HttpSession

首先，我们创建一个自定义，该自定义返回 . 它看起来像下面这样：HttpServletRequestHttpSessionspring-doc.cn

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

任何返回 an 的方法都将被覆盖。 所有其他方法都由原始实现实现并委托给原始实现。HttpSessionHttpServletRequestWrapperHttpServletRequestspring-doc.cn

我们使用名为 . 以下伪代码显示了它的工作原理：HttpServletRequestFilterSessionRepositoryFilterspring-doc.cn

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);
	}

	// ...
}

通过将自定义实现传递到 中，我们确保在 之后调用的任何内容都使用自定义实现。 这突出了为什么将 Spring Session 放在与 .HttpServletRequestFilterChainFilterHttpSessionSessionRepositoryFilterHttpSessionspring-doc.cn

HttpSession和 RESTful API

Spring Session 可以通过在 header 中提供会话来与 RESTful API 一起使用。spring-doc.cn

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

Spring 配置

添加所需的依赖项后，我们可以创建 Spring 配置。 Spring 配置负责创建一个 servlet 过滤器，该过滤器将实现替换为 Spring Session 支持的实现。 为此，请添加以下 Spring Configuration：HttpSessionspring-doc.cn

@Configuration
@EnableRedisHttpSession (1)
public class HttpSessionConfig {

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

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

}
1 该注释将创建一个名为 的 Spring Bean，该 Bean 实现 . 过滤器负责替换 Spring Session 支持的实现。 在这种情况下， Spring Session 由 Redis 提供支持。@EnableRedisHttpSessionspringSessionRepositoryFilterFilterHttpSession
2 我们创建一个将 Spring Session 连接到 Redis 服务器。 我们将连接配置为连接到默认端口 （6379） 上的 localhost。 有关配置 Spring Data Redis 的更多信息，请参阅参考文档。RedisConnectionFactory
3 我们自定义 Spring Session 的 HttpSession 集成，以使用 HTTP 标头而不是 cookie 来传达当前会话信息。

Servlet 容器初始化

我们的 Spring 配置创建了一个名为 的 Spring Bean，它实现了 . 该 bean 负责将 替换为由 Spring Session 支持的自定义实现。springSessionRepositoryFilterFilterspringSessionRepositoryFilterHttpSessionspring-doc.cn

为了让我们发挥它的魔力， Spring 需要加载我们的 class。 我们在 Spring 中提供配置，如下例所示：FilterConfigMvcInitializerspring-doc.cn

来源/main/java/sample/mvc/MvcInitializer.java
@Override
protected Class<?>[] getRootConfigClasses() {
	return new Class[] { SecurityConfig.class, HttpSessionConfig.class };
}

最后，我们需要确保我们的 Servlet 容器（即 Tomcat）对每个请求都使用我们的容器。 幸运的是，Spring Session 提供了一个名为 的 Util 类，它使操作变得容易。为此，请使用 default 构造函数扩展类，如下例所示：springSessionRepositoryFilterAbstractHttpSessionApplicationInitializerspring-doc.cn

来源/main/java/sample/Initializer.java
public class Initializer extends AbstractHttpSessionApplicationInitializer {

}
类的名称 （） 无关紧要。重要的是，我们将 .InitializerAbstractHttpSessionApplicationInitializer

用HttpSessionListener

Spring Session 通过翻译和声明 into 来支持。 要使用此支持，您需要：HttpSessionListenerSessionDestroyedEventSessionCreatedEventHttpSessionEventSessionEventHttpSessionListenerAdapterspring-doc.cn

  • 确保您的实施支持并配置为 fire 和 。SessionRepositorySessionDestroyedEventSessionCreatedEventspring-doc.cn

  • 配置为 Spring Bean。SessionEventHttpSessionListenerAdapterspring-doc.cn

  • 将 every 注入到HttpSessionListenerSessionEventHttpSessionListenerAdapterspring-doc.cn

如果您使用 Redis 支持并将 设置为 ，则只需将 each 注册为 bean。 例如，假设您希望支持 Spring Security 的并发控制，并且需要使用 .在这种情况下，您可以添加为 bean。 在 Java 配置中，这可能如下所示：enableIndexingAndEventstrue@EnableRedisHttpSession(enableIndexingAndEvents = true)HttpSessionListenerHttpSessionEventPublisherHttpSessionEventPublisherspring-doc.cn

@Configuration
@EnableRedisHttpSession
public class RedisHttpSessionConfig {

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

	// ...

}

在 XML 配置中，这可能如下所示：spring-doc.cn

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