此版本仍在开发中，尚未被视为稳定版本。对于最新的稳定版本，请使用 Spring Session 3.4.0！spring-doc.cn

Redis 配置

现在您已经配置了应用程序，您可能希望开始自定义内容：spring-doc.cn

我想要使用 Spring Boot 属性自定义 Redis 配置 spring-doc.cn
我需要帮助来选择或。RedisSessionRepositoryRedisIndexedSessionRepositoryspring-doc.cn
我想要使用 JSON 序列化会话。spring-doc.cn
我想指定一个不同的命名空间。spring-doc.cn
我想知道会话何时创建、删除、销毁或过期。spring-doc.cn
我想查找特定用户的所有会话 spring-doc.cn
我想安全地反序列化 Redis 会话 spring-doc.cn
自定义会话过期存储 spring-doc.cn

使用 JSON 序列化 Session

默认情况下，Spring Session 使用 Java 序列化来序列化会话属性。有时可能会出现问题，尤其是当您有多个应用程序使用同一个 Redis 实例但具有同一类的不同版本时。您可以提供一个 Bean 来自定义如何将会话序列化为 Redis。 Spring Data Redis 提供了使用 Jackson 的序列化和反序列化对象的。RedisSerializerGenericJackson2JsonRedisSerializerObjectMapperspring-doc.cn

配置 RedisSerializer

@Configuration
public class SessionConfig implements BeanClassLoaderAware {

	private ClassLoader loader;

	/**
	 * Note that the bean name for this bean is intentionally
	 * {@code springSessionDefaultRedisSerializer}. It must be named this way to override
	 * the default {@link RedisSerializer} used by Spring Session.
	 */
	@Bean
	public RedisSerializer<Object> springSessionDefaultRedisSerializer() {
		return new GenericJackson2JsonRedisSerializer(objectMapper());
	}

	/**
	 * Customized {@link ObjectMapper} to add mix-in for class that doesn't have default
	 * constructors
	 * @return the {@link ObjectMapper} to use
	 */
	private ObjectMapper objectMapper() {
		ObjectMapper mapper = new ObjectMapper();
		mapper.registerModules(SecurityJackson2Modules.getModules(this.loader));
		return mapper;
	}

	/*
	 * @see
	 * org.springframework.beans.factory.BeanClassLoaderAware#setBeanClassLoader(java.lang
	 * .ClassLoader)
	 */
	@Override
	public void setBeanClassLoader(ClassLoader classLoader) {
		this.loader = classLoader;
	}

}

上面的代码片段使用的是 Spring Security，因此我们正在创建一个使用 Spring Security 的 Jackson 模块的自定义。如果您不需要 Spring Security Jackson 模块，则可以注入应用程序的 bean 并按如下方式使用它：ObjectMapperObjectMapperspring-doc.cn

@Bean
public RedisSerializer<Object> springSessionDefaultRedisSerializer(ObjectMapper objectMapper) {
    return new GenericJackson2JsonRedisSerializer(objectMapper);
}

指定不同的命名空间

多个应用程序使用同一个 Redis 实例的情况并不少见。出于这个原因， Spring Session 如果需要，使用（默认为）来保持 session 数据分离。namespacespring:sessionspring-doc.cn

使用 Spring Boot 属性

您可以通过设置属性来指定它。spring.session.redis.namespacespring-doc.cn

application.properties

spring.session.redis.namespace=spring:session:myapplication

application.yml

spring:
  session:
    redis:
      namespace: "spring:session:myapplication"

使用 Annotation 的属性

您可以通过在、或 annotations 中设置属性来指定：namespaceredisNamespace@EnableRedisHttpSession@EnableRedisIndexedHttpSession@EnableRedisWebSessionspring-doc.cn

@EnableRedisHttpSession

@Configuration
@EnableRedisHttpSession(redisNamespace = "spring:session:myapplication")
public class SessionConfig {
    // ...
}

@EnableRedisIndexedHttpSession

@Configuration
@EnableRedisIndexedHttpSession(redisNamespace = "spring:session:myapplication")
public class SessionConfig {
    // ...
}

@EnableRedisWebSession

@Configuration
@EnableRedisWebSession(redisNamespace = "spring:session:myapplication")
public class SessionConfig {
    // ...
}

