Jackson配置

转换类（RequestParam 和 PathVariable）

编写类型 Date 的转换类

  1. package com.luoqiz.pincheng.config.date;
  3. import lombok.extern.slf4j.Slf4j;
  4. import org.springframework.core.convert.converter.Converter;
  6. import java.text.SimpleDateFormat;
  7. import java.util.Date;
  9. @Slf4j
  10. public class StringToDateConverter implements Converter<String, Date> {
  12.     private static final String dateFormat = "yyyy-MM-dd HH:mm:ss";
  13.     private static final String shortDateFormat = "yyyy-MM-dd";
  14.     private static final String timeStampFormat = "^\\d+$";
  16.     @Override
  17.     public Date convert(String value) {
  19.         if (value == null || value.trim().equals("") || value.equalsIgnoreCase("null")) {
  20.             return null;
  21.         }
  23.         value = value.trim();
  25.         try {
  26.             if (value.contains("-")) {
  27.                 SimpleDateFormat formatter;
  28.                 if (value.contains(":")) {
  29.                     formatter = new SimpleDateFormat(dateFormat);
  30.                 } else {
  31.                     formatter = new SimpleDateFormat(shortDateFormat);
  32.                 }
  33.                 return formatter.parse(value);
  34.             } else if (value.matches(timeStampFormat)) {
  35.                 Long lDate = Long.valueOf(value);
  36.                 return new Date(lDate);
  37.             }
  38.         } catch (Exception e) {
  39.             throw new RuntimeException(String.format("parser %s to Date fail", value));
  40.         }
  41.         throw new RuntimeException(String.format("parser %s to Date fail", value));
  42.     }
  43. }

编写类型 LocalDate 的转换类

  1. package com.luoqiz.pincheng.config.date;
  3. import lombok.extern.slf4j.Slf4j;
  4. import org.springframework.core.convert.converter.Converter;
  6. import java.time.Instant;
  7. import java.time.LocalDate;
  8. import java.time.ZoneOffset;
  9. import java.time.format.DateTimeFormatter;
  11. @Slf4j
  12. public class StringToLocalDateConverter implements Converter<String, LocalDate> {
  15.     private static final String dateFormat = "yyyy-MM-dd HH:mm:ss";
  16.     private static final String shortDateFormat = "yyyy-MM-dd";
  17.     private static final String timeStampFormat = "^\\d+$";
  19.     @Override
  20.     public LocalDate convert(String value) {
  22.         if (value == null || value.trim().equals("") || value.equalsIgnoreCase("null")) {
  23.             return null;
  24.         }
  26.         value = value.trim();
  28.         try {
  29.             if (value.contains("-")) {
  30.                 DateTimeFormatter formatter;
  31.                 if (value.contains(":")) {
  32.                     formatter = DateTimeFormatter.ofPattern(dateFormat);
  33.                 } else {
  34.                     formatter = DateTimeFormatter.ofPattern(shortDateFormat);
  35.                 }
  36.                 return LocalDate.parse(value, formatter);
  37.             } else if (value.matches(timeStampFormat)) {
  38.                 Long timestamp = Long.valueOf(value);
  39.                 return Instant.ofEpochMilli(timestamp).atZone(ZoneOffset.systemDefault()).toLocalDate();
  40.             }
  41.         } catch (Exception e) {
  42.             throw new RuntimeException(String.format("parser %s to LocalDate fail", value));
  43.         }
  44.         throw new RuntimeException(String.format("parser %s to LocalDate fail", value));
  45.     }
  46. }

编写类型 LocalDateTime 的转换类

  1. package com.luoqiz.pincheng.config.date;
  4. import lombok.extern.slf4j.Slf4j;
  5. import org.springframework.core.convert.converter.Converter;
  7. import java.time.Instant;
  8. import java.time.LocalDateTime;
  9. import java.time.ZoneOffset;
  10. import java.time.format.DateTimeFormatter;
  12. @Slf4j
  13. public class StringToLocalDateTimeConverter implements Converter<String, LocalDateTime> {
  16.     private static final String dateFormat = "yyyy-MM-dd HH:mm:ss";
  17.     private static final String timeStampFormat = "^\\d+$";
  19.     @Override
  20.     public LocalDateTime convert(String value) {
  22.         if (value == null || value.trim().equals("") || value.equalsIgnoreCase("null")) {
  23.             return null;
  24.         }
  26.         value = value.trim();
  28.         try {
  29.             if (value.contains("-")) {
  30.                 return LocalDateTime.parse(value, DateTimeFormatter.ofPattern(dateFormat));
  31.             } else if (value.matches(timeStampFormat)) {
  32.                 Long timestamp = Long.valueOf(value);
  33.                 return Instant.ofEpochMilli(timestamp).atZone(ZoneOffset.systemDefault()).toLocalDateTime();
  34.             }
  35.         } catch (Exception e) {
  36.             throw new RuntimeException(String.format("parser %s to LocalDateTime fail", value));
  37.         }
  38.         throw new RuntimeException(String.format("parser %s to LocalDateTime fail", value));
  39.     }
  40. }

