Java Jackson De/在通用映射中序列化日期到字符串到日期

Hymanson De/Serializing Date-to-String-to-Date in generic Maps

提问by Buzz Moschetti

There are many examples of Hymanson to/from java.util.Date code but they all seem to leverage POJO annotation. I have generic Maps of scalars that I wish to de/serialize to JSON. This is the current deserializer setup; very simple:

有很多 Hymanson 与 java.util.Date 代码之间的示例，但它们似乎都利用了 POJO 注释。我有我希望反序列化为 JSON 的通用标量映射。这是当前的解串器设置；很简单：

public class JSONUtils {
    static {
        DateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS");

        mapper = new ObjectMapper();

        mapper.configure(DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS, true);
        mapper.setDateFormat(df);  // this works for outbounds but has no effect on inbounds

        mapper.getDeserializationConfig().with(df); // Gave this a shot but still does not sniff strings for a format that we declare should be treated as java.util.Date                           
  }
  public static Map<String,Object> parseJSON(InputStream is) {
    Map<String,Object> data = null;

    try {
        data = mapper.readValue(is, Map.class);
    } catch(Exception e) {
      // ...
    }

    return data;
}

I grok that a dateserializer can turn java.util.Date into a ISO 8601-ish string. It's going the other way that puzzles me. Clearly, in a JSON doc with no context, a string is a string so I cannot know if it was once a date. So I am prepared to duck type this and examine all strings being deserialized and if they smell like YYYY-MM-DDTHH:MM:SS.sss datetimes, then I will make a java.util.Date instead of just passing back a String. So given:

我认为日期序列化器可以将 java.util.Date 转换为 ISO 8601-ish 字符串。它的另一个方向让我感到困惑。显然，在没有上下文的 JSON 文档中，字符串是一个字符串，所以我不知道它是否曾经是一个日期。所以我准备回避输入并检查所有被反序列化的字符串，如果它们闻起来像 YYYY-MM-DDTHH:MM:SS.sss 日期时间，那么我将创建一个 java.util.Date 而不是仅仅传回一个字符串。所以给出：

{ "name": "buzz",
  "theDate": "2013-09-10T12:00:00.000"
}

will yield

会屈服

Map<String,Object> m = mapper.readValue(is, Map.class);
Object o1 = m.get("name");   // o1 is instanceof String
Object o2 = m.get("theDate");  // o2 is instanceof Date

But this means that the deserializer has to return two different types and I have not been able to figure out how to do this in Hymanson. Does anyone know of a good, compact example that will sniff for date-like strings and turn them into Dates, leaving others as Strings?

但这意味着解串器必须返回两种不同的类型，而我一直无法弄清楚如何在 Hymanson 中做到这一点。有谁知道一个好的、紧凑的例子，它会嗅探类似日期的字符串并将它们转换成日期，而将其他人作为字符串？

回答by nmorenor

Here is a basic example on how to use Hymanson to serialize deserialize a date from an object

这是一个关于如何使用 Hymanson 从对象序列化反序列化日期的基本示例

public class HymansonSetup {

公共类 HymansonSetup {

private static class HymansonSerializer {

    private static HymansonSerializer instance;

    private HymansonSerializer() {

    }

    public static HymansonSerializer getInstance() {
        if (instance == null)
            instance = new HymansonSerializer();
        return instance;
    }

    public <E extends ModelObject> void writeTo(E object, Class<E> type, OutputStream out) throws IOException {
        ObjectMapper mapper = getMapper();
        mapper.writeValue(out, object);
    }

    public <E extends ModelObject> void writeTo(E object, Class<E> type, Writer out) throws IOException {
        ObjectMapper mapper = getMapper();
        mapper.writeValue(out, object);
    }

    public <E extends ModelObject> E read(String input, Class<E> type) throws IOException {
        ObjectMapper mapper = getMapper();
        E result = (E) mapper.readValue(input, type);
        return result;
    }

    private ObjectMapper getMapper() {
        ObjectMapper mapper = new ObjectMapper();
        mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
        AnnotationIntrospector introspector = new JaxbAnnotationIntrospector(mapper.getTypeFactory());
        mapper.setAnnotationIntrospector(introspector);
        return mapper;
    }

}

private static class JaxbDateSerializer extends XmlAdapter<String, Date> {

    private SimpleDateFormat dateFormat = new SimpleDateFormat("MM-dd-yyyy");

    @Override
    public String marshal(Date date) throws Exception {
        return dateFormat.format(date);
    }

    @Override
    public Date unmarshal(String date) throws Exception {
        return dateFormat.parse(date);
    }
}

private static abstract class ModelObject {

}

private static class Person extends ModelObject {

    private String name;

    private Date bday;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @XmlElement(name = "birth-day")
    @XmlJavaTypeAdapter(JaxbDateSerializer.class)
    public Date getBday() {
        return bday;
    }

    public void setBday(Date bday) {
        this.bday = bday;
    }
}

public static void main(String[] args) {
    try {
        Person person = new Person();
        person.setName("Jhon Doe");
        person.setBday(new Date());

        Writer writer = new StringWriter();
        HymansonSerializer.getInstance().writeTo(person, Person.class, writer);
        System.out.println(writer.toString());
    } catch (Exception e) {
        e.printStackTrace();
    }
}

}

}

回答by Buzz Moschetti

After some weeks poking around on this (and no other comments or answers), I now believe what I seek is NOT possible in Hymanson. Deserialization of JSON into a Map with ducktyping for dates must occur after-the-fact. There is no way to interpose the parse stream, sniff the string for YYYY-MM-DDTHH:MM:SS.SSSand upon match substitute a Dateobject instead of String. You must let Hymanson build the Map, then outside of Hymanson go back to the top and walk the Map, sniffing for dates.

经过几周的探索（没有其他评论或答案），我现在相信我在Hyman逊不可能寻求什么。必须在事后将 JSON 反序列化为带有日期类型的映射。没有办法插入解析流，嗅探字符串YYYY-MM-DDTHH:MM:SS.SSS并在匹配时替换一个Date对象而不是String. 你必须让Hyman逊建造Map，然后在Hyman逊外面回到顶部并走Map，嗅探约会。

I will add that since I have a very specificduck I am looking for, the fastest implementation to turn the String into a Date is a hand-rolled thing about 120 lines long that validates and sets up the proper integer m-d-y-h-m-s-ms for Calendar then calls getTime(). 10,000,000 conversions takes 4240 millis, or about 2.3m/sec.

我要补充一点，因为我有一个非常具体的鸭子我正在寻找，将 String 转换为 Date 的最快实现是一个大约 120 行长的手工滚动的东西，它验证并为 Calendar 设置正确的整数 mdyhms-ms 然后调用getTime()。10,000,000 次转换需要 4240 毫秒，或大约 2.3 米/秒。

Before the joda-time lobby pipes up, yes, I tried that first:

在 joda-time 大厅响起之前，是的，我先试过了：

// This is set up ONCE, outside the timing loop:
DateTimeFormatter format = ISODateTimeFormat.dateHourMinuteSecondMillis();

// These are in the timing loop:
while(loop) {
    DateTime time = format.parseDateTime("2013-09-09T14:45:00.123");
    Date d = time.toDate();
}

takes about 9630 millis to run, about 1.04m/sec; half the speed. But that's still WAY faster than the "out of the box use javax" option:

运行大约需要 9630 毫秒，大约为 1.04m/sec；速度减半。但这仍然比“开箱即用的使用 javax”选项快得多：

java.util.Calendar c2 = javax.xml.bind.DatatypeConverter.parseDateTime(s);
Date d = c2.getTime();

This takes 30428 mills to run, about .33m/sec -- almost 7x slower than the handroll.

这需要 30428 台轧机运行，大约 0.33m/sec —— 几乎比手辊慢 7 倍。

SimpleDateFormatis not thread-safe so therefore was not considered in for use in converter utility where I cannot make any assumptions about the callers.

SimpleDateFormat不是线程安全的，因此不考虑在转换器实用程序中使用，因为我无法对调用者做出任何假设。

回答by Giuseppe Adaldo

If you have a POJO, you can easy use annotation on get and set method with serializer and deserializer.

如果您有POJO，您可以使用序列化器和反序列化器轻松地在 get 和 set 方法上使用注释。

following an example that serialize and deserialize objects in different ways: List<POJO>to String, Stringto Mapand Mapto List<POJO>again. Obviously, in the map the Datevalues are as String.

下面是一个以不同方式序列化和反序列化对象的示例：List<POJO>to String、StringtoMap和Mapto List<POJO>again 。显然，在地图中，Date值是String。

This solution is thread safe because uses org.joda.time.format.DateTimeFormatand org.joda.time.format.DateTimeFormatter, you can find more info herein this post How to deserialize JS date using Hymanson?and this link http://fahdshariff.blogspot.co.uk/2010/08/dateformat-with-multiple-threads.html

这个解决方案是线程安全的，因为使用org.joda.time.format.DateTimeFormat和org.joda.time.format.DateTimeFormatter，你可以在这篇文章中找到更多信息如何使用 Hymanson 反序列化 JS 日期？和这个链接http://fahdshariff.blogspot.co.uk/2010/08/dateformat-with-multiple-threads.html

My POJO:

我的POJO：

@JsonAutoDetect
public class QueueTask implements Serializable {