在和之间进行选择`RedisSessionRepositoryRedisIndexedSessionRepository`

使用 Spring Session Redis 时，您可能必须在和之间进行选择。两者都是在 Redis 中存储会话数据的接口的实现。但是，它们在处理会话索引和查询的方式上有所不同。RedisSessionRepositoryRedisIndexedSessionRepositorySessionRepositoryspring-doc.cn

RedisSessionRepository：是一种基本实现，可将会话数据存储在 Redis 中，而无需任何其他索引。它使用简单的键值结构来存储会话属性。每个会话都分配有一个唯一的会话 ID，会话数据存储在与该 ID 关联的 Redis 密钥下。当需要检索会话时，存储库使用会话 ID 查询 Redis 以获取关联的会话数据。由于没有索引，因此根据会话 ID 以外的属性或条件查询会话可能效率低下。RedisSessionRepositoryspring-doc.cn
RedisIndexedSessionRepository：是一种扩展实现，可为 Redis 中存储的会话提供索引功能。它在 Redis 中引入了额外的数据结构，以根据属性或条件高效地查询会话。除了使用的键值结构之外，它还维护其他索引以实现快速查找。例如，它可能会根据会话属性（如用户 ID 或上次访问时间）创建索引。这些索引允许根据特定条件高效查询会话，从而提高性能并启用高级会话管理功能。除此之外，还支持会话过期和删除。RedisIndexedSessionRepositoryRedisSessionRepositoryRedisIndexedSessionRepositoryspring-doc.cn

与 Redis 集群一起使用时，您必须注意它仅订阅来自集群中一个随机 redis 节点的事件，如果事件发生在其他节点中，这可能会导致某些会话索引无法清理。RedisIndexedSessionRepository

配置`RedisSessionRepository`

使用 Spring Boot 属性

如果您使用的是 Spring Boot，则这是默认实现。但是，如果您想明确说明这一点，则可以在应用程序中设置以下属性：RedisSessionRepositoryspring-doc.cn

application.properties

spring.session.redis.repository-type=default

application.yml

spring:
  session:
    redis:
      repository-type: default

使用注释

您可以使用注释配置：RedisSessionRepository@EnableRedisHttpSessionspring-doc.cn

@Configuration
@EnableRedisHttpSession
public class SessionConfig {
    // ...
}

配置`RedisIndexedSessionRepository`

使用 Spring Boot 属性

您可以通过在应用程序中设置以下属性来配置：RedisIndexedSessionRepositoryspring-doc.cn

application.properties

spring.session.redis.repository-type=indexed

application.yml

spring:
  session:
    redis:
      repository-type: indexed

使用注释

您可以使用注释配置：RedisIndexedSessionRepository@EnableRedisIndexedHttpSessionspring-doc.cn

@Configuration
@EnableRedisIndexedHttpSession
public class SessionConfig {
    // ...
}

侦听会话事件

通常，对会话事件做出反应是有价值的，例如，您可能希望根据会话生命周期进行某种处理。为了能够做到这一点，您必须使用索引存储库。如果您不知道已编入索引的存储库和默认存储库之间的区别，可以转到此部分。spring-doc.cn

配置索引存储库后，您现在可以开始侦听、和事件。在 Spring 中有几种方法可以监听应用程序事件，我们将使用 Annotation。SessionCreatedEventSessionDeletedEventSessionDestroyedEventSessionExpiredEvent@EventListenerspring-doc.cn

@Component
public class SessionEventListener {

    @EventListener
    public void processSessionCreatedEvent(SessionCreatedEvent event) {
        // do the necessary work
    }

    @EventListener
    public void processSessionDeletedEvent(SessionDeletedEvent event) {
        // do the necessary work
    }

    @EventListener
    public void processSessionDestroyedEvent(SessionDestroyedEvent event) {
        // do the necessary work
    }

    @EventListener
    public void processSessionExpiredEvent(SessionExpiredEvent event) {
        // do the necessary work
    }

}

查找特定用户的所有会话

通过检索特定用户的所有会话，您可以跨设备或浏览器跟踪用户的活动会话。例如，您可以使用此信息进行会话管理，例如允许用户使特定会话无效或注销，或者根据用户的会话活动执行操作。spring-doc.cn

