ObjectSerializer should deserialize using Argument<T>

Author: dstepanov

core/src/main/java/io/micronaut/core/serialize/JdkSerializer.java

@@ -18,6 +18,7 @@
 import io.micronaut.core.convert.ConversionService;
 import io.micronaut.core.reflect.ClassUtils;
 import io.micronaut.core.serialize.exceptions.SerializationException;
+import io.micronaut.core.type.Argument;
 
 import java.io.IOException;
 import java.io.InputStream;
@@ -82,6 +83,25 @@ public <T> Optional<T> deserialize(InputStream inputStream, Class<T> requiredTyp
         }
     }
 
+    @Override
+    public <T> Optional<T> deserialize(InputStream inputStream, Argument<T> requiredType) throws SerializationException {
+        try {
+            try (ObjectInputStream objectIn = createObjectInput(inputStream, requiredType.getType())) {
+                try {
+                    Object readObject = objectIn.readObject();
+
+                    return conversionService.convert(readObject, requiredType);
+                } catch (ClassCastException cce) {
+                    throw new SerializationException("Invalid type deserialized from stream: " + cce.getMessage(), cce);
+                } catch (ClassNotFoundException e) {
+                    throw new SerializationException("Type not found deserializing from stream: " + e.getMessage(), e);
+                }
+            }
+        } catch (IOException e) {
+            throw new SerializationException("I/O error occurred during deserialization: " + e.getMessage(), e);
+        }
+    }
+
     /**
      * @param outputStream The output stream
      * @return A new {@link ObjectOutputStream}

core/src/main/java/io/micronaut/core/serialize/ObjectSerializer.java

@@ -18,6 +18,8 @@
 import io.micronaut.core.serialize.exceptions.SerializationException;
 
 import edu.umd.cs.findbugs.annotations.Nullable;
+import io.micronaut.core.type.Argument;
+
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
@@ -58,6 +60,20 @@ public interface ObjectSerializer {
      */
     <T> Optional<T> deserialize(@Nullable InputStream inputStream, Class<T> requiredType) throws SerializationException;
 
+    /**
+     * Deserialize the given object to bytes.
+     *
+     * @param inputStream  The input stream
+     * @param requiredType The required type
+     * @param <T>          The required generic type
+     * @return An {@link Optional} of the object
+     * @throws SerializationException if there is a serialization problem
+     * @since 2.0
+     */
+    default <T> Optional<T> deserialize(@Nullable InputStream inputStream, Argument<T> requiredType) throws SerializationException {
+        return deserialize(inputStream, requiredType.getType());
+    }
+
     /**
      * Serialize the given object to a byte[].
      *
@@ -97,6 +113,20 @@ default <T> Optional<T> deserialize(@Nullable byte[] bytes, Class<T> requiredTyp
         }
     }
 
+    /**
+     * Deserialize the given object to bytes.
+     *
+     * @param bytes        The byte array
+     * @param requiredType The required type
+     * @param <T>          The required generic type
+     * @return An {@link Optional} of the object
+     * @throws SerializationException if there is a serialization problem
+     * @since 2.0
+     */
+    default <T> Optional<T> deserialize(@Nullable byte[] bytes, Argument<T> requiredType) throws SerializationException {
+        return deserialize(bytes, requiredType.getType());
+    }
+
     /**
      * Deserialize the given object to bytes.
      *

runtime/src/main/java/io/micronaut/jackson/serialize/JacksonObjectSerializer.java

@@ -16,9 +16,12 @@
 package io.micronaut.jackson.serialize;
 
 import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.JavaType;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import io.micronaut.core.serialize.ObjectSerializer;
 import io.micronaut.core.serialize.exceptions.SerializationException;
+import io.micronaut.core.type.Argument;
+import io.micronaut.jackson.JacksonConfiguration;
 
 import javax.inject.Singleton;
 import java.io.IOException;
@@ -79,4 +82,24 @@ public <T> Optional<T> deserialize(InputStream inputStream, Class<T> requiredTyp
             throw new SerializationException("Error deserializing object from JSON: " + e.getMessage(), e);
         }
     }
+
+    @Override
+    public <T> Optional<T> deserialize(byte[] bytes, Argument<T> requiredType) throws SerializationException {
+        try {
+            JavaType javaType = JacksonConfiguration.constructType(requiredType, objectMapper.getTypeFactory());
+            return Optional.ofNullable(objectMapper.readValue(bytes, javaType));
+        } catch (IOException e) {
+            throw new SerializationException("Error deserializing object from JSON: " + e.getMessage(), e);
+        }
+    }
+
+    @Override
+    public <T> Optional<T> deserialize(InputStream inputStream, Argument<T> requiredType) throws SerializationException {
+        try {
+            JavaType javaType = JacksonConfiguration.constructType(requiredType, objectMapper.getTypeFactory());
+            return Optional.ofNullable(objectMapper.readValue(inputStream, javaType));
+        } catch (IOException e) {
+            throw new SerializationException("Error deserializing object from JSON: " + e.getMessage(), e);
+        }
+    }
 }