    private static final long serialVersionUID = -4411796657106403937L;

    public enum ActivitiQueueStatus {

        IN_PROGRESS(AsyncProcessingWorkflowContentModel.InProgressTask.TYPE.getLocalName()), //
        IN_QUEUE(AsyncProcessingWorkflowContentModel.InQueueTask.TYPE.getLocalName());

        private String value;

        private ActivitiQueueStatus(final String value) {
            this.value = value;
        }

        public static ActivitiQueueStatus enumOf(final String value) {
            for (ActivitiQueueStatus enum_i : values()) {
                if (enum_i.value.equals(value))
                    return enum_i;
            }
            throw new IllegalArgumentException("value '" + value + "' is not a valid enum");
        }
    }

    private String user;

    private Date creationDate;

    private int noRowsSelected;

    private ActivitiQueueStatus status;


    public String getUser() {
        return user;
    }

    public void setUser(String user) {
        this.user = user;
    }

    @JsonSerialize(using = JsonDateSerializer.class)
    public Date getCreationDate() {
        return creationDate;
    }

    @JsonDeserialize(using = JsonDateDeSerializer.class)
    public void setCreationDate(Date creationDate) {
        this.creationDate = creationDate;
    }

    public int getNoRowsSelected() {
        return noRowsSelected;
    }