为此，首先您必须使用索引存储库，然后您可以注入接口，如下所示：FindByIndexNameSessionRepositoryspring-doc.cn

@Autowired
public FindByIndexNameSessionRepository<? extends Session> sessions;

public Collection<? extends Session> getSessions(Principal principal) {
    Collection<? extends Session> usersSessions = this.sessions.findByPrincipalName(principal.getName()).values();
    return usersSessions;
}

public void removeSession(Principal principal, String sessionIdToDelete) {
    Set<String> usersSessionIds = this.sessions.findByPrincipalName(principal.getName()).keySet();
    if (usersSessionIds.contains(sessionIdToDelete)) {
        this.sessions.deleteById(sessionIdToDelete);
    }
}

在上面的示例中，你可以使用 method 来查找特定用户的所有会话，以及 method 来删除用户的特定会话。getSessionsremoveSessionspring-doc.cn

配置 Redis 会话映射器

Spring Session Redis 从 Redis 中检索会话信息并将其存储在 . 此映射需要经过映射过程才能转换为对象，然后在中使用。Map<String, Object>MapSessionRedisSessionspring-doc.cn

用于此目的的默认映射器称为。如果 session map 不包含构造 session 所需的最小键，例如，则此 mapper 将引发异常。缺少所需密钥的一种可能情况是，在保存过程正在进行时，会话密钥通常由于过期而被同时删除。发生这种情况是因为 HSET 命令用于设置键中的字段，如果键不存在，此命令将创建它。RedisSessionMappercreationTimespring-doc.cn

如果要自定义映射过程，可以创建的实现并将其设置到 session 存储库中。以下示例显示了如何将映射过程委托给默认映射器，但如果引发异常，则会从 Redis 中删除该会话：BiFunction<String, Map<String, Object>, MapSession>spring-doc.cn

RedisSessionRepositoryspring-doc.cn
RedisIndexedSessionRepositoryspring-doc.cn
ReactiveRedisSessionRepositoryspring-doc.cn

@Configuration
@EnableRedisHttpSession
public class SessionConfig {

    @Bean
    SessionRepositoryCustomizer<RedisSessionRepository> redisSessionRepositoryCustomizer() {
        return (redisSessionRepository) -> redisSessionRepository
                .setRedisSessionMapper(new SafeRedisSessionMapper(redisSessionRepository));
    }

    static class SafeRedisSessionMapper implements BiFunction<String, Map<String, Object>, MapSession> {

        private final RedisSessionMapper delegate = new RedisSessionMapper();

        private final RedisSessionRepository sessionRepository;

        SafeRedisSessionMapper(RedisSessionRepository sessionRepository) {
            this.sessionRepository = sessionRepository;
        }

        @Override
        public MapSession apply(String sessionId, Map<String, Object> map) {
            try {
                return this.delegate.apply(sessionId, map);
            }
            catch (IllegalStateException ex) {
                this.sessionRepository.deleteById(sessionId);
                return null;
            }
        }

    }

}

@Configuration
@EnableRedisIndexedHttpSession
public class SessionConfig {

    @Bean
    SessionRepositoryCustomizer<RedisIndexedSessionRepository> redisSessionRepositoryCustomizer() {
        return (redisSessionRepository) -> redisSessionRepository.setRedisSessionMapper(
                new SafeRedisSessionMapper(redisSessionRepository.getSessionRedisOperations()));
    }

    static class SafeRedisSessionMapper implements BiFunction<String, Map<String, Object>, MapSession> {

        private final RedisSessionMapper delegate = new RedisSessionMapper();

        private final RedisOperations<String, Object> redisOperations;

        SafeRedisSessionMapper(RedisOperations<String, Object> redisOperations) {
            this.redisOperations = redisOperations;
        }

        @Override
        public MapSession apply(String sessionId, Map<String, Object> map) {
            try {
                return this.delegate.apply(sessionId, map);
            }
            catch (IllegalStateException ex) {
                // if you use a different redis namespace, change the key accordingly
                this.redisOperations.delete("spring:session:sessions:" + sessionId); // we do not invoke RedisIndexedSessionRepository#deleteById to avoid an infinite loop because the method also invokes this mapper
                return null;
            }
        }

    }

}

@Configuration
@EnableRedisWebSession
public class SessionConfig {

