#1330 Support ability to configure global defaultTyping

Author: puneetbehl

runtime/src/main/java/io/micronaut/jackson/JacksonConfiguration.java

@@ -65,6 +65,7 @@ public class JacksonConfiguration {
     private Map<JsonParser.Feature, Boolean> parser = Collections.emptyMap();
     private Map<JsonGenerator.Feature, Boolean> generator = Collections.emptyMap();
     private JsonInclude.Include serializationInclusion = JsonInclude.Include.NON_EMPTY;
+    private ObjectMapper.DefaultTyping defaultTyping = null;
     private PropertyNamingStrategy propertyNamingStrategy = null;
 
     /**
@@ -110,6 +111,13 @@ public JsonInclude.Include getSerializationInclusion() {
         return serializationInclusion;
     }
 
+    /**
+     * @return The global defaultTyping using for Polymorphic handling
+     */
+    public ObjectMapper.DefaultTyping getDefaultTyping() {
+        return defaultTyping;
+    }
+
     /**
      * @return The default locale to use
      */
@@ -273,6 +281,15 @@ public void setSerializationInclusion(JsonInclude.Include serializationInclusion
         }
     }
 
+    /**
+     * Sets the global defaultTyping using for Polymorphic handling.
+     *
+     * @param defaultTyping The defaultTyping
+     */
+    public void setDefaultTyping(ObjectMapper.DefaultTyping defaultTyping) {
+        this.defaultTyping = defaultTyping;
+    }
+
     /**
      * Sets the property naming strategy.
      *

runtime/src/main/java/io/micronaut/jackson/ObjectMapperFactory.java

@@ -135,6 +135,11 @@ public ObjectMapper objectMapper(@Nullable JacksonConfiguration jacksonConfigura
 
         if (hasConfiguration) {
 
+            ObjectMapper.DefaultTyping defaultTyping = jacksonConfiguration.getDefaultTyping();
+            if (defaultTyping != null) {
+                objectMapper.enableDefaultTyping(defaultTyping);
+            }
+
             JsonInclude.Include include = jacksonConfiguration.getSerializationInclusion();
             if (include != null) {
                 objectMapper.setSerializationInclusion(include);

runtime/src/test/groovy/io/micronaut/jackson/parser/JacksonProcessorSpec.groovy

@@ -15,13 +15,16 @@
  */
 package io.micronaut.jackson.parser
 
+import com.fasterxml.jackson.annotation.JsonTypeInfo
 import com.fasterxml.jackson.core.JsonParseException
 import com.fasterxml.jackson.core.io.JsonEOFException
 import com.fasterxml.jackson.databind.JsonNode
 import com.fasterxml.jackson.databind.ObjectMapper
 import com.fasterxml.jackson.databind.node.ArrayNode
+import groovy.transform.ToString
 import io.micronaut.context.ApplicationContext
 import io.micronaut.context.DefaultApplicationContext
+import io.micronaut.context.env.PropertySource
 import org.reactivestreams.Subscriber
 import org.reactivestreams.Subscription
 import spock.lang.AutoCleanup
@@ -103,6 +106,219 @@ class JacksonProcessorSpec extends Specification {
         foo.age == 10
     }
 