    public void setNoRowsSelected(int noRowsSelected) {
        this.noRowsSelected = noRowsSelected;
    }

    public ActivitiQueueStatus getStatus() {
        return status;
    }

    public void setStatus(ActivitiQueueStatus status) {
        this.status = status;
    }

}

My Serializer:

我的序列化器：

@Component
public class JsonDateDeSerializer extends JsonDeserializer<Date> {

    // use joda library for thread safe issue
    private static final DateTimeFormatter dateFormat = DateTimeFormat.forPattern("dd/MM/yyyy hh:mm:ss");

    @Override
    public Date deserialize(final JsonParser jp, final DeserializationContext ctxt) throws IOException, JsonProcessingException {
        if (jp.getCurrentToken().equals(JsonToken.VALUE_STRING))
            return dateFormat.parseDateTime(jp.getText().toString()).toDate();
        return null;
    }

}

and Deserializer:

和解串器：

@Component
public class JsonDateSerializer extends JsonSerializer<Date> {

    // use joda library for thread safe issue
    private static final DateTimeFormatter dateFormat = DateTimeFormat.forPattern("dd/MM/yyyy hh:mm:ss");

    @Override
    public void serialize(final Date date, final JsonGenerator gen, final SerializerProvider provider) throws IOException, JsonProcessingException {

        final String formattedDate = dateFormat.print(date.getTime());

        gen.writeString(formattedDate);
    }

}

My Service:

我的服务：

public class ServiceMock {