配置

  1. public class WebMvcConfig implements WebMvcConfigurer {
  3.     /**
  4.      * 添加自定义的Converters和Formatters.
  5.      */
  6.     @Override
  7.     public void addFormatters(FormatterRegistry registry) {
  8.         registry.addConverter(new StringToDateConverter());
  9.         registry.addConverter(new StringToLocalDateConverter());
  10.         registry.addConverter(new StringToLocalDateTimeConverter());
  11.     }
  12. }

序列化类（RequestBody）

转为字符串

  1. package com.luoqiz.pincheng.config.date;
  3. import com.fasterxml.jackson.core.JsonGenerator;
  4. import com.fasterxml.jackson.core.JsonParser;
  5. import com.fasterxml.jackson.core.JsonProcessingException;
  6. import com.fasterxml.jackson.databind.*;
  7. import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
  8. import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateDeserializer;
  9. import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateTimeDeserializer;
  10. import com.fasterxml.jackson.datatype.jsr310.deser.LocalTimeDeserializer;
  11. import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateSerializer;
  12. import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateTimeSerializer;
  13. import com.fasterxml.jackson.datatype.jsr310.ser.LocalTimeSerializer;
  14. import lombok.extern.slf4j.Slf4j;
  15. import org.springframework.context.annotation.Bean;
  16. import org.springframework.context.annotation.Configuration;
  18. import java.io.IOException;
  19. import java.text.ParseException;
  20. import java.text.SimpleDateFormat;
  21. import java.time.*;
  22. import java.time.format.DateTimeFormatter;
  23. import java.util.Date;
  25. @Configuration
  26. @Slf4j
  27. public class DateConfig {
  29.     /**
  30.      * 默认日期时间格式
  31.      */
  32.     public static final String DEFAULT_DATE_TIME_FORMAT = "yyyy-MM-dd HH:mm:ss";
  33.     /**
  34.      * 默认日期格式
  35.      */
  36.     public static final String DEFAULT_DATE_FORMAT = "yyyy-MM-dd";
  37.     /**
  38.      * 默认时间格式
  39.      */
  40.     public static final String DEFAULT_TIME_FORMAT = "HH:mm:ss";
  42.     private static final String timeStampFormat = "^\\d+$";
  44.     /**
  45.      * Json序列化和反序列化转换器，用于转换Post请求体中的json以及将我们的对象序列化为返回响应的json
  46.      */
  47.     @Bean
  48.     public ObjectMapper objectMapper() {
  49.         ObjectMapper objectMapper = new ObjectMapper();
  50.         objectMapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
  51.         objectMapper.disable(DeserializationFeature.ADJUST_DATES_TO_CONTEXT_TIME_ZONE);
  53.         //LocalDateTime系列序列化和反序列化模块，继承自jsr310，我们在这里修改了日期格式
  54.         JavaTimeModule javaTimeModule = new JavaTimeModule();
  56.         javaTimeModule.addSerializer(LocalDateTime.class, new LocalDateTimeSerializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_TIME_FORMAT)));
  57.         javaTimeModule.addSerializer(LocalDate.class, new LocalDateSerializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_FORMAT)));
  58.         javaTimeModule.addSerializer(LocalTime.class, new LocalTimeSerializer(DateTimeFormatter.ofPattern(DEFAULT_TIME_FORMAT)));
  60.         javaTimeModule.addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_TIME_FORMAT)));
  61.         javaTimeModule.addDeserializer(LocalDate.class, new LocalDateDeserializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_FORMAT)));
  62.         javaTimeModule.addDeserializer(LocalTime.class, new LocalTimeDeserializer(DateTimeFormatter.ofPattern(DEFAULT_TIME_FORMAT)));
  65.         //Date序列化和反序列化
  66.         javaTimeModule.addSerializer(Date.class, new JsonSerializer<Date>() {
  67.             @Override
  68.             public void serialize(Date date, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException {
  69.                 SimpleDateFormat formatter = new SimpleDateFormat(DEFAULT_DATE_TIME_FORMAT);
  70.                 String formattedDate = formatter.format(date);
  71.                 jsonGenerator.writeString(formattedDate);
  72.             }
  73.         });
  75.         javaTimeModule.addDeserializer(Date.class, new JsonDeserializer<Date>() {
  76.             @Override
  77.             public Date deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException, JsonProcessingException {
  78.                 String value = jsonParser.getText();
  79.                 if (value == null || value.trim().equals("") || value.equalsIgnoreCase("null")) {
  80.                     return null;
  81.                 }
  82.                 if (value.matches(timeStampFormat)) {
  83.                     Long timestamp = Long.valueOf(value);
  84.                     return new Date(timestamp);
  85.                 }
  87.                 SimpleDateFormat format = new SimpleDateFormat(DEFAULT_DATE_TIME_FORMAT);
  89.                 try {
  90.                     return format.parse(value);
  91.                 } catch (ParseException e) {
  92.                     throw new RuntimeException(e);
  93.                 }
  94.             }
  95.         });
  97.         objectMapper.registerModule(javaTimeModule);
  98.         return objectMapper;
  99.     }
  102. }

