SpringBoot项目中Redis对java8时间的序列化和反序列化

骑猪看日落 2023-02-14 10:48 6阅读 0赞

### SpringBoot项目中Redis对java8时间的序列化和反序列化 ###

> 1、第一种方法是在属性上面为需要序列化的属性加注解，这种方式虽然可用，但是非常繁琐。有时候可能会忘记。

@JsonFormat( pattern="yyyy-MM-dd HH:mm:ss",timezone = "GMT+8")
    @JsonDeserialize(using = LocalDateTimeDeserializer.class)
    @JsonSerialize(using = LocalDateTimeSerializer.class)
    private LocalDateTime createTime;
    @JsonFormat( pattern="yyyy-MM-dd HH:mm:ss",timezone = "GMT+8")
    @JsonDeserialize(using = LocalDateTimeDeserializer.class)
    @JsonSerialize(using = LocalDateTimeSerializer.class)
    private LocalDateTime updateTime;

> 2、弄一个统一配置类如下，让GenericJackson2JsonRedisSerializer 支持java8 time的的序列化和反序列化

import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.context.annotation.Lazy;
    import org.springframework.data.redis.cache.RedisCacheConfiguration;
    import org.springframework.data.redis.cache.RedisCacheManager;
    import org.springframework.data.redis.cache.RedisCacheWriter;
    import org.springframework.data.redis.connection.RedisConnectionFactory;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.data.redis.serializer.GenericToStringSerializer;
    import org.springframework.data.redis.serializer.RedisSerializationContext;
    
    @Configuration
    public class RedisConfig { 
    
    	@SuppressWarnings({  "unchecked", "rawtypes" })
    	@Bean("redisTemplate")
    	public RedisTemplate redisTemplate(@Lazy RedisConnectionFactory connectionFactory) { 
    		RedisTemplate redis = new RedisTemplate();
    
    		GenericToStringSerializer<String> keySerializer = new GenericToStringSerializer<>(String.class);
    		redis.setKeySerializer(keySerializer);
    		redis.setHashKeySerializer(keySerializer);
    
    		//GenericJackson2JsonRedisSerializer valueSerializer = new GenericJackson2JsonRedisSerializer();
    		GenericJackson2JsonRedisSerializerEx valueSerializer = new GenericJackson2JsonRedisSerializerEx();
    		redis.setValueSerializer(valueSerializer);
    		redis.setHashValueSerializer(valueSerializer);
    
    		redis.setConnectionFactory(connectionFactory);
    		return redis;
    	}
    }

> 2、本想继承GenericJackson2JsonRedisSerializer ,但是里面的属性是私有的，对继承不友好。简单粗暴，直接复制一份进行扩展

