【redis】redis使用GenericJackson2JsonRedisSerializer

简介：GenericJackson2JsonRedisSerializer

不同于使用Java默认的对象序列化，使用GenericJackson2JsonRedisSerializer会将对象格式化为类似json形式，并且在json中会包含类的一些信息，我们以一个列子来看一下：

{
    "@class": "com.xxx.bo.DeviceIpBo",
    "deviceIp": "192.168.1.101",
    "devicePort": 8080
}

其中deviceIp和devicePort是我们对象中存在的字段，而@class则是GenericJackson2JsonRedisSerializer自己添加进去的，至于为什么要加显而易见，就是为了方便反序列化。

如何使用？

因为GenericJackson2JsonRedisSerializer是spring data redis自带的，所以我们不需要单独引入。我们知道spring中使用redis主要是通过RedisTemplate，所以我们需要先配置RedisTemplate.（因为GenericJackson2JsonRedisSerializer内部解析JSON使用的是jackson，而jackson对新的日期时间类型支持不友好，所以需要单独配置，见下面的jackson配置类），以下代码支持直接复制粘贴使用

• 主配置类

import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
import org.springframework.web.filter.CorsFilter;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;


@Configuration
public class MvcConfig implements WebMvcConfigurer {

    private final StringRedisSerializer keySerializer = new StringRedisSerializer();
    private final GenericJackson2JsonRedisSerializer valueSerializer = createJsonRedisSerializer();

    @Bean("redisTemplate")
    public RedisTemplate<Object,Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<Object,Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(factory);
        redisTemplate.setKeySerializer(keySerializer);
        redisTemplate.setValueSerializer(valueSerializer);
        redisTemplate.setExposeConnection(true);
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }


    private static GenericJackson2JsonRedisSerializer createJsonRedisSerializer(){
    	//创建objectMapper，见下面的jsonson配置
        ObjectMapper objectMapper = JsonSerializerConfig.createObjectMapper();
        //为什么这么写，是因为默认的new GenericJackson2JsonRedisSerializer()中存在此逻辑，为了保持一致，这里这么写，避免不必要的错误，不同版本的spring-data-redis可能会有所区别，自己查看下new GenericJackson2JsonRedisSerializer()内的逻辑处理一下即可。
        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
        GenericJackson2JsonRedisSerializer.registerNullValueSerializer(objectMapper, null);
        return new GenericJackson2JsonRedisSerializer(objectMapper);
    }
}

• jackson配置

import cn.hutool.core.util.StrUtil;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;

import java.io.IOException;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

@Configuration
public class JsonSerializerConfig {

    private final static String datetimePattern = "yyyy-MM-dd HH:mm:ss";

    private final static String datePattern = "yyyy-MM-dd";

    @Bean
    @Primary
    public ObjectMapper serializingObjectMapper() {
        return createObjectMapper();
    }

    public static ObjectMapper createObjectMapper(){
        ObjectMapper objectMapper = new ObjectMapper();
        JavaTimeModule javaTimeModule = new JavaTimeModule();
        javaTimeModule.addSerializer(LocalDateTime.class, new LocalDateTimeSerializer());
        javaTimeModule.addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer());
        javaTimeModule.addSerializer(LocalDate.class, new LocalDateSerializer());
        javaTimeModule.addDeserializer(LocalDate.class, new LocalDateDeserializer());
        objectMapper.registerModule(javaTimeModule);
        objectMapper.configure(DeserializationFeature.READ_UNKNOWN_ENUM_VALUES_AS_NULL, true);
        objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
        return objectMapper;
    }

    public static class LocalDateSerializer extends JsonSerializer<LocalDate> {
        @Override
        public void serialize(LocalDate value, JsonGenerator gen, SerializerProvider serializers)
                throws IOException {
            gen.writeString(value.format(DateTimeFormatter.ofPattern(datePattern)));
        }
    }

    public static class LocalDateDeserializer extends JsonDeserializer<LocalDate> {
        @Override
        public LocalDate deserialize(JsonParser p, DeserializationContext deserializationContext)
                throws IOException {
            String valueAsString = p.getValueAsString();
            if (StrUtil.isEmpty(valueAsString)) {
                return null;
            }
            return LocalDate.parse(valueAsString, DateTimeFormatter.ofPattern(datePattern));
        }
    }

    public static class LocalDateTimeSerializer extends JsonSerializer<LocalDateTime> {
        @Override
        public void serialize(LocalDateTime value, JsonGenerator gen, SerializerProvider serializers)
                throws IOException {
            gen.writeString(value.format(DateTimeFormatter.ofPattern(datetimePattern)));
        }
    }

    public static class LocalDateTimeDeserializer extends JsonDeserializer<LocalDateTime> {
        @Override
        public LocalDateTime deserialize(JsonParser p, DeserializationContext deserializationContext)
                throws IOException {
            String valueAsString = p.getValueAsString();
            if (StrUtil.isEmpty(valueAsString)) {
                return null;
            }
            return LocalDateTime.parse(valueAsString, DateTimeFormatter.ofPattern(datetimePattern));
        }
    }
}