SpringBoot日期序列化

刺骨的言语ヽ痛彻心扉 2023-01-02 04:26 127阅读 0赞

在一个请求中存在一个时间字段，但是前端传过来的值格式有问题，由此引出本文。

### 问题： ###

*  后端接收：
    
        @Data
        @NoArgsConstructor
        @ApiModel(value = "时间参数")
        public class DateInsert { 
        
           @ApiModelProperty(value = "时间A")
           private Date a;
        
           @ApiModelProperty(value = "时间B")
           private Date b;
        }
 *  前端传输：
    
        { 
            "a":"2020-12-20T02:08:39.000Z",
            "b":"2020-12-27 07:28:36"
        }

本文的问题是，日期格式数据前端可能会传输两种过来（格式化好的以及带T的），a、b两个字段实际上是同一个字段，此处目的是同时实现两种格式数据接收。（注意，这两个字段数据类型、注解等一致）

### 解决 ###

*  全局配置序列化
    
        package com.single.cong.config;
        
        import java.io.IOException;
        import java.math.BigInteger;
        import java.nio.charset.StandardCharsets;
        import java.text.SimpleDateFormat;
        import java.time.LocalDate;
        import java.time.LocalDateTime;
        import java.time.LocalTime;
        import java.time.format.DateTimeFormatter;
        import java.util.Date;
        import java.util.List;
        import java.util.TimeZone;
        
        import org.springframework.context.annotation.Bean;
        import org.springframework.context.annotation.Configuration;
        import org.springframework.http.converter.HttpMessageConverter;
        import org.springframework.http.converter.StringHttpMessageConverter;
        import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
        import org.springframework.web.servlet.config.annotation.CorsRegistry;
        import org.springframework.web.servlet.config.annotation.WebMvcConfigurationSupport;
        
        import com.fasterxml.jackson.core.JsonGenerator;
        import com.fasterxml.jackson.core.JsonParser;
        import com.fasterxml.jackson.core.JsonProcessingException;
        import com.fasterxml.jackson.databind.DeserializationContext;
        import com.fasterxml.jackson.databind.JsonDeserializer;
        import com.fasterxml.jackson.databind.JsonSerializer;
        import com.fasterxml.jackson.databind.ObjectMapper;
        import com.fasterxml.jackson.databind.SerializerProvider;
        import com.fasterxml.jackson.databind.module.SimpleModule;
        import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
        import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
        import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateDeserializer;
        import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateTimeDeserializer;
        import com.fasterxml.jackson.datatype.jsr310.deser.LocalTimeDeserializer;
        import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateSerializer;
        import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateTimeSerializer;
        import com.fasterxml.jackson.datatype.jsr310.ser.LocalTimeSerializer;
        
        @Configuration
        public class WebMvcConfig extends WebMvcConfigurationSupport { 
        
        	/** 解决返回值乱码问题 */
        	@Bean
        	public HttpMessageConverter<String> responseBodyStringConverter() { 
        		StringHttpMessageConverter converter = new StringHttpMessageConverter(StandardCharsets.UTF_8);
        		return converter;
        	}
        
        	/** 修改StringHttpMessageConverter默认配置 */
        	@Override
        	public void configureMessageConverters(List<HttpMessageConverter<?>> converters) { 
        		converters.add(responseBodyStringConverter());
        
        		// 日期序列化配置
        		
        		JavaTimeModule javaTimeModule = new JavaTimeModule();
        		/** 序列化配置,针对java8 时间 **/
        		javaTimeModule.addSerializer(LocalDateTime.class,
        				new LocalDateTimeSerializer(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
        		javaTimeModule.addSerializer(LocalDate.class,
        				new LocalDateSerializer(DateTimeFormatter.ofPattern("yyyy-MM-dd")));
        		javaTimeModule.addSerializer(LocalTime.class, new LocalTimeSerializer(DateTimeFormatter.ofPattern("HH:mm:ss")));
        
        		/** 反序列化配置,针对java8 时间 **/
        		javaTimeModule.addDeserializer(LocalDateTime.class,
        				new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
        		javaTimeModule.addDeserializer(LocalDate.class,
        				new LocalDateDeserializer(DateTimeFormatter.ofPattern("yyyy-MM-dd")));
        		javaTimeModule.addDeserializer(LocalTime.class,
        				new LocalTimeDeserializer(DateTimeFormatter.ofPattern("HH:mm:ss")));
        		// Date序列化和反序列化
        		javaTimeModule.addSerializer(Date.class, new JsonSerializer<Date>() { 
        			@Override
        			public void serialize(Date date, JsonGenerator jsonGenerator, SerializerProvider serializerProvider)
        					throws IOException { 
        				SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        				String formattedDate = formatter.format(date);
        				jsonGenerator.writeString(formattedDate);
        			}
        		});
        		javaTimeModule.addDeserializer(Date.class, new JsonDeserializer<Date>() { 
        			@Override
        			public Date deserialize(JsonParser jsonParser, DeserializationContext deserializationContext)
        					throws IOException, JsonProcessingException { 
        				SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        				String date = jsonParser.getText();
        				// 处理数据在这里
        				try { 
        					if (date.contains("T")) { 
        						date = date.replaceAll("T", " ").substring(0, 19);
        						// 特殊格式数据,进行日期转换
        						return format.parse(date);
        					} else { 
        						// 正常数据日期转换
        						return format.parse(date);
        					}
        				} catch (Exception e) { 
        					throw new RuntimeException(e);
        				}
        			}
        		});
        		
        		
        		
        
        		MappingJackson2HttpMessageConverter messageConverter = new MappingJackson2HttpMessageConverter();
        		ObjectMapper objectMapper = new ObjectMapper();
        		SimpleModule simpleModule = new SimpleModule();
        		/** * 将Long,BigInteger序列化的时候,转化为String,某些类里面的Long类型数据超长造成精度缺失可以在属性上使用@JsonSerialize注解 */
        		simpleModule.addSerializer(Long.class, ToStringSerializer.instance);
        		simpleModule.addSerializer(Long.TYPE, ToStringSerializer.instance);
        		simpleModule.addSerializer(BigInteger.class, ToStringSerializer.instance);
        		objectMapper.registerModule(simpleModule).registerModule(javaTimeModule);
        		// objectMapper.registerModule(simpleModule);
        		objectMapper.setTimeZone(TimeZone.getTimeZone("GMT+8"));
        		objectMapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
        		messageConverter.setObjectMapper(objectMapper);
        		converters.add(messageConverter);
        	}
        }
    
    注意：`date = date.replaceAll("T", " ").substring(0, 19);`单纯是将字符串处理一下然后再格式化，没什么说的，但是要注意，如果使用此种方式，那么系统里面所有的Date类型的数据序列化都会先走一个判断，如果系统中参数格式不固定可以使用这种方式，但是肯定会带来性能上的问题。
 *  单独序列化  
    自定义类继承`JsonDeserializer`
    
        package com.single.cong.config;
        
        import java.io.IOException;
        import java.text.SimpleDateFormat;
        import java.util.Date;
        
        import com.fasterxml.jackson.core.JsonParser;
        import com.fasterxml.jackson.core.JsonProcessingException;
        import com.fasterxml.jackson.databind.DeserializationContext;
        import com.fasterxml.jackson.databind.JsonDeserializer;
        
        import lombok.extern.slf4j.Slf4j;
        
        @Slf4j
        public class MyDateSerialize extends JsonDeserializer<Date> { 
        
        	@Override
        	public Date deserialize(JsonParser jsonParser, DeserializationContext ctxt)
        			throws IOException, JsonProcessingException { 
        		log.info("参数数据为:[{}]", jsonParser.getText());
        		SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        		String date = jsonParser.getText();
        		try { 
        			if (date.contains("T")) { 
        				date = date.replaceAll("T", " ").substring(0, 19);
        				// 特殊格式数据,进行日期转换
        				return format.parse(date);
        			} else { 
        				// 正常数据日期转换
        				return format.parse(date);
        			}
        		} catch (Exception e) { 
        			throw new RuntimeException(e);
        		}
        	}
        }
    
    使用：
    
        @Data
        @NoArgsConstructor
        @ApiModel(value = "时间参数")
        public class DateInsert { 
        
        	@JsonDeserialize(using = MyDateSerialize.class)
        	@ApiModelProperty(value = "时间A")
        	private Date a;
        
        	@ApiModelProperty(value = "时间B")
        	private Date b;
        }
    
    这样就只需要对有问题的字段单独设置自定义的序列化方式，至于其他的字段不变。

### 总结 ###

*  做了什么  
    实际上这个问题就是自己搞出来的，一般只要前后端能够明确数据格式都不会出现这个问题，本文的日期格式化问题出现在反序列化中，在将参数转换为Date类型的时候因为参数的格式问题一直导致序列化失败，所以本文其实最终只做了一件事情：在反序列化之前将参数处理成正常格式。
 *  更多  
    在解决这个问题的过程中有几位网友建议将`Date`转为`LocalDateTime`类型，我查了一下，都在说`LocalDateTime`性能好，线程安全，所以建议以后还是使用`LocalDateTime`吧。

### 疑问 ###

我在解决这个问题的时候看到网上很多文章写得自定义日期转换器Converter，但是不知道为什么我按照别人说的文章写了但是没用，最后还是用的上面这两个方法。