關於Springboot日期時間格式化處理方式總結

阿新 • • 發佈：2020-03-05

專案中使用LocalDateTime系列作為DTO中時間的資料型別，但是SpringMVC收到引數後總報錯，為了配置全域性時間型別轉換，嘗試瞭如下處理方式。

注：本文基於Springboot2.x測試，如果無法生效可能是spring版本較低導致的。PS：如果你的Controller中的LocalDate型別的引數啥註解（RequestParam、PathVariable等）都沒加，也是會出錯的，因為預設情況下，解析這種引數是使用ModelAttributeMethodProcessor進行處理，而這個處理器要通過反射例項化一個物件出來，然後再對物件中的各個引數進行convert，但是LocalDate類沒有建構函式，無法反射例項化因此會報錯！！！

本文原始碼解析部分引用自 Spring中使用LocalDateTime、LocalDate等引數作為入參，原文寫的很精彩，建議仔細閱讀！！！

完成目標

請求入參為 String（指定格式）轉 Date，支援get、post（content-type=application/json）
返回資料為Date型別轉為指定的日期時間格式字元創
支援Java8 日期 API，如：LocalTime、localDate 和 LocalDateTime

GET請求及POST表單日期時間字串格式轉換

這種情況要和時間作為Json字串時區別對待，因為前端json轉後端pojo底層使用的是Json序列化Jackson工具（HttpMessgeConverter）；而時間字串作為普通請求引數傳入時，轉換用的是Converter，兩者在處理方式上是有區別。

使用自定義引數轉換器（Converter）

實現 org.springframework.core.convert.converter.Converter，自定義引數轉換器，如下：

@Configuration
public class DateConverterConfig {
  @Bean
  public Converter<String,LocalDate> localDateConverter() {
    return new Converter<>() {
      @Override
      public LocalDate convert(String source) {
        return LocalDate.parse(source,DateTimeFormatter.ofPattern("yyyy-MM-dd"));
      }
    };
  }

  @Bean
  public Converter<String,LocalDateTime> localDateTimeConverter() {
    return new Converter<>() {
      @Override
      public LocalDateTime convert(String source) {
        return LocalDateTime.parse(source,DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
      }
    };
  }

}

點評：以上兩個bean會注入到spring mvc的引數解析器（好像叫做ParameterConversionService），當傳入的字串要轉為LocalDateTime類時，spring會呼叫該Converter對這個入參進行轉換。

還可以對前端傳遞的string進行正則匹配，如yyyy-MM-dd HH:mm:ss、yyyy-MM-dd、 HH:mm:ss等，進行匹配。以適應多種場景。

@Component
public class DateConverter implements Converter<String,Date> {

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

  @Override
  public Date convert(String value) {
    /**
     * 可對value進行正則匹配，支援日期、時間等多種型別轉換
     * @param value
     * @return
     */
    SimpleDateFormat formatter = new SimpleDateFormat(dateFormat);
    try {
      return formatter.parse(value);
    } catch (Exception e) {
      throw new RuntimeException(String.format("parser %s to Date fail",value));
    }
  }
}

使用Spring註解

使用spring自帶註解@DateTimeFormat(pattern = "yyyy-MM-dd")，如下：

@DateTimeFormat(pattern = "yyyy-MM-dd")
private Date startDate;

如果使用了自定義引數轉化器，Spring會優先使用該方式進行處理，即Spring註解不生效。

使用ControllerAdvice配合initBinder

@ControllerAdvice
public class GlobalExceptionHandler {