/* * Copyright 2015-2020 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * https://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */
    import com.fasterxml.jackson.annotation.JsonTypeInfo;
    import com.fasterxml.jackson.annotation.JsonTypeInfo.As;
    import com.fasterxml.jackson.core.JsonGenerator;
    import com.fasterxml.jackson.core.JsonProcessingException;
    import com.fasterxml.jackson.databind.ObjectMapper;
    import com.fasterxml.jackson.databind.ObjectMapper.DefaultTyping;
    import com.fasterxml.jackson.databind.SerializerProvider;
    import com.fasterxml.jackson.databind.module.SimpleModule;
    import com.fasterxml.jackson.databind.ser.SerializerFactory;
    import com.fasterxml.jackson.databind.ser.std.StdSerializer;
    import org.springframework.cache.support.NullValue;
    import org.springframework.data.redis.serializer.RedisSerializer;
    import org.springframework.data.redis.serializer.SerializationException;
    import org.springframework.lang.Nullable;
    import org.springframework.util.Assert;
    import org.springframework.util.StringUtils;
    
    import java.io.IOException;
    
    /** * Generic Jackson 2-based {@link RedisSerializer} that maps {@link Object objects} to JSON using dynamic typing. * * @author Christoph Strobl * @author Mark Paluch * @author Mao Shuai * @since 1.6 */
    public class GenericJackson2JsonRedisSerializerEx implements RedisSerializer<Object> { 
    
        private final ObjectMapper mapper;
    
        /** * Creates {@link GenericJackson2JsonRedisSerializerEx} and configures {@link ObjectMapper} for default typing. */
        public GenericJackson2JsonRedisSerializerEx() { 
            this((String) null);
        }
    
        /** * Creates {@link GenericJackson2JsonRedisSerializerEx} and configures {@link ObjectMapper} for default typing using the * given {@literal name}. In case of an {@literal empty} or {@literal null} String the default * {@link JsonTypeInfo.Id#CLASS} will be used. * * @param classPropertyTypeName Name of the JSON property holding type information. Can be {@literal null}. */
        public GenericJackson2JsonRedisSerializerEx(@Nullable String classPropertyTypeName) { 
    
            this(new ObjectMapper());
    
            /** 处理java8 Time */
            mapper.registerModule(new CustomJavaTimeModule());
            
            // simply setting {@code mapper.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS)} does not help here since we need
            // the type hint embedded for deserialization using the default typing feature.
            registerNullValueSerializer(mapper, classPropertyTypeName);
    
            if (StringUtils.hasText(classPropertyTypeName)) { 
                mapper.enableDefaultTypingAsProperty(DefaultTyping.NON_FINAL, classPropertyTypeName);
            } else { 
                mapper.enableDefaultTyping(DefaultTyping.NON_FINAL, As.PROPERTY);
            }
        }
    
        /** * Setting a custom-configured {@link ObjectMapper} is one way to take further control of the JSON serialization * process. For example, an extended {@link SerializerFactory} can be configured that provides custom serializers for * specific types. * * @param mapper must not be {@literal null}. */
        public GenericJackson2JsonRedisSerializerEx(ObjectMapper mapper) { 
    
            Assert.notNull(mapper, "ObjectMapper must not be null!");
            this.mapper = mapper;
        }
    
        /** * Register {@link NullValueSerializer} in the given {@link ObjectMapper} with an optional * {@code classPropertyTypeName}. This method should be called by code that customizes * {@link GenericJackson2JsonRedisSerializerEx} by providing an external {@link ObjectMapper}. * * @param objectMapper the object mapper to customize. * @param classPropertyTypeName name of the type property. Defaults to {@code @class} if {@literal null}/empty. * @since 2.2 */
        public static void registerNullValueSerializer(ObjectMapper objectMapper, @Nullable String classPropertyTypeName) { 
    
            // simply setting {@code mapper.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS)} does not help here since we need
            // the type hint embedded for deserialization using the default typing feature.
            objectMapper.registerModule(new SimpleModule().addSerializer(new NullValueSerializer(classPropertyTypeName)));
        }
    
        /* * (non-Javadoc) * @see org.springframework.data.redis.serializer.RedisSerializer#serialize(java.lang.Object) */
        @Override
        public byte[] serialize(@Nullable Object source) throws SerializationException { 
    
            if (source == null) { 
                return new byte[0];
            }
    
            try { 
                return mapper.writeValueAsBytes(source);
            } catch (JsonProcessingException e) { 
                throw new SerializationException("Could not write JSON: " + e.getMessage(), e);
            }
        }
    
        /* * (non-Javadoc) * @see org.springframework.data.redis.serializer.RedisSerializer#deserialize(byte[]) */
        @Override
        public Object deserialize(@Nullable byte[] source) throws SerializationException { 
            return deserialize(source, Object.class);
        }
    
        /** * @param source can be {@literal null}. * @param type must not be {@literal null}. * @return {@literal null} for empty source. * @throws SerializationException */
        @Nullable
        public <T> T deserialize(@Nullable byte[] source, Class<T> type) throws SerializationException { 
    
            Assert.notNull(type,
                    "Deserialization type must not be null! Please provide Object.class to make use of Jackson2 default typing.");
    
            if (isEmpty(source)) { 
                return null;
            }
    
            try { 
                return mapper.readValue(source, type);
            } catch (Exception ex) { 
                throw new SerializationException("Could not read JSON: " + ex.getMessage(), ex);
            }
        }
    
        /** * {@link StdSerializer} adding class information required by default typing. This allows de-/serialization of * {@link NullValue}. * * @author Christoph Strobl * @since 1.8 */
        private static class NullValueSerializer extends StdSerializer<NullValue> { 
    
            private static final long serialVersionUID = 1999052150548658808L;
            private final String classIdentifier;
    
            /** * @param classIdentifier can be {@literal null} and will be defaulted to {@code @class}. */
            NullValueSerializer(@Nullable String classIdentifier) { 
    
                super(NullValue.class);
                this.classIdentifier = StringUtils.hasText(classIdentifier) ? classIdentifier : "@class";
            }
    
            /* * (non-Javadoc) * @see com.fasterxml.jackson.databind.ser.std.StdSerializer#serialize(java.lang.Object, com.fasterxml.jackson.core.JsonGenerator, com.fasterxml.jackson.databind.SerializerProvider) */
            @Override
            public void serialize(NullValue value, JsonGenerator jgen, SerializerProvider provider)
                    throws IOException { 
    
                jgen.writeStartObject();
                jgen.writeStringField(classIdentifier, NullValue.class.getName());
                jgen.writeEndObject();
            }
        }
    
        static boolean isEmpty(@Nullable byte[] data) { 
            return (data == null || data.length == 0);
        }
    }

> 直接在GenericJackson2JsonRedisSerializerEx(@Nullable String classPropertyTypeName)方法中加入  
> mapper.registerModule(new CustomJavaTimeModule());即可，CustomJavaTimeModule类在上一篇配置jackson对java8时间的支持的里面

> 小尾巴~~  
> 只要有积累，就会有进步