使用@JsonFormat和@DateTimeFormat對Date格式化操作

Posted on by

@JsonFormat和@DateTimeFormat對Date格式化

實體類

package com.pojo;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;    
public class User {
     private Long id;
     private String username;//用戶名
     private String password;//密碼
     private String phone;//手機號
     private String email;//郵箱
     private Date created;//創建日期
     private Date updated;//修改日期
 
     public Long getId() { return id; }
     public void setId(Long id) { this.id = id;}
 
     public String getUsername() {return username;}
     public void setUsername(String username) {this.username = username;}
 
     public String getPassword() { return password;}
     public void setPassword(String password) { this.password = password;}
 
     public String getPhone() { return phone;}
     public void setPhone(String phone) {this.phone = phone;}
 
     public String getEmail() {return email;}
     public void setEmail(String email) { this.email = email;}
 
     public Date getCreated() {return created;}
     public void setCreated(Date created) {this.created = created;}
    
     public Date getUpdated() {return updated;}
     public void setUpdated(Date updated) {this.updated = updated;}
 }

一、@JsonFormat

控制器：

@RequestMapping("/getdate")
 @ResponseBody
 public TbUser getdate() {
  TbUser user = new TbUser();
  user.setId(1001l);
  user.setUsername("zhangsan");
  user.setPassword("1234567");
  user.setPhone("15225969681");
  user.setEmail("[email protected]");
  user.setUpdated(new Date());
  user.setCreated(new Date());
  return user;
 }

訪問控制器在瀏覽器中輸出的json格式如下：

{“id”:1001,”username”:”zhangsan”,”password”:”1234567″,”phone”:”15212559252″,”email”:”[email protected]”,”created”:1545288773904,”updated”:”1545288773904″}

可見created、updated這兩個屬性值是時間戳並不是“yyyy-MM-dd HH:mm:ss”格式，那怎麼把日期類型格式化成我們想要的類型呢，其實很簡單隻需要在實體類的屬性上加上**@JsonFormat**註解就行瞭。

@JsonFormat(pattern="yyyy-MM-dd HH:mm:ss",timezone = "GMT+8")
 private Date created;
 @JsonFormat(pattern="yyyy-MM-dd HH:mm:ss",timezone = "GMT+8")
 private Date updated;
@JsonFormat(pattern=“yyyy-MM-dd”,timezone = “GMT+8”)

**pattern:**是你需要轉換的時間日期的格式

**timezone：**是時間設置為東八區(北京時間)

提示：@JsonFormat註解可以在屬性的上方，同樣可以在屬性對應的get方法上，兩種方式沒有區別。

再次訪問控制器，會發現在瀏覽器中輸出的json格式就會變成我們指定的時間格式瞭。如下：

{“id”:1001,”username”:”zhangsan”,”password”:”1234567″,”phone”:”15225969681″,”email”:”[email protected]”,”created”:2018-12-19 19:00:11,”updated”:”2018-12-19 19:00:11″}

加上註解後將User對象轉為json字符串時也是會按照註解中的格式進行轉換

二、@DateTimeFormat

Index.jsp

<%@ page language="java" contentType="text/html; charset=utf-8"
pageEncoding="utf-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>測試</title>
</head>
<body>
<form method="post" action="/getuser">
用戶名：<input type="text" name="username"/></br>
密碼：<input type="password" name="password"/></br>
手機：<input type="text" name="phone"/></br>
郵箱：<input type="text" name="email"/></br>
創建日期：<input type="datetime" name="created"/></br>
修改日期：<input type="datetime" name="updated"/></br>
<input type="submit" />
</form>
</body>
</html>
@RequestMapping(value="/getuser", method=RequestMethod.POST)
@ResponseBody
public TbUser getuser(TbUser user) {
 System.out.println("-------------------------------");
 System.out.println(user.toString());
 System.out.println("-------------------------------");
 return user;
}

在這裡插入圖片描述

當User實體類created、updated不加註解 @DateTimeFormat(pattern = “yyyy-MM-dd”) 時可以輸入任意格式的日期如yyyy-MM-dd、yyyy/MM/dd…，後臺仍會將接收到的字符串轉換為Date，但如果加上@DateTimeFormat註解就隻能按照註解後面的日期格式進行輸入瞭。

當User實體類created、updated不加註解 @DateTimeFormat(pattern = “yyyy-MM-dd”) 時可以輸入任意格式的日期如yyyy-MM-dd、yyyy/MM/dd…，後臺仍會將接收到的字符串轉換為Date，但如果加上@DateTimeFormat註解就隻能按照註解後面的日期格式進行輸入瞭。

@DateTimeFormat(pattern = "yyyy-MM-dd")
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss",timezone="GMT+8")
private Date created;
@DateTimeFormat(pattern = "yyyy-MM-dd")
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss",timezone="GMT+8")
private Date updated;

控制臺輸出結果如下：

User [id=null, username=test, password=123, phone=12345678901, [email protected], created=Thu Dec 20 00:00:00 CST 2012, updated=Thu Dec 20 00:00:00 CST 2012]

總結：

註解**@JsonFormat**:主要是控制後臺到前臺的時間格式