  @InitBinder
  protected void initBinder(WebDataBinder binder) {
    binder.registerCustomEditor(LocalDate.class,new PropertyEditorSupport() {
      @Override
      public void setAsText(String text) throws IllegalArgumentException {
        setValue(LocalDate.parse(text,DateTimeFormatter.ofPattern("yyyy-MM-dd")));
      }
    });
    binder.registerCustomEditor(LocalDateTime.class,new PropertyEditorSupport() {
      @Override
      public void setAsText(String text) throws IllegalArgumentException {
        setValue(LocalDateTime.parse(text,DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
      }
    });
    binder.registerCustomEditor(LocalTime.class,new PropertyEditorSupport() {
      @Override
      public void setAsText(String text) throws IllegalArgumentException {
        setValue(LocalTime.parse(text,DateTimeFormatter.ofPattern("HH:mm:ss")));
      }
    });
  }
}

從名字就可以看出來，這是在controller做環切（這裡面還可以全域性異常捕獲），在引數進入handler之前進行轉換；轉換為我們相應的物件。

JSON入參及返回值全域性處理

請求型別為:post,content-type=application/json，後臺用@RequestBody接收，預設接收及返回值格式為: yyyy-MM-dd HH:mm:ss

修改 application.yml 檔案

在application.propertities檔案中增加如下內容：

spring:
  jackson:
    date-format: yyyy-MM-dd HH:mm:ss
    time-zone: GMT+8

支援（content-type=application/json）請求中格式為 yyyy-MM-dd HH:mm:ss的字串，後臺用@RequestBody接收，及返回值date轉為yyyy-MM-dd HH:mm:ss格式string；
不支援（content-type=application/json）請求中yyyy-MM-dd等型別的字串轉為date；
不支援java8日期api;

利用Jackson的JSON序列化和反序列化

@Configuration
public class JacksonConfig {

  /** 預設日期時間格式 */
  public static final String DEFAULT_DATE_TIME_FORMAT = "yyyy-MM-dd HH:mm:ss";
  /** 預設日期格式 */
  public static final String DEFAULT_DATE_FORMAT = "yyyy-MM-dd";
  /** 預設時間格式 */
  public static final String DEFAULT_TIME_FORMAT = "HH:mm:ss";

  @Bean
  public MappingJackson2HttpMessageConverter mappingJackson2HttpMessageConverter() {
    MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter();
    ObjectMapper objectMapper = new ObjectMapper();

    // 忽略json字串中不識別的屬性
    objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES,false);
    // 忽略無法轉換的物件 
    objectMapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS,false);
    // PrettyPrinter 格式化輸出
    objectMapper.configure(SerializationFeature.INDENT_OUTPUT,true);
    // NULL不參與序列化
    objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);

    // 指定時區
    objectMapper.setTimeZone(TimeZone.getTimeZone("GMT+8:00"));
    // 日期型別字串處理
    objectMapper.setDateFormat(new SimpleDateFormat(DEFAULT_DATE_TIME_FORMAT));

    // java8日期日期處理
    JavaTimeModule javaTimeModule = new JavaTimeModule();
    javaTimeModule.addSerializer(LocalDateTime.class,new LocalDateTimeSerializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_TIME_FORMAT)));
    javaTimeModule.addSerializer(LocalDate.class,new LocalDateSerializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_FORMAT)));
    javaTimeModule.addSerializer(LocalTime.class,new LocalTimeSerializer(DateTimeFormatter.ofPattern(DEFAULT_TIME_FORMAT)));
    javaTimeModule.addDeserializer(LocalDateTime.class,new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_TIME_FORMAT)));
    javaTimeModule.addDeserializer(LocalDate.class,new LocalDateDeserializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_FORMAT)));
    javaTimeModule.addDeserializer(LocalTime.class,new LocalTimeDeserializer(DateTimeFormatter.ofPattern(DEFAULT_TIME_FORMAT)));
    objectMapper.registerModule(javaTimeModule);

    converter.setObjectMapper(objectMapper);
    return converter;
  }
}

總結：

支援（content-type=application/json）請求中格式為yyyy-MM-dd HH:mm:ss的字串，後臺用@RequestBody接收，及返回值Date轉為yyyy-MM-dd HH:mm:ss格式String；
支援java8日期api；
不支援（content-type=application/json）請求中yyyy-MM-dd等型別的字串轉為Date；