    // mock this parameter for usage.
    public List<QueueTask> getActiveActivities(QName taskStatus) {
        final List<QueueTask> listToReturn = new LinkedList<QueueTask>();

        final SimpleDateFormat dateFormat = new SimpleDateFormat("dd/MM/yyyy hh:mm:ss");
        Date d1 = null, d2 = null, d3 = null, d4 = null, d5 = null;

        try {
            d1 = dateFormat.parse("01/02/2013 12:44:44");
            d2 = dateFormat.parse("21/12/2013 16:44:44");
            d3 = dateFormat.parse("21/12/2013 16:45:44");
            d4 = dateFormat.parse("21/12/2013 16:44:46");
            d5 = dateFormat.parse("11/09/2013 16:44:44");
        } catch (ParseException e) {
        }

        QueueTask dataSet = new QueueTask();
        dataSet = new QueueTask();
        dataSet.setUser("user_b");
        dataSet.setStatus(ActivitiQueueStatus.enumOf("placeInQueue"));
        dataSet.setNoRowsSelected(500);
        dataSet.setCreationDate(d1);
        listToReturn.add(dataSet);

        dataSet = new QueueTask();
        dataSet.setUser("user_d");
        dataSet.setStatus(ActivitiQueueStatus.enumOf("placeInQueue"));
        dataSet.setNoRowsSelected(300);
        dataSet.setCreationDate(d2);
        listToReturn.add(dataSet);

        dataSet = new QueueTask();
        dataSet.setUser("user_a");
        dataSet.setStatus(ActivitiQueueStatus.enumOf("inProgress"));
        dataSet.setNoRowsSelected(700);
        dataSet.setCreationDate(d3);
        listToReturn.add(dataSet);

        dataSet = new QueueTask();
        dataSet.setUser("user_k");
        dataSet.setStatus(ActivitiQueueStatus.enumOf("inProgress"));
        dataSet.setNoRowsSelected(700);
        dataSet.setCreationDate(d4);
        listToReturn.add(dataSet);

        dataSet = new QueueTask();
        dataSet.setUser("user_l");
        dataSet.setStatus(ActivitiQueueStatus.enumOf("inProgress"));
        dataSet.setNoRowsSelected(700);
        dataSet.setCreationDate(d5);
        listToReturn.add(dataSet);

        return listToReturn;
    }

}

MAIN usage:

主要用途：

public class SerializationServiceTest {

    private static final Logger LOGGER = LoggerFactory.getLogger(OUPQueueStatusServiceIT.class);

    public void testGetActiveActivitiesSerialization() throws Exception {
        LOGGER.info("testGetActiveActivitiesSerialization - start");

        ServiceMock mockedService = new ServiceMock();

        // AsyncProcessingWorkflowContentModel.InProgressTask.TYPE is an QName, mock this calling
        List<QueueTask> tasks = mockedService.getActiveActivities(AsyncProcessingWorkflowContentModel.InProgressTask.TYPE);
        assertNotNull(tasks);
        assertTrue(tasks.size() == 5);
        assertNotNull(tasks.get(0).getUser());
        assertNotNull(tasks.get(0).getCreationDate());
        assertNotNull(tasks.get(0).getStatus());
        assertNotNull(tasks.get(0).getNoRowsSelected());

        final ObjectMapper mapper = new ObjectMapper();
        final String jsonString = mapper.writeValueAsString(tasks);

        assertNotNull(jsonString);
        assertTrue(jsonString.contains("creationDate"));

        // test serialization from string to Map
        final List<Map<String, Object>> listOfMap = mapper.readValue(jsonString, new TypeReference<List<Map<String, Object>>>() {
        });
        assertNotNull(listOfMap);

        final DateFormat formatter = new SimpleDateFormat("dd/MM/yyyy hh:mm:ss");
        for (Map<String, Object> map_i : listOfMap) {
            // check date value
            assertTrue(map_i.containsKey("creationDate"));
            final Date date = formatter.parse("" + map_i.get("creationDate"));
            assertNotNull(date);

            assertNotNull(map_i.get("user"));
            assertNotNull(map_i.get("status"));
            assertNotNull(ActivitiQueueStatus.valueOf("" + map_i.get("status")));
            assertNotNull(map_i.get("noRowsSelected"));
        }

        // test de-serialization
        List<QueueTask> deserializedTaskList = mapper.convertValue(listOfMap, new TypeReference<List<QueueTask>>() {
        });

        assertNotNull(deserializedTaskList);
        assertTrue(deserializedTaskList.size() == 5);
        for (QueueTask t : deserializedTaskList) {
            assertNotNull(t.getUser());
            assertNotNull(t.getCreationDate());
            assertNotNull(t.getDownloadType());
            assertNotNull(t.getStatus());
        }
        LOGGER.info("testGetActiveActivitiesSerialization - end");
    }