转为时间戳

  1. import com.fasterxml.jackson.core.JsonGenerator;
  2. import com.fasterxml.jackson.core.JsonParser;
  3. import com.fasterxml.jackson.core.JsonProcessingException;
  4. import com.fasterxml.jackson.databind.*;
  5. import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
  6. import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateDeserializer;
  7. import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateTimeDeserializer;
  8. import com.fasterxml.jackson.datatype.jsr310.deser.LocalTimeDeserializer;
  9. import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateSerializer;
  10. import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateTimeSerializer;
  11. import com.fasterxml.jackson.datatype.jsr310.ser.LocalTimeSerializer;
  12. import lombok.extern.slf4j.Slf4j;
  13. import org.springframework.context.annotation.Bean;
  14. import org.springframework.context.annotation.Configuration;
  15. import org.springframework.context.annotation.Primary;
  17. import java.io.IOException;
  18. import java.text.ParseException;
  19. import java.text.SimpleDateFormat;
  20. import java.time.*;
  21. import java.time.format.DateTimeFormatter;
  22. import java.util.Date;
  24. /**
  25.  * @author luoqiz
  26.  */
  27. @Configuration
  28. @Slf4j
  29. public class DateConfig {
  31.     /**
  32.      * 默认日期时间格式
  33.      */
  34.     public static final String DEFAULT_DATE_TIME_FORMAT = "yyyy-MM-dd HH:mm:ss";
  35.     /**
  36.      * 默认日期格式
  37.      */
  38.     public static final String DEFAULT_DATE_FORMAT = "yyyy-MM-dd";
  39.     /**
  40.      * 默认时间格式
  41.      */
  42.     public static final String DEFAULT_TIME_FORMAT = "HH:mm:ss";
  44.     private static final String timeStampFormat = "^\\d+$";
  46.     /**
  47.      * Json序列化和反序列化转换器，用于转换Post请求体中的json以及将我们的对象序列化为返回响应的json
  48.      */
  49.     @Bean
  50.     @Primary
  51.     public ObjectMapper objectMapper() {
  52.         ObjectMapper objectMapper = new ObjectMapper();
  53.         objectMapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
  54.         objectMapper.disable(DeserializationFeature.ADJUST_DATES_TO_CONTEXT_TIME_ZONE);
  56.         //LocalDateTime系列序列化和反序列化模块，继承自jsr310，我们在这里修改了日期格式
  57.         JavaTimeModule javaTimeModule = new JavaTimeModule();
  59. //        javaTimeModule.addSerializer(LocalDateTime.class, new LocalDateTimeSerializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_TIME_FORMAT)));
  60. //        javaTimeModule.addSerializer(LocalDate.class, new LocalDateSerializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_FORMAT)));
  61. //        javaTimeModule.addSerializer(LocalTime.class, new LocalTimeSerializer(DateTimeFormatter.ofPattern(DEFAULT_TIME_FORMAT)));
  62. //
  63. //        javaTimeModule.addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_TIME_FORMAT)));
  64. //        javaTimeModule.addDeserializer(LocalDate.class, new LocalDateDeserializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_FORMAT)));
  65. //        javaTimeModule.addDeserializer(LocalTime.class, new LocalTimeDeserializer(DateTimeFormatter.ofPattern(DEFAULT_TIME_FORMAT)));
  68.         javaTimeModule.addSerializer(LocalDateTime.class, new LocalDateTimeSerializer());
  69.         javaTimeModule.addSerializer(LocalDate.class, new LocalDateSerializer());
  70.         javaTimeModule.addSerializer(LocalTime.class, new LocalTimeSerializer(DateTimeFormatter.ofPattern(DEFAULT_TIME_FORMAT)));
  71.         javaTimeModule.addSerializer(Date.class, new DateSerializer());
  73.         javaTimeModule.addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer());
  74.         javaTimeModule.addDeserializer(LocalDate.class, new LocalDateDeserializer());
  75.         javaTimeModule.addDeserializer(LocalTime.class, new LocalTimeDeserializer(DateTimeFormatter.ofPattern(DEFAULT_TIME_FORMAT)));
  76.         javaTimeModule.addDeserializer(Date.class, new DateDeserializer());
  78.         objectMapper.registerModule(javaTimeModule);
  79.         return objectMapper;
  80.     }
  82.     /**
  83.      * 序列化实现 Date 转为时间戳
  84.      */
  85.     public static class DateSerializer extends JsonSerializer<Date> {
  86.         @Override
  87.         public void serialize(Date value, JsonGenerator gen, SerializerProvider serializers)
  88.                 throws IOException {
  89.             if (value != null) {
  90.                 long timestamp = value.getTime();
  91.                 gen.writeNumber(timestamp);
  92.             }
  93.         }
  94.     }
  96.     /**
  97.      * 反序列化实现 时间戳转为 Date
  98.      */
  99.     public static class DateDeserializer extends JsonDeserializer<Date> {
  100.         @Override
  101.         public Date deserialize(JsonParser p, DeserializationContext deserializationContext)
  102.                 throws IOException {
  103.             long timestamp = p.getValueAsLong();
  104.             if (timestamp > 0) {
  105.                 return new Date(timestamp);// .ofInstant(Instant.ofEpochMilli(timestamp), ZoneId.systemDefault());
  106.             } else {
  107.                 return null;
  108.             }
  109.         }
  110.     }
  113.     /**
  114.      * 序列化实现 LocalDate 转为时间戳
  115.      */
  116.     public static class LocalDateSerializer extends JsonSerializer<LocalDate> {
  117.         @Override
  118.         public void serialize(LocalDate value, JsonGenerator gen, SerializerProvider serializers)
  119.                 throws IOException {
  120.             if (value != null) {
  121.                 long timestamp = value.atStartOfDay(ZoneId.systemDefault()).toInstant().toEpochMilli();// .toEpochDay();// .atZone(ZoneId.systemDefault()).toInstant().toEpochMilli();
  122.                 gen.writeNumber(timestamp);
  123.             }
  124.         }
  125.     }
  127.     /**
  128.      * 反序列化实现 时间戳转为 LocalDate
  129.      */
  130.     public static class LocalDateDeserializer extends JsonDeserializer<LocalDate> {
  131.         @Override
  132.         public LocalDate deserialize(JsonParser p, DeserializationContext deserializationContext)
  133.                 throws IOException {
  134.             long timestamp = p.getValueAsLong();
  135.             if (timestamp > 0) {
  136.                 return Instant.ofEpochMilli(timestamp).atZone(ZoneId.systemDefault()).toLocalDate();// .ofInstant(Instant.ofEpochMilli(timestamp), ZoneId.systemDefault());
  137.             } else {
  138.                 return null;
  139.             }
  140.         }
  141.     }
  143.     /**
  144.      * 序列化实现 LocalDateTime 转为时间戳
  145.      */
  146.     public static class LocalDateTimeSerializer extends JsonSerializer<LocalDateTime> {
  147.         @Override
  148.         public void serialize(LocalDateTime value, JsonGenerator gen, SerializerProvider serializers)
  149.                 throws IOException {
  150.             if (value != null) {
  151.                 long timestamp = value.atZone(ZoneId.systemDefault()).toInstant().toEpochMilli();
  152.                 gen.writeNumber(timestamp);
  153.             }
  154.         }
  155.     }
  157.     /**
  158.      * 反序列化实现 时间戳转为 LocalDateTime
  159.      */
  160.     public static class LocalDateTimeDeserializer extends JsonDeserializer<LocalDateTime> {
  161.         @Override
  162.         public LocalDateTime deserialize(JsonParser p, DeserializationContext deserializationContext)
  163.                 throws IOException {
  164.             long timestamp = p.getValueAsLong();
  165.             if (timestamp > 0) {
  166.                 return LocalDateTime.ofInstant(Instant.ofEpochMilli(timestamp), ZoneId.systemDefault());
  167.             } else {
  168.                 return null;
  169.             }
  170.         }
  171.     }
  173. }