    @Bean
    ReactiveSessionRepositoryCustomizer<ReactiveRedisSessionRepository> redisSessionRepositoryCustomizer() {
        return (redisSessionRepository) -> redisSessionRepository
                .setRedisSessionMapper(new SafeRedisSessionMapper(redisSessionRepository));
    }

    static class SafeRedisSessionMapper implements BiFunction<String, Map<String, Object>, Mono<MapSession>> {

        private final RedisSessionMapper delegate = new RedisSessionMapper();

        private final ReactiveRedisSessionRepository sessionRepository;

        SafeRedisSessionMapper(ReactiveRedisSessionRepository sessionRepository) {
            this.sessionRepository = sessionRepository;
        }

        @Override
        public Mono<MapSession> apply(String sessionId, Map<String, Object> map) {
            return Mono.fromSupplier(() -> this.delegate.apply(sessionId, map))
                .onErrorResume(IllegalStateException.class,
                    (ex) -> this.sessionRepository.deleteById(sessionId).then(Mono.empty()));
        }

    }

}

自定义会话过期存储

由于 Redis 的性质，如果密钥未被访问，则无法保证何时会触发过期事件。有关更多详细信息，请参阅有关密钥过期的 Redis 文档。spring-doc.cn

为了降低过期事件的不确定性，会话还会存储其预期的过期时间。这可确保每个密钥在预期过期时都可以访问。该接口定义了跟踪会话及其过期时间的常见操作，并提供了清理过期会话的策略。RedisSessionExpirationStorespring-doc.cn

默认情况下，每个会话过期时间都跟踪到最接近的分钟。这允许后台任务访问可能过期的会话，以确保以更具确定性的方式触发 Redis 过期事件。spring-doc.cn

例如：spring-doc.cn

SADD spring:session:expirations:1439245080000 expires:33fdd1b6-b496-4b33-9f7d-df96679d32fe
EXPIRE spring:session:expirations:1439245080000 2100

然后，后台任务将使用这些映射显式请求每个会话过期密钥。通过访问密钥而不是删除密钥，我们确保 Redis 仅在 TTL 过期时为我们删除密钥。spring-doc.cn

通过自定义会话过期存储，您可以根据需要更有效地管理会话过期。为此，您应该提供一个 bean 类型，该 bean 将由 Spring Session Data Redis 配置拾取：RedisSessionExpirationStorespring-doc.cn

SessionConfigspring-doc.cn

import org.springframework.session.data.redis.SortedSetRedisSessionExpirationStore;

@Configuration
@EnableRedisIndexedHttpSession
public class SessionConfig {

    @Bean
    public RedisSessionExpirationStore redisSessionExpirationStore(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setKeySerializer(RedisSerializer.string());
        redisTemplate.setHashKeySerializer(RedisSerializer.string());
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        redisTemplate.afterPropertiesSet();
        return new SortedSetRedisSessionExpirationStore(redisTemplate, RedisIndexedSessionRepository.DEFAULT_NAMESPACE);
    }

}

在上面的代码中，使用了 implementation ，它使用 Sorted Set 来存储会话 ID，其过期时间作为分数。SortedSetRedisSessionExpirationStorespring-doc.cn

我们不会明确删除密钥，因为在某些情况下，可能存在争用条件，错误地将密钥标识为过期，而密钥实际上并未过期。如果不使用分布式锁（这会降低性能），则无法确保过期 Map 的一致性。通过简单地访问密钥，我们确保只有在该密钥的 TTL 过期时才会删除该密钥。但是，对于您的实施，您可以选择最适合的策略。spring-doc.cn

Redis 配置

使用 JSON 序列化 Session

指定不同的命名空间

使用 Spring Boot 属性

使用 Annotation 的属性

在 和 之间进行选择RedisSessionRepositoryRedisIndexedSessionRepository

配置RedisSessionRepository

使用 Spring Boot 属性

使用注释

配置RedisIndexedSessionRepository

使用 Spring Boot 属性

使用注释

侦听会话事件

查找特定用户的所有会话

配置 Redis 会话映射器

自定义会话过期存储

在和之间进行选择`RedisSessionRepositoryRedisIndexedSessionRepository`

配置`RedisSessionRepository`

配置`RedisIndexedSessionRepository`