以上兩種方式為JSON入參的全域性化處理，推薦使用方式二，尤其適合大型專案在基礎包中全域性設定。

JSON入參及返回值區域性差異化處理

場景：假如全域性日期時間處理格式為：yyyy-MM-dd HH:mm:ss，但是某個欄位要求接收或返回日期yyyy-MM-dd。

方式一

使用springboot自帶的註解@JsonFormat(pattern = "yyyy-MM-dd")，如下所示：

@JsonFormat(pattern = "yyyy-MM-dd",timezone="GMT+8")
private Date releaseDate;

點評： springboot預設提供，功能強大，滿足常見場景使用，並可指定時區。

方式二

自定義日期序列化與反序列化，如下所示：

/**
 * 日期序列化
 */
public class DateJsonSerializer extends JsonSerializer<Date> {
  @Override
  public void serialize(Date date,JsonGenerator jsonGenerator,SerializerProvider serializerProvider) throws
      IOException {
    SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
    jsonGenerator.writeString(dateFormat.format(date));
  }
}

/**
 * 日期反序列化
 */
public class DateJsonDeserializer extends JsonDeserializer<Date> {

  @Override
  public Date deserialize(JsonParser jsonParser,DeserializationContext deserializationContext) throws IOException {
    try {
      SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
      return dateFormat.parse(jsonParser.getText());
    } catch (ParseException e) {
      throw new RuntimeException(e);
    }
  }
}

/**
 * 使用方式
 */
@JsonSerialize(using = DateJsonSerializer.class)
@JsonDeserialize(using = DateJsonDeserializer.class)
private Date releaseDate;

日期時間格式化處理方式完整配置

@Configuration
public class DateHandlerConfig {

  /** 預設日期時間格式 */
  public static final String DEFAULT_DATE_TIME_FORMAT = "yyyy-MM-dd HH:mm:ss";
  /** 預設日期格式 */
  public static final String DEFAULT_DATE_FORMAT = "yyyy-MM-dd";
  /** 預設時間格式 */
  public static final String DEFAULT_TIME_FORMAT = "HH:mm:ss";

  /**
   * LocalDate轉換器，用於轉換RequestParam和PathVariable引數
   */
  @Bean
  public Converter<String,DateTimeFormatter.ofPattern(DEFAULT_DATE_FORMAT));
      }
    };
  }

  /**
   * LocalDateTime轉換器，用於轉換RequestParam和PathVariable引數
   */
  @Bean
  public Converter<String,DateTimeFormatter.ofPattern(DEFAULT_DATE_TIME_FORMAT));
      }
    };
  }

  /**
   * LocalTime轉換器，用於轉換RequestParam和PathVariable引數
   */
  @Bean
  public Converter<String,LocalTime> localTimeConverter() {
    return new Converter<>() {
      @Override
      public LocalTime convert(String source) {
        return LocalTime.parse(source,DateTimeFormatter.ofPattern(DEFAULT_TIME_FORMAT));
      }
    };
  }

  /**
   * Date轉換器，用於轉換RequestParam和PathVariable引數
   */
  @Bean
  public Converter<String,Date> dateConverter() {
    return new Converter<>() {
      @Override
      public Date convert(String source) {
        SimpleDateFormat format = new SimpleDateFormat(DEFAULT_DATE_TIME_FORMAT);
        try {
          return format.parse(source);
        } catch (ParseException e) {
          throw new RuntimeException(e);
        }
      }
    };
  }


  /**
   * Json序列化和反序列化轉換器，用於轉換Post請求體中的json以及將我們的物件序列化為返回響應的json
   */
  @Bean
  public ObjectMapper objectMapper(){
    ObjectMapper objectMapper = new ObjectMapper();
    objectMapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
    objectMapper.disable(DeserializationFeature.ADJUST_DATES_TO_CONTEXT_TIME_ZONE);

    //LocalDateTime系列序列化和反序列化模組，繼承自jsr310，我們在這裡修改了日期格式
    JavaTimeModule javaTimeModule = new JavaTimeModule();
    javaTimeModule.addSerializer(LocalDateTime.class,new LocalTimeDeserializer(DateTimeFormatter.ofPattern(DEFAULT_TIME_FORMAT)));


    //Date序列化和反序列化
    javaTimeModule.addSerializer(Date.class,new JsonSerializer<>() {
      @Override
      public void serialize(Date date,SerializerProvider serializerProvider) throws IOException {
        SimpleDateFormat formatter = new SimpleDateFormat(DEFAULT_DATE_TIME_FORMAT);
        String formattedDate = formatter.format(date);
        jsonGenerator.writeString(formattedDate);
      }
    });
    javaTimeModule.addDeserializer(Date.class,new JsonDeserializer<>() {
      @Override
      public Date deserialize(JsonParser jsonParser,DeserializationContext deserializationContext) throws IOException,JsonProcessingException {
        SimpleDateFormat format = new SimpleDateFormat(DEFAULT_DATE_TIME_FORMAT);
        String date = jsonParser.getText();
        try {
          return format.parse(date);
        } catch (ParseException e) {
          throw new RuntimeException(e);
        }
      }
    });

    objectMapper.registerModule(javaTimeModule);
    return objectMapper;
  }
}

