• Jackson

• Gson

• FastJson

1. Problems encountered

\/Date(1296576000000+0800)\/

2. Thoughts

• Java code

Date now = new Date();
String nowStr = String.format("\\/Date(%s+0800)\\/", now.getTime());

3. Code

• Dependent on Jar packages

compile group: 'com.google.code.gson', name: 'gson', version: '2.8.1'
compile group: 'com.alibaba', name: 'fastjson', version: '1.2.36'
compile group: 'com.fasterxml.jackson.core', name: 'jackson-databind', version: '2.9.0'

• Custom Time Conversion String Code

public class StringSmallUtils {

    /**
     * Converts the time type format to the specified String type
     *
     * @param date
     * @return
     */
    protected static String DateToSpecialString(Date date) {
        if (date == null)
            return null;
        return String.format("\\/Date(%s+0800)\\/", date.getTime());
    }

    /**
     * Converts the specified String type to a time type format
     *
     * @param str
     * @return
     */
    protected static Date SpecialStringToDate(String str) {
        if (isEmpty(str))
            return null;
        if (!contains(str,"Date"))
            return null;
        str = str.replace("\\/Date(", "").replace("+0800)\\/", "").trim();
        return new Date(Long.parseLong(str));
    }


    /**
     * Determine whether a string contains an input string
     *
     * @param str
     * @param searchStr
     * @return
     */
    public static boolean contains(String str, String searchStr) {
        if (str == null || searchStr == null) {
            return false;
        }
        return str.contains(searchStr);
    }

    /**
     * Determine whether a string is empty
     *
     * @param str
     * @return
     */
    public static boolean isEmpty(String str) {
        return ((str == null) || (str.trim().isEmpty()));
    }
}

3.1 Gson custom implementation of Date Json string serialization

public class GsonCustomerDateJsonSerializer implements JsonSerializer<Date>, JsonDeserializer<Date> {
    @Override
    public JsonElement serialize(Date src, Type typeOfSrc, JsonSerializationContext context) {
        return new JsonPrimitive(StringSmallUtils.DateToSpecialString(src));
    }

    @Override
    public Date deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
        return StringSmallUtils.SpecialStringToDate(json.getAsString());
    }
}

• test

public class Program {
    public static void main(String[] args) throws JsonProcessingException {
        Date start = new Date();
        Gson gson = new GsonBuilder().registerTypeAdapter(Date.class, new GsonCustomerDateJsonSerializer()).create();
        String gsonStr = gson.toJson(createUser());
        Date end = new Date();
        long interval = (end.getTime() - start.getTime());
        System.out.println(String.format("Gson Serialized string:%s，Spending time%d Millisecond", gsonStr, interval));
    }

    private static User createUser() {
        User user = new User();
        user.setName("Zhang San");
        user.setAge(21);
        user.setLastlogintime(new Date());
        return user;
    }
}

3.2 FasJSON Custom Implementation of Date Json String Serialization

public class FastJsonCustomerDateJsonSerializer implements ObjectSerializer, ObjectDeserializer {
    @Override
    public void write(JSONSerializer serializer, Object object, Object fieldName, Type fieldType, int features) throws IOException {
        SerializeWriter out = serializer.getWriter();
        out.write(StringSmallUtils.DateToSpecialString((Date) object));
    }

    @Override
    public <T> T deserialze(DefaultJSONParser parser, Type type, Object fieldName) {
        return (T) StringSmallUtils.SpecialStringToDate(parser.getInput());
    }

    @Override
    public int getFastMatchToken() {
        return 0;
    }
}

• test

public class Program {
    public static void main(String[] args) throws JsonProcessingException {
        Date start1 = new Date();
        SerializeConfig mapping = new SerializeConfig();
        mapping.put(Date.class, new FastJsonCustomerDateJsonSerializer());
        String fastjsonStr = JSON.toJSONString(createUser(), mapping);
        Date end1 = new Date();
        long interval1 = (end1.getTime() - start1.getTime());
        System.out.println(String.format("FastJSON Serialized string:%s，Spending time%d Millisecond", fastjsonStr, interval1));
    }

    private static User createUser() {
        User user = new User();
        user.setName("Zhang San");
        user.setAge(21);
        user.setLastlogintime(new Date());
        return user;
    }
}

3.3 Jackson Customizes Date Json String Serialization

public class JacksonCustomerDateJsonSerializer extends JsonSerializer<Date> {
    @Override
    public void serialize(Date value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
        gen.writeString(StringSmallUtils.DateToSpecialString(value));
    }
}

public class JacksonCustomerDateJsonDeserializer extends JsonDeserializer<Date> {
    @Override
    public Date deserialize(JsonParser p, DeserializationContext ctxt) throws IOException, JsonProcessingException {
        return StringSmallUtils.SpecialStringToDate(p.getText());
    }
}

• test

public class Program {
    public static void main(String[] args) throws JsonProcessingException {
        Date start2 = new Date();
        ObjectMapper mapper = new ObjectMapper();
        SimpleModule module = new SimpleModule();
        module.addSerializer(Date.class, new JacksonCustomerDateJsonSerializer());
        module.addDeserializer(Date.class, new JacksonCustomerDateJsonDeserializer());
        mapper.registerModule(module);
        String jacksonStr = mapper.writeValueAsString(createUser());
        Date end2 = new Date();
        long interval2 = (end2.getTime() - start2.getTime());
        System.out.println(String.format("Jackson Serialized string:%s，Spending time%d Millisecond", jacksonStr, interval2));
    }

    private static User createUser() {
        User user = new User();
        user.setName("Zhang San");
        user.setAge(21);
        user.setLastlogintime(new Date());
        return user;
    }
}

4. Summary

The string after Gson serialization: {"Name", "Zhang San", "Age": 21, "Lastlogintime": " Date (1502366214027+0800)\ /", takes 77 milliseconds.
FastJSON serialized string: {"age": 21, "lastlogintime"; Date (15023214100 + 0800); /, "name", "Zhangsan"} takes 99 milliseconds
 The string after Jackson's serialization: {"name": "Zhang San", "age": 21, "lastlogintime": " Date (15023214307+0800)\/", takes 200 milliseconds.

• 1. In terms of code implementation, Gson and FastJSON are better than Jackson. Interface-oriented programming.
• 2. In terms of registration methods, Gson is better than FastJSON and Jackson. Using the adapter model
• 3. In terms of operation efficiency, Gson and FastJSON are better than Jackson. Gson is three times Jackson's and FastJSON is twice Jackson's.