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，因此我们创建了一个自定义的 `ObjectMapper`，它使用 Spring Security 的 Jackson 模块。如果您不需要 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 集群中使用 `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>中。此映射需要经过映射过程才能转换为MapSession对象，然后在RedisSession中使用。

为此目的使用的默认映射器称为RedisSessionMapper。如果会话映射不包含构建会话所需的最小必需键，例如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()));
        }

    }

}