擴充原始碼：深入研究SpringMVC資料繫結過程

接下來進入debug模式，看看mvc是如何將我們request中的引數繫結到我們controller層方法入參的；

寫一個簡單controller，打個斷點看看方法呼叫棧：

  @GetMapping("/getDate")
  public LocalDateTime getDate(@RequestParam LocalDate date,@RequestParam LocalDateTime dateTime,@RequestParam Date originalDate) {
    System.out.println(date);
    System.out.println(dateTime);
    System.out.println(originalDate);
    return LocalDateTime.now();
  }

呼叫介面以後，我們看下方法呼叫棧中一些關鍵方法：

//進入DispatcherServlet
doService:942,DispatcherServlet
//處理請求
doDispatch:1038,DispatcherServlet
//生成呼叫鏈（前處理、實際呼叫方法、後處理）
handle:87,AbstractHandlerMethodAdapter
//反射獲取到實際呼叫方法，準備開始呼叫
invokeHandlerMethod:895,RequestMappingHandlerAdapter
invokeAndHandle:102,ServletInvocableHandlerMethod
//這裡是關鍵，引數從這裡開始獲取到
invokeForRequest:142,InvocableHandlerMethod
doInvoke:215,InvocableHandlerMethod
//這個是Java reflect呼叫，因此一定是在這之前獲取到的引數
invoke:566,Method

根據上述分析，發現invokeForRequest:142,InvocableHandlerMethod這裡的程式碼是用來拿到實際引數的：

  @Nullable
  public Object invokeForRequest(NativeWebRequest request,@Nullable ModelAndViewContainer mavContainer,Object... providedArgs) throws Exception {
    //這個方法是獲取引數的，在這裡下個斷
    Object[] args = getMethodArgumentValues(request,mavContainer,providedArgs);
    if (logger.isTraceEnabled()) {
      logger.trace("Arguments: " + Arrays.toString(args));
    }
    //這裡開始呼叫方法
    return doInvoke(args);
  }

進入這個方法看看是什麼操作：

protected Object[] getMethodArgumentValues(NativeWebRequest request,Object... providedArgs) throws Exception {
  //獲取方法引數陣列，包含了入參資訊，比如型別、泛型等等
  MethodParameter[] parameters = getMethodParameters();
  //這個用來存放一會從request parameter轉換的引數
  Object[] args = new Object[parameters.length];
  for (int i = 0; i < parameters.length; i++) {
   MethodParameter parameter = parameters[i];
   parameter.initParameterNameDiscovery(this.parameterNameDiscoverer);
   //這裡看起來沒啥卵用（providedArgs為空）
   args[i] = resolveProvidedArgument(parameter,providedArgs);
   //這裡開始獲取到方法實際呼叫的引數，步進
   if (this.argumentResolvers.supportsParameter(parameter)) {
    //從名字就看出來：引數解析器解析引數
    args[i] = this.argumentResolvers.resolveArgument(parameter,request,this.dataBinderFactory);
    continue;
   }
  }
  return args;
}