    public static void main(String[] args) throws Exception {
        new SerializationServiceTest().SerializationServiceTest();
    }

}

回答by Nick

I've been looking for the answer on a related subject recently and come up with the following solution, thanks to Justin Musgroveand his article Custom Hymanson date deserializer. Basically, the idea is to replace standard deserializer for Object.class that will convert any string in the specified format to the Date object or fallback to the standard behaviour otherwise. Obviously, this operation comes at cost of extra processing, so you'd want to keep a dedicated instance of ObjectMapper configured for this and only use it when absolutely necessary or if prepared doing second pass anyway.

我最近一直在寻找相关主题的答案，并提出了以下解决方案，这要感谢Justin Musgrove和他的文章Custom Hymanson date deserializer。基本上，这个想法是替换 Object.class 的标准反序列化器，它会将指定格式的任何字符串转换为 Date 对象，否则回退到标准行为。显然，此操作需要额外处理，因此您需要为此配置一个专用的 ObjectMapper 实例，并且仅在绝对必要或准备进行第二遍时才使用它。

Note that the Date string format in your example has no timezone component, which may cause some issues, but I leave the format as requested. You can use a parser of your choice in place of the FastDateFormat from Apache Commons Lang. I actually use Instant in my case.

请注意，您示例中的日期字符串格式没有时区组件，这可能会导致一些问题，但我按要求保留了格式。您可以使用您选择的解析器代替来自Apache Commons Lang的 FastDateFormat 。在我的情况下，我实际上使用 Instant 。

CustomObjectDeserializer.java

CustomObjectDeserializer.java

import java.io.IOException;

import org.apache.commons.lang3.time.FastDateFormat;

import com.fasterxml.Hymanson.core.JsonParser;
import com.fasterxml.Hymanson.core.JsonProcessingException;
import com.fasterxml.Hymanson.core.JsonTokenId;
import com.fasterxml.Hymanson.databind.DeserializationContext;
import com.fasterxml.Hymanson.databind.deser.std.UntypedObjectDeserializer;

public class CustomObjectDeserializer extends UntypedObjectDeserializer {
    private static final long serialVersionUID = 1L;

    private static final FastDateFormat format = FastDateFormat.getInstance("yyyy-MM-dd'T'HH:mm:ss.SSS");

    public CustomObjectDeserializer() {
        super(null, null);
    }

    @Override
    public Object deserialize(JsonParser p, DeserializationContext ctxt) throws IOException, JsonProcessingException {
        if (p.getCurrentTokenId() == JsonTokenId.ID_STRING) {
            try {
                String value = p.getText();
                // put your own parser here
                return format.parse(value);
            } catch (Exception e) {
                return super.deserialize(p, ctxt);
            }
        } else {
            return super.deserialize(p, ctxt);
        }
    }

}

JSONUtils.java

JSONUtils.java

import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.nio.charset.StandardCharsets;
import java.util.Map;

import com.fasterxml.Hymanson.databind.DeserializationFeature;
import com.fasterxml.Hymanson.databind.ObjectMapper;
import com.fasterxml.Hymanson.databind.module.SimpleModule;

public class JSONUtils {
    private static final ObjectMapper mapper = new ObjectMapper();

    static {
        mapper.configure(DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS, true);

        SimpleModule module = new SimpleModule("DateConverter");
        // register a new deserializer extending and replacing UntypedObjectDeserializer 
        module.addDeserializer(Object.class, new CustomObjectDeserializer());
        mapper.registerModule(module);
    }

    public static Map<String, Object> parseJSON(InputStream is) {
        Map<String, Object> data = null;

        try {
            data = mapper.readValue(is, Map.class);
        } catch (Exception e) {
            // ...
            e.printStackTrace();
        }

        return data;
    }

    public static void main(String[] args) throws Exception {
        String input = "{\"name\": \"buzz\", \"theDate\": \"2013-09-10T12:00:00.000\"}";
        InputStream is = new ByteArrayInputStream(input.getBytes(StandardCharsets.UTF_8));

        Map<String, Object> m = mapper.readValue(is, Map.class);
        Object o1 = m.get("name"); // o1 is instanceof String
        Object o2 = m.get("theDate"); // o2 is instanceof Date
        System.out.println(o1.getClass().getName() + " : " + o1);
        System.out.println(o2.getClass().getName() + " : " + o2);
    }
}