自定义解析类（无RequestParam、PathVariable、RequestBody）

编写 LocalDate 解析类

  2. import org.springframework.core.MethodParameter;
  3. import org.springframework.web.bind.support.WebDataBinderFactory;
  4. import org.springframework.web.context.request.NativeWebRequest;
  5. import org.springframework.web.context.request.ServletWebRequest;
  6. import org.springframework.web.method.support.HandlerMethodArgumentResolver;
  7. import org.springframework.web.method.support.ModelAndViewContainer;
  9. import javax.servlet.http.HttpServletRequest;
  10. import java.time.Instant;
  11. import java.time.LocalDate;
  12. import java.time.ZoneOffset;
  13. import java.time.format.DateTimeFormatter;
  15. public class LocalDateHandlerMethodArgumentResolver implements HandlerMethodArgumentResolver {
  16.     @Override
  17.     public boolean supportsParameter(MethodParameter parameter) {
  18.         return LocalDate.class.equals(parameter.getParameterType());
  19.     }
  21.     @Override
  22.     public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer, NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {
  24.         ServletWebRequest servletWebRequest = (ServletWebRequest) webRequest;
  25.         HttpServletRequest httpServletRequest = servletWebRequest.getRequest();
  26.         String key = parameter.getParameter().getName();
  27.         String value = httpServletRequest.getParameter(key);
  28.         // 获取 contentType
  29. //        String contentType = httpServletRequest.getContentType();
  30.         // 获取支持媒体类型
  31. //        MediaType mediaType = MediaType.parseMediaType(contentType);
  32. //        Charset charset = mediaType.getCharset();
  33. //        charset = charset == null ? StandardCharsets.UTF_8 : charset;
  34. //        ServletInputStream in = httpServletRequest.getInputStream();
  36.         return convert(value);
  37.     }
  39.     private static final String dateFormat = "yyyy-MM-dd HH:mm:ss";
  40.     private static final String shortDateFormat = "yyyy-MM-dd";
  41.     private static final String timeStampFormat = "^\\d+$";
  43.     public LocalDate convert(String value) {
  45.         if (value == null || value.trim().equals("") || value.equalsIgnoreCase("null")) {
  46.             return null;
  47.         }
  49.         value = value.trim();
  51.         try {
  52.             if (value.contains("-")) {
  53.                 DateTimeFormatter formatter;
  54.                 if (value.contains(":")) {
  55.                     formatter = DateTimeFormatter.ofPattern(dateFormat);
  56.                 } else {
  57.                     formatter = DateTimeFormatter.ofPattern(shortDateFormat);
  58.                 }
  59.                 return LocalDate.parse(value, formatter);
  60.             } else if (value.matches(timeStampFormat)) {
  61.                 Long timestamp = Long.valueOf(value);
  62.                 return Instant.ofEpochMilli(timestamp).atZone(ZoneOffset.systemDefault()).toLocalDate();
  63.             }
  64.         } catch (Exception e) {
  65.             throw new RuntimeException(String.format("parser %s to LocalDate fail", value));
  66.         }
  67.         throw new RuntimeException(String.format("parser %s to LocalDate fail", value));
  68.     }
  69. }