+    void "test Jackson polymorphic deserialization"() {
+        given:
+        ObjectMapper objectMapper = applicationContext.getBean(ObjectMapper)
+        JacksonProcessor processor = new JacksonProcessor()
+        Bicycle bicycle = new MountainBike(3, 30, 10)
+        Garage instance = new Garage(bicycle: bicycle)
+
+        when:
+        def string = objectMapper.writeValueAsString(instance)
+        byte[] bytes = objectMapper.writeValueAsBytes(instance)
+        boolean complete = false
+        JsonNode node = null
+        Throwable error = null
+        int nodeCount = 0
+        processor.subscribe(new Subscriber<JsonNode>() {
+            @Override
+            void onSubscribe(Subscription s) {
+                s.request(Long.MAX_VALUE)
+            }
+
+            @Override
+            void onNext(JsonNode jsonNode) {
+                nodeCount++
+                node = jsonNode
+            }
+
+            @Override
+            void onError(Throwable t) {
+                error = t
+            }
+
+            @Override
+            void onComplete() {
+                complete = true
+            }
+        })
+        processor.onSubscribe(new Subscription() {
+            @Override
+            void request(long n) {
+
+            }
+
+            @Override
+            void cancel() {
+
+            }
+        })
+        processor.onNext(bytes)
+        processor.onComplete()
+
+        then:
+        complete
+        node != null
+        error == null
+        nodeCount == 1
+        string == '{"bicycle":{"gear":3,"speed":30,"seatHeight":10}}'
+
+        when:
+        Garage garage = objectMapper.treeToValue(node, Garage)
+
+        then:
+        !(garage.bicycle instanceof MountainBike)
+    }
+
+    void "test Jackson polymorphic deserialization, per class"() {
+        given:
+        ObjectMapper objectMapper = applicationContext.getBean(ObjectMapper)
+        JacksonProcessor processor = new JacksonProcessor()
+        Dog dog = new Dog(name: "Daisy", barkVolume: 1111.1D)
+        Zoo instance = new Zoo(animal: dog)
+
+        when:
+        def string = objectMapper.writeValueAsString(instance)
+        byte[] bytes = objectMapper.writeValueAsBytes(instance)
+        boolean complete = false
+        JsonNode node = null
+        Throwable error = null
+        int nodeCount = 0
+        processor.subscribe(new Subscriber<JsonNode>() {
+            @Override
+            void onSubscribe(Subscription s) {
+                s.request(Long.MAX_VALUE)
+            }
+
+            @Override
+            void onNext(JsonNode jsonNode) {
+                nodeCount++
+                node = jsonNode
+            }
+
+            @Override
+            void onError(Throwable t) {
+                error = t
+            }
+
+            @Override
+            void onComplete() {
+                complete = true
+            }
+        })
+        processor.onSubscribe(new Subscription() {
+            @Override
+            void request(long n) {
+
+            }
+
+            @Override
+            void cancel() {
+
+            }
+        })
+        processor.onNext(bytes)
+        processor.onComplete()
+
+        then:
+        complete
+        node != null
+        error == null
+        nodeCount == 1
+        string == '{"animal":{"@class":"io.micronaut.jackson.parser.Dog","name":"Daisy","barkVolume":1111.1}}'
+
+        when:
+        Zoo zoo = objectMapper.treeToValue(node, Zoo)
+
+        then:
+        zoo.animal instanceof Dog
+
+        when:
+        Dog animal = (Dog) zoo.animal
+
+        then:
+        animal != null
+        animal.name == "Daisy"
+        animal.barkVolume == 1111.1D
+    }
+
+    void "test Jackson polymorphic deserialization, global default typing"() {
+        given:
+        ApplicationContext applicationContext1 = new DefaultApplicationContext("test")
+        applicationContext1.environment.addPropertySource(PropertySource.of(
+                'test',  ['jackson.defaultTyping':'NON_FINAL']
+        ))
+        applicationContext1 = applicationContext1.start()
+        ObjectMapper objectMapper = applicationContext1.getBean(ObjectMapper)
+        JacksonProcessor processor = new JacksonProcessor()
+        Bicycle bicycle = new MountainBike(3, 30, 10)
+        Garage instance = new Garage(bicycle: bicycle)
+
+        when:
+        def string = objectMapper.writeValueAsString(instance)
+        byte[] bytes = objectMapper.writeValueAsBytes(instance)
+        boolean complete = false
+        JsonNode node = null
+        Throwable error = null
+        int nodeCount = 0
+        processor.subscribe(new Subscriber<JsonNode>() {
+            @Override
+            void onSubscribe(Subscription s) {
+                s.request(Long.MAX_VALUE)
+            }
+
+            @Override
+            void onNext(JsonNode jsonNode) {
+                nodeCount++
+                node = jsonNode
+            }
+
+            @Override
+            void onError(Throwable t) {
+                error = t
+            }
+
+            @Override
+            void onComplete() {
+                complete = true
+            }
+        })
+        processor.onSubscribe(new Subscription() {
+            @Override
+            void request(long n) {
+
+            }
+
+            @Override
+            void cancel() {
+
+            }
+        })
+        processor.onNext(bytes)
+        processor.onComplete()
+
+        then:
+        complete
+        node != null
+        error == null
+        nodeCount == 1
+        string == '["io.micronaut.jackson.parser.Garage",{"bicycle":["io.micronaut.jackson.parser.MountainBike",{"gear":3,"speed":30,"seatHeight":10}]}]'
+
+        when:
+        Garage garage = objectMapper.treeToValue(node, Garage)
+
+        then:
+        garage.bicycle instanceof MountainBike
+
+        when:
+        MountainBike mountainBike = (MountainBike) garage.bicycle
+
+        then:
+        mountainBike != null
+        mountainBike.gear == 3
+        mountainBike.speed == 30
+        mountainBike.seatHeight == 10
+    }
 
     void "test publish JSON array async"() {
 
@@ -289,3 +505,59 @@ class Foo {
     String name
     Integer age
 }
+
+@ToString
+class Garage {
+    String name
+    Bicycle bicycle
+}
+
+@ToString
+class Bicycle {
+    int gear
+    int speed
+
+    Bicycle() {}
+
+    Bicycle(int gear, int speed) {
+        this.gear = gear
+        this.speed = speed
+    }
+
+    void applyBrake(int decrement) {
+        speed -= decrement
+    }
+
+    void speedUp(int increment) {
+        speed += increment
+    }
+}
+
+@ToString
+class MountainBike extends Bicycle {
+    int seatHeight
+
+    MountainBike() {}
+    
+    MountainBike(int gear,int speed, int seatHeight) {
+        super(gear, speed)
+        this.seatHeight = seatHeight
+    }
+}
+
+@ToString
+class Zoo {
+    Animal animal
+}
+
+@ToString
+@JsonTypeInfo(use=JsonTypeInfo.Id.CLASS, include=JsonTypeInfo.As.PROPERTY, property="@class")
+class Animal {
+    String name
+}
+
+@ToString
+class Dog extends Animal {
+    double barkVolume
+
+}