註解**@DateTimeFormat**:主要是限制前臺到後臺的時間格式

順便分享一個json和Object互轉的工具類，源碼如下：

package com.common.utils;
import java.util.List;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.ObjectMapper;
public class JsonUtils {
    // 定義jackson對象
    private static final ObjectMapper MAPPER = new ObjectMapper();
    /**
     * 將對象轉換成json字符串。
     * <p>Title: pojoToJson</p>
     * <p>Description: </p>
     * @param data
     * @return
     */
    public static String objectToJson(Object data) {
     try {
   String string = MAPPER.writeValueAsString(data);
   return string;
  } catch (JsonProcessingException e) {
   e.printStackTrace();
  }
     return null;
    }
    
    /**
     * 將json結果集轉化為對象
     * 
     * @param jsonData json數據
     * @param clazz 對象中的object類型
     * @return
     */
    public static <T> T jsonToPojo(String jsonData, Class<T> beanType) {
        try {
            T t = MAPPER.readValue(jsonData, beanType);
            return t;
        } catch (Exception e) {
         e.printStackTrace();
        }
        return null;
    }
    
    /**
     * 將json數據轉換成pojo對象list
     * <p>Title: jsonToList</p>
     * <p>Description: </p>
     * @param jsonData
     * @param beanType
     * @return
     */
    public static <T>List<T> jsonToList(String jsonData, Class<T> beanType) {
     JavaType javaType = MAPPER.getTypeFactory().constructParametricType(List.class, beanType);
     try {
      List<T> list = MAPPER.readValue(jsonData, javaType);
      return list;
  } catch (Exception e) {
   e.printStackTrace();
  }
     return null;
    }
}

Json Date日期格式化以及字段過濾

json 數據的日期格式化一直都是一個問題，沒有能夠按照自己想要的格式格式化的方法或者工具，所以把自己用過的整理一下.

引入jar包：

jackson-all-1.8.5.jar 不一定固定這個版本.

org.codehaus.jackson.map.ObjectMapper.class 需要導入這個轉換對象.

maven依賴：版本自適配

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.15</version>
</dependency>

Null轉空串””

// Date日期格式化
ObjectMapper mapper = new ObjectMapper();
mapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
// 將null替換為""
mapper.getSerializerProvider().setNullValueSerializer(new JsonSerializer<Object>() {
 @Override
 public void serialize(Object obj, JsonGenerator jg, SerializerProvider sp)
  throws IOException, JsonProcessingException {
  jg.writeString(""); // Null 值轉 “”（String串）
 }
});

實現json字段的過濾：

// 隻保留包含的字段
// 實現自定義字段保留filterOutAllExcept，過濾serializeAllExcept
mapper.setFilters(new SimpleFilterProvider().addFilter(ReportLoss.class.getName(),
 SimpleBeanPropertyFilter.serializeAllExcept("id", "title")));
mapper.setAnnotationIntrospector(new JacksonAnnotationIntrospector(){
 @Override
 public Object findFilterId(AnnotatedClass ag) {
  return ag.getName();
 }
});

格式化後的結果獲取：

// 得到格式化後的json數據
String asString = mapper.writeValueAsString(queryActiveList);

註解的釋義：

註解使用：（對象）

字段註解過濾

@JsonIgnore屬性上 或者 @JsonIgnoreProperties({“createTime”,”valid”})實體類上

@JsonProperty(“idName”)更改字段名，屬性上

// 過濾對象的null屬性.
mapper.setSerializationInclusion(Inclusion.NON_NULL);
// 過濾map中的null值
mapper.configure(Feature.WRITE_NULL_MAP_VALUES, false);

json轉map：

//JSONObject轉Map<String, Object>
@SuppressWarnings("unchecked")
private Map<String, Object> getJsonToMap(JSONObject json) {
 Map<String,Object> map = new HashMap<String, Object>();
 try {
  ObjectMapper mapper = new ObjectMapper();
  map = mapper.readValue(json.toString(), Map.class);
 } catch (Exception e) {
  e.printStackTrace();
 }
 return map;
}

為瞭方便，整理瞭一份工具類：JsonDMOUtil.java

JsonDMOUtil.java （json日期格式化以及轉換工具類）

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializerProvider;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
/**
 * jsonDMUtil工具類 by cdw
 */