编写 LocalDateTime 解析类

  1. import org.springframework.core.MethodParameter;
  2. import org.springframework.web.bind.support.WebDataBinderFactory;
  3. import org.springframework.web.context.request.NativeWebRequest;
  4. import org.springframework.web.context.request.ServletWebRequest;
  5. import org.springframework.web.method.support.HandlerMethodArgumentResolver;
  6. import org.springframework.web.method.support.ModelAndViewContainer;
  8. import javax.servlet.http.HttpServletRequest;
  9. import java.time.Instant;
  10. import java.time.LocalDateTime;
  11. import java.time.ZoneOffset;
  12. import java.time.format.DateTimeFormatter;
  14. public class LocalDateTimeHandlerMethodArgumentResolver implements HandlerMethodArgumentResolver {
  15.     @Override
  16.     public boolean supportsParameter(MethodParameter parameter) {
  17.         return LocalDateTime.class.equals(parameter.getParameterType());
  18.     }
  20.     @Override
  21.     public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer, NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception {
  23.         ServletWebRequest servletWebRequest = (ServletWebRequest) webRequest;
  24.         HttpServletRequest httpServletRequest = servletWebRequest.getRequest();
  25.         String key = parameter.getParameter().getName();
  26.         String value = httpServletRequest.getParameter(key);
  27.         return convert(value);
  28.     }
  30.     private static final String dateFormat = "yyyy-MM-dd HH:mm:ss";
  31.     private static final String timeStampFormat = "^\\d+$";
  33.     public LocalDateTime convert(String value) {
  35.         if (value == null || value.trim().equals("") || value.equalsIgnoreCase("null")) {
  36.             return null;
  37.         }
  39.         value = value.trim();
  41.         try {
  42.             if (value.contains("-")) {
  43.                 return LocalDateTime.parse(value, DateTimeFormatter.ofPattern(dateFormat));
  44.             } else if (value.matches(timeStampFormat)) {
  45.                 Long timestamp = Long.valueOf(value);
  46.                 return Instant.ofEpochMilli(timestamp).atZone(ZoneOffset.systemDefault()).toLocalDateTime();
  47.             }
  48.         } catch (Exception e) {
  49.             throw new RuntimeException(String.format("parser %s to LocalDateTime fail", value));
  50.         }
  51.         throw new RuntimeException(String.format("parser %s to LocalDateTime fail", value));
  52.     }
  53. }