進入resolveArgument看看：

public Object resolveArgument(MethodParameter parameter,NativeWebRequest webRequest,@Nullable WebDataBinderFactory binderFactory) throws Exception {
 //根據方法入參，獲取對應的解析器
 HandlerMethodArgumentResolver resolver = getArgumentResolver(parameter);
 //開始解析引數（把請求中的parameter轉為方法的入參）
 return resolver.resolveArgument(parameter,webRequest,binderFactory);
}

這裡根據引數獲取相應的引數解析器，看看內部如何獲取的：

//遍歷，呼叫supportParameter方法，跟進看看
for (HandlerMethodArgumentResolver methodArgumentResolver : this.argumentResolvers) {
 if (methodArgumentResolver.supportsParameter(parameter)) {
  result = methodArgumentResolver;
  this.argumentResolverCache.put(parameter,result);
  break;
 }
}

這裡，遍歷引數解析器，查詢有沒有適合的解析器！那麼，有哪些引數解析器呢(我測試的時候有26個)？？？我列出幾個重要的看看，是不是很眼熟！！！

{RequestParamMethodArgumentResolver@7686} 
{PathVariableMethodArgumentResolver@8359} 
{RequestResponseBodyMethodProcessor@8366} 
{RequestPartMethodArgumentResolver@8367}

我們進入最常用的一個解析器看看他的supportsParameter方法，發現就是通過引數註解來獲取相應的解析器的。

  public boolean supportsParameter(MethodParameter parameter) {
    //如果引數擁有註解@RequestParam，則走這個分支（知道為什麼上文要對RequestParam和Json兩種資料區別對待了把）
    if (parameter.hasParameterAnnotation(RequestParam.class)) {
      //這個似乎是對Optional型別的引數進行處理的
      if (Map.class.isAssignableFrom(parameter.nestedIfOptional().getNestedParameterType())) {
        RequestParam requestParam = parameter.getParameterAnnotation(RequestParam.class);
        return (requestParam != null && StringUtils.hasText(requestParam.name()));
      }
      else {
        return true;
      }
    }
    //......
  }

也就是說，對於@RequestParam和@RequestBody以及@PathVariable註解的引數，SpringMVC會使用不同的引數解析器進行資料繫結！

那麼，這三種解析器分別使用什麼Converter解析引數呢？我們分別進入三種解析器看一看：

首先看下RequestParamMethodArgumentResolver發現內部使用WebDataBinder進行資料繫結，底層使用的是ConversionService （也就是我們的Converter注入的地方）

WebDataBinder binder = binderFactory.createBinder(webRequest,null,namedValueInfo.name);
//通過DataBinder進行資料繫結的
arg = binder.convertIfNecessary(arg,parameter.getParameterType(),parameter);

//跟進convertIfNecessary()
public <T> T convertIfNecessary(@Nullable Object value,@Nullable Class<T> requiredType,@Nullable MethodParameter methodParam) throws TypeMismatchException {

 return getTypeConverter().convertIfNecessary(value,requiredType,methodParam);
}

//繼續跟進，看到了把
ConversionService conversionService = this.propertyEditorRegistry.getConversionService();
if (editor == null && conversionService != null && newValue != null && typeDescriptor != null) {
 TypeDescriptor sourceTypeDesc = TypeDescriptor.forObject(newValue);
 if (conversionService.canConvert(sourceTypeDesc,typeDescriptor)) {
  try {
   return (T) conversionService.convert(newValue,sourceTypeDesc,typeDescriptor);
  }
  catch (ConversionFailedException ex) {
   // fallback to default conversion logic below
   conversionAttemptEx = ex;
  }
 }
}

