bugfix: serialize the type of timestamp lost nano value

rm-datasource/src/main/java/io/seata/rm/datasource/undo/parser/JacksonUndoLogParser.java

@@ -16,17 +16,30 @@
 package io.seata.rm.datasource.undo.parser;
 
 import com.fasterxml.jackson.annotation.JsonTypeInfo;
+import com.fasterxml.jackson.core.JsonGenerator;
+import com.fasterxml.jackson.core.JsonParser;
 import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.core.JsonToken;
+import com.fasterxml.jackson.core.type.WritableTypeId;
 import com.fasterxml.jackson.databind.DeserializationFeature;
+import com.fasterxml.jackson.databind.DeserializationContext;
+import com.fasterxml.jackson.databind.JsonDeserializer;
+import com.fasterxml.jackson.databind.SerializerProvider;
+import com.fasterxml.jackson.databind.JsonSerializer;
 import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.deser.std.JsonNodeDeserializer;
+import com.fasterxml.jackson.databind.jsontype.TypeSerializer;
+import com.fasterxml.jackson.databind.module.SimpleModule;
+import com.fasterxml.jackson.databind.node.ArrayNode;
+import com.fasterxml.jackson.databind.ser.std.ArraySerializerBase;
 import io.seata.common.Constants;
 import io.seata.common.loader.LoadLevel;
 import io.seata.rm.datasource.undo.BranchUndoLog;
 import io.seata.rm.datasource.undo.UndoLogParser;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-
 import java.io.IOException;
+import java.sql.Timestamp;
 
 /**
  * The type Json based undo log parser.
@@ -41,7 +54,23 @@ public class JacksonUndoLogParser implements UndoLogParser {
     private static final Logger LOGGER = LoggerFactory.getLogger(JacksonUndoLogParser.class);
 
     private static final ObjectMapper MAPPER = new ObjectMapper();
+
+    private static final SimpleModule MODULE = new SimpleModule();
+
+    /**
+     * customize serializer for java.sql.Timestamp
+     */
+    private static final JsonSerializer TIMESTAMP_SERIALIZER = new TimestampSerializer();
+
+    /**
+     * customize deserializer for java.sql.Timestamp
+     */
+    private static final JsonDeserializer TIMESTAMP_DESERIALIZER = new TimestampDeserializer();
+
     static {
+        MODULE.addSerializer(Timestamp.class, TIMESTAMP_SERIALIZER);
+        MODULE.addDeserializer(Timestamp.class, TIMESTAMP_DESERIALIZER);
+        MAPPER.registerModule(MODULE);
         MAPPER.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
         MAPPER.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
     }
@@ -78,4 +107,53 @@ public BranchUndoLog decode(byte[] bytes) {
         }
     }
 
+    /**
+     * if necessary
+     * extend {@link ArraySerializerBase}
+     */
+    private static class TimestampSerializer extends JsonSerializer<Timestamp> {
+
+        @Override
+        public void serializeWithType(Timestamp timestamp, JsonGenerator gen, SerializerProvider serializers, TypeSerializer typeSerializer) throws IOException {
+            WritableTypeId typeId = typeSerializer.writeTypePrefix(gen, typeSerializer.typeId(timestamp, JsonToken.START_ARRAY));
+            serialize(timestamp, gen, serializers);
+            gen.writeTypeSuffix(typeId);
+        }
+
+        @Override
+        public void serialize(Timestamp timestamp, JsonGenerator gen, SerializerProvider serializers) {
+            try {
+                gen.writeNumber(timestamp.getTime());
+                gen.writeNumber(timestamp.getNanos());
+            } catch (IOException e) {
+                LOGGER.error("serialize java.sql.Timestamp error : {}", e.getMessage(), e);
+            }
+
+        }
+    }
+
+    /**
+     * if necessary
+     * extend {@link JsonNodeDeserializer}
+     */
+    private static class TimestampDeserializer extends JsonDeserializer<Timestamp> {
+
+        @Override
+        public Timestamp deserialize(JsonParser p, DeserializationContext ctxt) {
+            if(p.isExpectedStartArrayToken()){
+                ArrayNode arrayNode;
+                try {
+                    arrayNode = p.getCodec().readTree(p);
+                    Timestamp timestamp = new Timestamp(arrayNode.get(0).asLong());
+                    timestamp.setNanos(arrayNode.get(1).asInt());
+                    return timestamp;
+                } catch (IOException e) {
+                    LOGGER.error("deserialize java.sql.Timestamp error : {}", e.getMessage(), e);
+                }
+            }
+            LOGGER.error("deserialize java.sql.Timestamp type error.");
+            return null;
+        }
+    }
+
 }

rm-datasource/src/test/java/io/seata/rm/datasource/undo/parser/JacksonUndoLogParserTest.java

@@ -15,8 +15,17 @@
  */
 package io.seata.rm.datasource.undo.parser;
 
+import java.io.IOException;
+import java.math.BigDecimal;
+import java.sql.JDBCType;
+import java.sql.Timestamp;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import io.seata.rm.datasource.DataCompareUtils;
+import io.seata.rm.datasource.sql.struct.Field;
 import io.seata.rm.datasource.undo.BaseUndoLogParserTest;
 import io.seata.rm.datasource.undo.UndoLogParser;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
 
 /**
  * @author Geng Zhang
@@ -25,6 +34,39 @@ public class JacksonUndoLogParserTest extends BaseUndoLogParserTest {
 
     JacksonUndoLogParser parser = new JacksonUndoLogParser();
 
+    @Test
+    public void encode() throws NoSuchFieldException, IllegalAccessException, IOException {
+        //get the jackson mapper
+        java.lang.reflect.Field reflectField = parser.getClass().getDeclaredField("MAPPER");
+        reflectField.setAccessible(true);
+        ObjectMapper mapper = (ObjectMapper)reflectField.get(null);
+
+        //bigint type
+        Field field = new Field("bigint_type", JDBCType.BIGINT.getVendorTypeNumber(), new Long(9223372036854775807L));
+        byte[] bytes = mapper.writeValueAsBytes(field);
+        Field sameField = mapper.readValue(bytes, Field.class);
+        Assertions.assertTrue(DataCompareUtils.isFieldEquals(field, sameField));
+
+        //big decimal type
+        field = new Field("decimal_type", JDBCType.DECIMAL.getVendorTypeNumber(), new BigDecimal("55555555555555555555.55555555555555555555"));
+        bytes = mapper.writeValueAsBytes(field);
+        sameField = mapper.readValue(bytes, Field.class);
+        Assertions.assertTrue(DataCompareUtils.isFieldEquals(field, sameField));
+
+        //double type
+        field = new Field("double_type", JDBCType.DOUBLE.getVendorTypeNumber(), 999999.999999999);
+        bytes = mapper.writeValueAsBytes(field);
+        sameField = mapper.readValue(bytes, Field.class);
+        Assertions.assertTrue(DataCompareUtils.isFieldEquals(field, sameField));
+
+        //timestamp type
+        field = new Field("timestamp_type", JDBCType.TIMESTAMP.getVendorTypeNumber(), Timestamp.valueOf("2019-08-10 10:49:26.926554"));
+        bytes = mapper.writeValueAsBytes(field);
+        sameField = mapper.readValue(bytes, Field.class);
+        Assertions.assertTrue(DataCompareUtils.isFieldEquals(field, sameField));
+
+    }
+
     @Override
     public UndoLogParser getParser() {
         return parser;