Redis 配置

配置好应用后，您可能希望开始自定义一些设置。

我想使用 Spring Boot 属性自定义 Redis 配置
我想获得关于选择 RedisSessionRepository 或 RedisIndexedSessionRepository 的帮助。
我想使用 JSON 序列化会话。
我想指定不同的命名空间。
我想知道会话何时创建、删除、销毁或过期。
我想查找特定用户的所有会话
我想安全地反序列化 Redis 会话
自定义会话过期存储

使用 JSON 序列化会话

默认情况下，Spring Session 使用 Java 序列化来序列化会话属性。有时这可能会有问题，特别是当您有多个应用程序使用相同的 Redis 实例，但使用相同类的不同版本时。您可以提供一个 RedisSerializer bean 来自定义会话如何序列化到 Redis 中。Spring Data Redis 提供了 GenericJackson2JsonRedisSerializer，它使用 Jackson 的 ObjectMapper 来序列化和反序列化对象。

配置 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 模块的自定义 ObjectMapper。如果您不需要 Spring Security Jackson 模块，可以注入您应用的 ObjectMapper bean 并像这样使用它

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

指定不同的命名空间

多个应用程序使用同一个 Redis 实例是很常见的。因此，Spring Session 使用一个 namespace（默认为 spring:session）来在需要时分离会话数据。

使用 Spring Boot 属性

您可以通过设置 spring.session.redis.namespace 属性来指定它。

application.properties

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

application.yml

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

使用注解属性

您可以通过在 @EnableRedisHttpSession、@EnableRedisIndexedHttpSession 或 @EnableRedisWebSession 注解中设置 redisNamespace 属性来指定 namespace。

@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 {
    // ...
}

在 `RedisSessionRepository` 和 `RedisIndexedSessionRepository` 之间选择

使用 Spring Session Redis 时，您可能需要在 RedisSessionRepository 和 RedisIndexedSessionRepository 之间进行选择。它们都是 SessionRepository 接口的实现，用于在 Redis 中存储会话数据。然而，它们在会话索引和查询的处理方式上有所不同。

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

在 Redis Cluster 中使用 RedisIndexedSessionRepository 时，您必须注意它只订阅集群中一个随机 Redis 节点的事件，如果事件发生在不同的节点上，这可能导致一些会话索引无法被清理。

配置 `RedisSessionRepository`

使用 Spring Boot 属性

如果您使用 Spring Boot，RedisSessionRepository 是默认实现。但是，如果您想明确指定它，可以在应用程序中设置以下属性

application.properties

spring.session.redis.repository-type=default

application.yml

spring:
  session:
    redis:
      repository-type: default

使用注解

您可以使用 @EnableRedisHttpSession 注解配置 RedisSessionRepository

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

配置 `RedisIndexedSessionRepository`

使用 Spring Boot 属性

您可以通过在应用程序中设置以下属性来配置 RedisIndexedSessionRepository

application.properties

spring.session.redis.repository-type=indexed

application.yml

spring:
  session:
    redis:
      repository-type: indexed

使用注解

您可以使用 @EnableRedisIndexedHttpSession 注解配置 RedisIndexedSessionRepository

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

监听会话事件

通常情况下，响应会话事件很有价值，例如，您可能想根据会话生命周期进行某种处理。为此，您必须使用索引存储库。如果您不了解索引存储库和默认存储库之间的区别，可以查看本节。

配置好索引存储库后，您现在可以开始监听 SessionCreatedEvent、SessionDeletedEvent、SessionDestroyedEvent 和 SessionExpiredEvent 事件。Spring 中有几种监听应用程序事件的方法，我们将使用 @EventListener 注解。

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

}

查找特定用户的所有会话

通过检索特定用户的所有会话，您可以跟踪用户在不同设备或浏览器上的活动会话。例如，您可以将此信息用于会话管理目的，例如允许用户使特定会话失效或注销，或根据用户的会话活动执行操作。

为此，首先您必须使用索引存储库，然后您可以注入 FindByIndexNameSessionRepository 接口，如下所示

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

在上面的示例中，您可以使用 getSessions 方法查找特定用户的所有会话，并使用 removeSession 方法删除特定用户的会话。

配置 Redis 会话映射器

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

用于此目的的默认映射器称为 RedisSessionMapper。如果会话 Map 不包含构建会话所需的最小键（例如 creationTime），此映射器将抛出异常。缺少必需键的一种可能情况是，当会话键在保存过程进行中时被并发删除，通常是由于过期。发生这种情况是因为使用了 HSET 命令来设置键内的字段，如果键不存在，此命令将创建它。

如果您想自定义映射过程，可以创建自己的 BiFunction<String, Map<String, Object>, MapSession> 实现并将其设置到会话存储库中。以下示例展示了如何将映射过程委托给默认映射器，但如果抛出异常，则从 Redis 中删除会话

RedisSessionRepository
RedisIndexedSessionRepository
ReactiveRedisSessionRepository

@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 关于键过期的文档。

为了减轻过期事件的不确定性，会话也与其预期的过期时间一起存储。这确保了每个键可以在预期过期时被访问。RedisSessionExpirationStore 接口定义了跟踪会话及其过期时间的通用操作，并提供了一种清理过期会话的策略。

默认情况下，每个会话过期都会跟踪到最近一分钟。这允许后台任务访问可能已过期的会话，以确保 Redis 过期事件以更确定的方式触发。

例如

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

然后，后台任务将使用这些映射显式请求每个会话的过期键。通过访问键而不是直接删除它，我们可以确保 Redis 仅在 TTL 过期时删除键。

通过自定义会话过期存储，您可以根据需要更有效地管理会话过期。为此，您应该提供一个 RedisSessionExpirationStore 类型的 bean，它将被 Spring Session Data Redis 配置识别

SessionConfig

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

}

在上面的代码中，使用了 SortedSetRedisSessionExpirationStore 实现，它使用有序集合（Sorted Set）来存储会话 ID，并将其过期时间作为分数。

我们不会显式删除键，因为在某些情况下可能存在竞争条件，导致错误地将未过期的键识别为已过期。除了使用分布式锁（这会严重影响性能）之外，没有办法确保过期映射的一致性。通过简单地访问键，我们确保只有当该键的 TTL 过期时才删除它。但是，对于您的实现，您可以选择最适合您的策略。

Redis 配置

使用 JSON 序列化会话

指定不同的命名空间

使用 Spring Boot 属性

使用注解属性

在 RedisSessionRepository 和 RedisIndexedSessionRepository 之间选择

配置 RedisSessionRepository

使用 Spring Boot 属性

使用注解

配置 RedisIndexedSessionRepository

使用 Spring Boot 属性

使用注解

监听会话事件

查找特定用户的所有会话

配置 Redis 会话映射器

自定义会话过期存储

在 `RedisSessionRepository` 和 `RedisIndexedSessionRepository` 之间选择

配置 `RedisSessionRepository`

配置 `RedisIndexedSessionRepository`