然後看下RequestResponseBodyMethodProcessor發現使用的轉換器是HttpMessageConverter型別的：

//resolveArgument方法內部呼叫下面進行引數解析
Object arg = readWithMessageConverters(webRequest,parameter,parameter.getNestedGenericParameterType());

//step into readWithMessageConverters()，我們看到這裡的Converter是HttpMessageConverter
for (HttpMessageConverter<?> converter : this.messageConverters) {
 Class<HttpMessageConverter<?>> converterType = (Class<HttpMessageConverter<?>>) converter.getClass();
 GenericHttpMessageConverter<?> genericConverter =
  (converter instanceof GenericHttpMessageConverter ? (GenericHttpMessageConverter<?>) converter : null);
 if (genericConverter != null ? genericConverter.canRead(targetType,contextClass,contentType) :
   (targetClass != null && converter.canRead(targetClass,contentType))) {
  if (message.hasBody()) {
   HttpInputMessage msgToUse =
    getAdvice().beforeBodyRead(message,targetType,converterType);
   body = (genericConverter != null ? genericConverter.read(targetType,msgToUse) :
       ((HttpMessageConverter<T>) converter).read(targetClass,msgToUse));
   body = getAdvice().afterBodyRead(body,msgToUse,converterType);
  }
  else {
   body = getAdvice().handleEmptyBody(null,message,converterType);
  }
  break;
 }
}

最後看下PathVariableMethodArgumentResolver發現和RequestParam走的執行路徑一致（二者都是繼承自AbstractNamedValueMethodArgumentResolver解析器），因此程式碼就不貼了。

總結

如果要轉換request傳來的引數到我們指定的型別，根據入參註解要進行區分：

如果是RequestBody，那麼通過配置ObjectMapper（這個玩意兒會注入到Jackson的HttpMessagConverter裡面，即MappingJackson2HttpMessageConverter中）來實現Json格式資料的序列化和反序列化；
如果是RequestParam或者PathVariable型別的引數，通過配置Converter實現引數轉換（這些Converter會注入到ConversionService中）。

到此這篇關於關於Springboot日期時間格式化處理方式總結的文章就介紹到這了,更多相關Springboot 日期時間格式化內容請搜尋我們以前的文章或繼續瀏覽下面的相關文章希望大家以後多多支援我們！

關於Springboot日期時間格式化處理方式總結

關於Springboot日期時間格式化處理方式總結

Springboot全域性日期時間格式處理

VBS日期(時間)格式化函式程式碼

Pandas-Cookbook 時間戳處理方式

Python MySQL 日期時間格式化作為引數的操作

JS常用操作拓展 1.獲取路徑URL引數 2.時間格式化處理 3.字串截斷返回省略號 4.判斷是否IE瀏覽器及版本 5.時間戳中文轉化 6.手機號碼校驗 7.郵箱校驗 8.獲取背景圖片URL地址

JDBC中日期時間的處理技巧

JS日期時間格式化yyyy-MM-dd

moment時間格式化處理

獲取token和token的過期時間後不斷重新整理過期時間的處理方式

SpringBoot中時間格式化的五種方法彙總

js日期時間格式化的方法例項

springboot 全域性時間格式化

PHPCMS V9日期時間格式化標籤適用全站

Springboot 全域性日期格式化處理的實現

SpringBoot+MyBatis+ElementUI中對於時間格式化問題的處理

Java基礎進階:時間類要點摘要,時間Date類實現格式化與解析原始碼實現詳解,LocalDateTime時間類格式化與解析原始碼實現詳解,Period,Duration獲取時間間隔與原始碼實現,程式異常解析與處理方式

Python總結之處理時間(time)、日期時間(datetime)、日曆(calendar)

Java日期時間處理總結

Spring Boot 日期時間處理總結，寫的太好了。。

關於Springboot日期時間格式化處理方式總結

相關推薦