配置

  1. public class CommonWebMvcConfig implements WebMvcConfigurer {
  3.     /**
  4.      * 因为自定义的 HandlerMethodArgumentResolver，会放在
  5.      * {@link RequestMappingHandlerAdapter#customArgumentResolvers} 中，
  6.      * 而customArgumentResolvers自定义解析类会放在最后，为防止这种情况
  7.      * 所以放在 PostConstruct 中提升自定义的解析类位置
  8.      */
  9.     @PostConstruct
  10.     public void init() {
  11.         // 获取已存在的参数解析类
  12.         List<HandlerMethodArgumentResolver> oldHandlerMethodArgumentResolver = requestMappingHandlerAdapter.getArgumentResolvers();
  13.         List<HandlerMethodArgumentResolver> newHandlerMethodArgumentResolver = new ArrayList<>(oldHandlerMethodArgumentResolver.size() + 1);
  14.         // 设置自定义的解析
  15.         newHandlerMethodArgumentResolver.add(new LocalDateHandlerMethodArgumentResolver());
  16.         newHandlerMethodArgumentResolver.addAll(oldHandlerMethodArgumentResolver);
  17.         requestMappingHandlerAdapter.setArgumentResolvers(newHandlerMethodArgumentResolver);
  18.     }
  20.     ...
  22. }

FastJson配置

转换类（RequestParam 和 PathVariable）和自定义解析类

同上

