Spring session redis 修改默认的序列化方法(案例)

以下是Spring session redis修改默认的序列化方法的完整攻略：

简介

Spring Session是Spring官方提供的一个用于对Session进行管理的解决方案，可以将Session的数据存储在各种数据源中，其中就包括Redis。Spring Session Redis提供了一种默认的序列化方式，但是如果要修改默认的序列化方式，就需要进行一些额外的配置。

步骤

1. 添加Redis依赖

使用Spring Session Redis需要添加Spring Data Redis依赖。在Maven项目中，可以在pom.xml文件中添加以下依赖：

<dependency>
    <groupId>org.springframework.data</groupId>
    <artifactId>spring-data-redis</artifactId>
    <version>2.5.0</version>
</dependency>

1. 配置Redis连接

在Spring Boot项目中，可以在application.properties或application.yml文件中配置Redis连接信息。具体配置如下：

spring.redis.host=127.0.0.1
spring.redis.port=6379
spring.redis.password=
spring.redis.database=0

1. 自定义序列化方式

Spring Session Redis提供了默认的序列化方式，但是如果要修改默认的序列化方式，就需要实现Serializer接口，并将自定义的序列化器配置到RedisConfigurer中。示例代码如下：

import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.SerializationException;
import java.nio.charset.StandardCharsets;

public class CustomSerializer implements RedisSerializer<Object> {

    private static final String PREFIX = "custom:";
    private static final byte[] PREFIX_BYTES = PREFIX.getBytes(StandardCharsets.UTF_8);

    @Override
    public byte[] serialize(Object object) throws SerializationException {
        if (object == null) {
            return null;
        }
        String serializedValue = PREFIX + object.toString();
        return serializedValue.getBytes(StandardCharsets.UTF_8);
    }

    @Override
    public Object deserialize(byte[] bytes) throws SerializationException {
        if (bytes == null || bytes.length == 0) {
            return null;
        }
        String serializedValue = new String(bytes, StandardCharsets.UTF_8);
        if (serializedValue.startsWith(PREFIX)) {
            return serializedValue.substring(PREFIX.length());
        }
        throw new SerializationException("Cannot deserialize data with unknown prefix");
    }
}

将自定义的序列化器配置到RedisConfigurer中，示例代码如下：

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.security.crypto.encrypt.BytesEncryptor;
import org.springframework.security.crypto.encrypt.Encryptors;
import org.springframework.session.config.annotation.web.http.EnableSpringHttpSession;
import org.springframework.session.data.redis.config.ConfigureRedisAction;
import org.springframework.session.data.redis.config.annotation.web.http.RedisHttpSessionConfiguration;
import org.springframework.session.data.redis.config.annotation.web.http.RedisHttpSessionConfigurer;
import org.springframework.session.data.redis.serializer.RedisSerializationContext;
import org.springframework.session.data.redis.serializer.RedisSerializer;
import org.springframework.session.data.redis.serializer.SerializationException;
import java.nio.charset.StandardCharsets;

@Configuration
@EnableSpringHttpSession
public class RedisSessionConfig {

    @Bean
    public RedisHttpSessionConfigurer redisHttpSessionConfigurer() {
        //自定义序列化器
        RedisSerializer<Object> valueSerializer = new CustomSerializer();
        RedisSerializationContext<Object, Object> serializationContext = RedisSerializationContext
                .newSerializationContext()
                .key(valueSerializer)
                .value(valueSerializer)
                .hashKey(valueSerializer)
                .hashValue(valueSerializer)
                .build();

        //加密配置
        BytesEncryptor encryptor = Encryptors.noOpText();
        ConfigureRedisAction configureRedisAction = ConfigureRedisAction.NO_OP;
        RedisHttpSessionConfiguration redisHttpSessionConfiguration = new RedisHttpSessionConfiguration();
        return new RedisHttpSessionConfigurer() {
            @Override
            public void configureRedisAction(ConfigureRedisAction configureRedisAction) {
                configureRedisAction.configure(null);
            }
            @Override
            public void configure(RedisHttpSessionConfiguration redisHttpSessionConfiguration) {
                redisHttpSessionConfiguration.setMaxInactiveIntervalInSeconds(3600);
                redisHttpSessionConfiguration.setRedisNamespace("demo:session:");
                redisHttpSessionConfiguration.setRedisFlushModeOnSave(RedisFlushMode.IMMEDIATE);
                redisHttpSessionConfiguration.setSerializationContext(serializationContext);
                redisHttpSessionConfiguration.setEncryptor(encryptor);
            }
        };
    }

    @Bean
    public ConfigureRedisAction configureRedisAction() {
        return ConfigureRedisAction.NO_OP;
    }

    @Bean
    public RedisHttpSessionConfiguration redisHttpSessionConfiguration() {
        RedisHttpSessionConfiguration redisHttpSessionConfiguration = new RedisHttpSessionConfiguration();
        redisHttpSessionConfiguration.setMaxInactiveIntervalInSeconds(3600);
        redisHttpSessionConfiguration.setRedisNamespace("demo:session:");
        redisHttpSessionConfiguration.setRedisFlushModeOnSave(RedisFlushMode.IMMEDIATE);
        return redisHttpSessionConfiguration;
    }
}

1. 示例说明

以下是示例1中自定义序列化器的具体说明：

示例1中实现的自定义序列化器类为CustomSerializer，实现了RedisSerializer接口。在CustomSerializer中，序列化方法将对象转换为字符串后添加了前缀"custom:"，反序列化方法则截取了该前缀。这是为了防止误解析非自定义序列化器存储的数据。

以下是示例2中将自定义序列化器配置到RedisConfigurer中的具体说明：

在RedisSessionConfig中，定义了一个RedisHttpSessionConfigurer，在其中实现了configure方法。在configure方法中，通过RedisSerializationContext自定义了序列化器，并将其设置到RedisHttpSessionConfiguration中。最后通过setSerializationContext将RedisHttpSessionConfiguration设置到RedisHttpSessionConfigurer中。

经过以上配置，就可以使用自定义的序列化方式对Session数据进行存储和读取了。