public class JsonDMOUtil {
    /**
     * @param object      格式化的數據
     * @param dateFormate 格式化的日期格式
     * @return 返回格式化後的數據
     */
    public static String jsonDateFormate(Object object, String dateFormate) {
        String asString = "";
        try {
            // Date日期格式化
            if ("".equals(dateFormate.trim()) || dateFormate == null) {
                dateFormate = "yyyy-MM-dd HH:mm:ss";
            }
            ObjectMapper mapper = JsonDMOUtil.getObjectMapper(dateFormate);
            // 得到格式化後的json數據
            asString = mapper.writeValueAsString(object);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return asString;
    }
    /**
     * @param object      格式化的數據
     * @param dateFormate 格式化的日期格式
     * @return 返回格式化後的數據
     */
    public static JSONObject jsonDTOFormate(Object object, String dateFormate) {
        String asString = "";
        try {
            // Date日期格式化
            if ("".equals(dateFormate.trim()) || dateFormate == null) {
                dateFormate = "yyyy-MM-dd HH:mm:ss";
            }
            ObjectMapper mapper = JsonDMOUtil.getObjectMapper(dateFormate);
            // 得到格式化後的json數據
            asString = mapper.writeValueAsString(object);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return JSON.parseObject(asString);
    }
    /**
     * @param object      格式化的數據,將JSONObject轉成Map
     * @param dateFormate 格式化的日期格式
     * @return 返回格式化後的數據
     */
    @SuppressWarnings("unchecked")
    public static Map<String, String> jsonDTMFormate(Object object, String dateFormate) {
        Map<String, String> resultMap = new HashMap<String, String>();
        try {
            JSONObject jsonObj = JSON.parseObject(object.toString());
            // Date日期格式化
            if ("".equals(dateFormate.trim()) || dateFormate == null) {
                dateFormate = "yyyy-MM-dd HH:mm:ss";
            }
            ObjectMapper mapper = JsonDMOUtil.getObjectMapper(dateFormate);
            JSONObject header = jsonObj.getJSONObject("header");
            JSONObject body = jsonObj.getJSONObject("body");
            Map<String, String> headerMap = null;
            Map<String, String> bodyMap = null;
            if (header != null) {
                headerMap = mapper.readValue(header.toString(), Map.class);
                for (Entry<String, String> map : headerMap.entrySet()) {
                    resultMap.put(map.getKey(), map.getValue());
                }
            }
            if (body != null) {
                bodyMap = mapper.readValue(body.toString(), Map.class);
                for (Entry<String, String> map : bodyMap.entrySet()) {
                    resultMap.put(map.getKey(), map.getValue());
                }
            }
            if (resultMap.isEmpty()) {
                resultMap = mapper.readValue(jsonObj.toString(), Map.class);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return resultMap;
    }
    /**
     * @param object 格式化的數據,
     *               默認格式化的日期格式（"yyyy-MM-dd HH:mm:ss"）
     * @return 返回格式化後的數據
     */
    public static String jsonDateFormate(Object object) {
        String asString = "";
        try {
            // Date日期格式化
            ObjectMapper mapper = JsonDMOUtil.getObjectMapper("yyyy-MM-dd HH:mm:ss");
            asString = mapper.writeValueAsString(object);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return asString;
    }
    /**
     * @param object 格式化的數據,
     *               默認格式化的日期格式（"yyyy-MM-dd HH:mm:ss"）
     * @return 返回格式化後的數據
     */
    public static JSONObject jsonDTOFormate(Object object) {
        String asString = "";
        try {
            // Date日期格式化
            ObjectMapper mapper = JsonDMOUtil.getObjectMapper("yyyy-MM-dd HH:mm:ss");
            asString = mapper.writeValueAsString(object);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return JSON.parseObject(asString);
    }
    /**
     * @param object 格式化的數據,將JSONObject轉成Map,
     *               默認格式化的日期格式（"yyyy-MM-dd HH:mm:ss"）
     * @return 返回格式化後的數據
     */
    @SuppressWarnings("unchecked")
    public static Map<String, String> jsonDTMFormate(Object object) {
        Map<String, String> resultMap = new HashMap<String, String>();
        try {
            JSONObject jsonObj = JSON.parseObject(object.toString());
            // Date日期格式化
            ObjectMapper mapper = JsonDMOUtil.getObjectMapper("yyyy-MM-dd HH:mm:ss");
            JSONObject header = jsonObj.getJSONObject("header");
            JSONObject body = jsonObj.getJSONObject("body");
            Map<String, String> headerMap = null;
            Map<String, String> bodyMap = null;
            if (header != null) {
                headerMap = mapper.readValue(header.toString(), Map.class);
                for (Entry<String, String> map : headerMap.entrySet()) {
                    resultMap.put(map.getKey(), map.getValue());
                }
            }
            if (body != null) {
                bodyMap = mapper.readValue(body.toString(), Map.class);
                for (Entry<String, String> map : bodyMap.entrySet()) {
                    resultMap.put(map.getKey(), map.getValue());
                }
            }
            if (resultMap.isEmpty()) {
                resultMap = mapper.readValue(jsonObj.toString(), Map.class);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return resultMap;
    }
    /**
     * @param dateFormate 格式化的日期格式
     * @return 返回ObjectMapper對象
     */
    private static ObjectMapper getObjectMapper(String dateFormate) {
        // Date日期格式化
        ObjectMapper mapper = new ObjectMapper();
        mapper.setDateFormat(new SimpleDateFormat(dateFormate));
        // 將null替換為""
        mapper.getSerializerProvider().setNullValueSerializer(new JsonSerializer<Object>() {
            @Override
            public void serialize(Object obj, JsonGenerator jg, SerializerProvider sp)
                    throws IOException {
                jg.writeString(""); // Null 值轉 “”（String串）
            }
        });
        return mapper;
    }
}

以上為個人經驗，希望能給大傢一個參考，也希望大傢多多支持WalkonNet。

推薦閱讀：