序列化类

  1. @Configuration
  2. public class JsonHttpMessageConverConfiguration {
  4.     @Primary
  5.     @Bean
  6.     @ConditionalOnProperty(name = { "spring.http.converters.preferred-json-mapper" }, havingValue = "fastJson")
  7.     @ConditionalOnMissingBean({ FastJsonHttpMessageConverter.class }) // 3
  8.     public HttpMessageConverter<?> fastJsonHttpMessageConverter() {
  9.         // 1、需要先定义一个 convert 转换消息的对象;
  10.         FastJsonHttpMessageConverter fastConverter = new FastJsonHttpMessageConverter();
  11.         List<MediaType> supportedMediaTypes = new ArrayList<>();
  12.         supportedMediaTypes.add(MediaType.APPLICATION_JSON_UTF8);
  13.         supportedMediaTypes.add(MediaType.APPLICATION_FORM_URLENCODED);
  14.         supportedMediaTypes.add(MediaType.APPLICATION_OCTET_STREAM);
  15.         supportedMediaTypes.add(MediaType.APPLICATION_PDF);
  16.         supportedMediaTypes.add(MediaType.IMAGE_GIF);
  17.         supportedMediaTypes.add(MediaType.IMAGE_JPEG);
  18.         supportedMediaTypes.add(MediaType.IMAGE_PNG);
  19. //        supportedMediaTypes.add(MediaType.TEXT_EVENT_STREAM);
  20. //        supportedMediaTypes.add(MediaType.TEXT_HTML);
  21.         supportedMediaTypes.add(MediaType.TEXT_MARKDOWN);
  22.         fastConverter.setSupportedMediaTypes(supportedMediaTypes);
  23.         // 2、添加fastJson 的配置信息，比如：是否要格式化返回的json数据;
  24.         FastJsonConfigExt fastJsonConfig = new FastJsonConfigExt();
  25.         // 修改配置返回内容的过滤
  26.         // WriteNullListAsEmpty ：List字段如果为null,输出为[],而非null
  27.         // WriteNullStringAsEmpty ： 字符类型字段如果为null,输出为"",而非null
  28.         // DisableCircularReferenceDetect ：消除对同一对象循环引用的问题，默认为false（如果不配置有可能会进入死循环）
  29.         // WriteNullBooleanAsFalse：Boolean字段如果为null,输出为false,而非null
  30.         // WriteMapNullValue：是否输出值为null的字段,默认为false
  31.         // SerializerFeature.BrowserCompatible： 兼容浏览器，开启的话会将中文转为Unicode字符
  32.         fastJsonConfig.setSerializerFeatures(SerializerFeature.DisableCircularReferenceDetect,
  33.                 SerializerFeature.PrettyFormat,
  34.                 SerializerFeature.WriteMapNullValue);
  35. //2、添加fastjson的配置信息，比如是否要格式化返回的json数据；
  36. //        FastJsonConfig fastJsonConfig=new FastJsonConfig();
  37. //        fastJsonConfig.setSerializerFeatures(SerializerFeature.PrettyFormat);
  38. ////附加：处理中文乱码
  39. //        List<MediaType> fastMedisTypes = new ArrayList<MediaType>();
  40. //        fastMedisTypes.add(MediaType.APPLICATION_JSON_UTF8);
  41. //        fastConverter.setSupportedMediaTypes(fastMedisTypes);
  42. ////3、在convert中添加配置信息
  43. //        fastConverter.setFastJsonConfig(fastJsonConfig);
  44. //        converters.add(fastConverter);
  45.         // 设置null字段为字符串
  46. //        ValueFilter valueFilter = new ValueFilter() {// 5
  47. //            // o 是class
  48. //            // s 是key值
  49. //            // o1 是value值
  50. //            public Object process(Object o, String s, Object o1) {
  51. //                if (null == o1) {
  52. //                    o1 = "";
  53. //                }
  54. //                return o1;
  55. //            }
  56. //        };
  57. //设置数据过滤
  58.         // fastJsonConfig.setSerializeFilters(valueFilter);
  59.         // 3、在convert中添加配置信息.
  60.         fastConverter.setFastJsonConfig(fastJsonConfig);
  61.         return fastConverter;
  62.     }
  63. }

FastJsonConfigExt.java

  1. import com.alibaba.fastjson.parser.deserializer.Jdk8DateCodec;
  2. import com.alibaba.fastjson.serializer.DateCodec;
  3. import com.alibaba.fastjson.serializer.SerializeConfig;
  4. import com.alibaba.fastjson.serializer.ToStringSerializer;
  5. import com.alibaba.fastjson.support.config.FastJsonConfig;
  7. import java.math.BigInteger;
  8. import java.time.LocalDate;
  9. import java.time.LocalDateTime;
  10. import java.util.Date;
  12. public class FastJsonConfigExt extends FastJsonConfig {
  14.     public FastJsonConfigExt() {
  15.         super();
  16.         SerializeConfig serializeConfig = SerializeConfig.globalInstance;
  17.         serializeConfig.put(BigInteger.class, ToStringSerializer.instance);
  18.         serializeConfig.put(Long.class, ToStringSerializer.instance);
  19.         serializeConfig.put(Long.TYPE, ToStringSerializer.instance);
  20.         serializeConfig.put(Date.class, DateCodec.instance);
  21.         serializeConfig.put(LocalDate.class, Jdk8DateCodec.instance);
  22.         serializeConfig.put(LocalDateTime.class, Jdk8DateCodec.instance);
  23.         this.setSerializeConfig(serializeConfig);
  24.     }
  26. }