Jackson - How to process deserialize nested JSON

Question

vendors                vendor            id  367          name   Kuhn-Pollich           company id  1                             vendor            id  374          name   Sawayn-Hermann           company id  1                   I have a Vendor object that can properly be deserialized from a single  vendor  json  but I want to deserialize this into  a Vendor    I just can t figure out how to make Jackson cooperate   Any tips

User · Answer

Patrick I would improve your solution a bit   Override public Object deserialize JsonParser jp  DeserializationContext ctxt          throws IOException  JsonProcessingException               ObjectNode objectNode   jp readValueAsTree        JsonNode wrapped   objectNode get wrapperKey       JsonParser parser   node traverse        parser setCodec jp getCodec         Vendor mapped   parser readValueAs Vendor class       return mapped      It works faster

User · Answer

Your data is problematic in that you have inner wrapper objects in your array  Presumably your Vendor object is designed to handle id  name  company id  but each of those multiple objects are also wrapped in an object with a single property vendor   I m assuming that you re using the Jackson Data Binding model   If so then there are two things to consider   The first is using a special Jackson config property  Jackson - since 1 9 I believe  this may not be available if you re using an old version of Jackson - provides UNWRAP ROOT VALUE  It s designed for cases where your results are wrapped in a top-level single-property object that you want to discard   So  play around with   objectMapper configure SerializationConfig Feature UNWRAP ROOT VALUE  true     The second is using wrapper objects  Even after discarding the outer wrapper object you still have the problem of your Vendor objects being wrapped in a single-property object  Use a wrapper to get around this   class VendorWrapper       Vendor vendor          gettors  settors for vendor if you need them     Similarly  instead of using UNWRAP ROOT VALUES  you could also define a wrapper class to handle the outer object  Assuming that you have correct Vendor  VendorWrapper object  you can define   class VendorsWrapper       List lt VendorWrapper gt  vendors   new ArrayList lt VendorWrapper gt             gettors  settors for vendors if you need them       in your deserialization code  ObjectMapper mapper   new ObjectMapper    JsonNode rootNode   mapper readValue jsonInput  VendorsWrapper class      The object tree for VendorsWrapper is analogous to your JSON   VendorsWrapper      vendors                VendorWrapper             vendor  Vendor          VendorWrapper              vendor  Vendor                      Finally  you might use the Jackson Tree Model to parse this into JsonNodes  discarding the outer node  and for each JsonNode in the ArrayNode  calling   mapper readValue node get  vendor   getTextValue    Vendor class     That might result in less code  but it seems no less clumsy than using two wrappers

User · Answer

Here is a rough but more declarative solution   I haven t been able to get it down to a single annotation  but this seems to work well   Also not sure about performance on large data sets   Given this JSON          list                            wrapper                      name    Jack                                                  wrapper                      name    Jane                                    And these model objects   public class RootObject        JsonProperty  list        JsonDeserialize contentUsing   SkipWrapperObjectDeserializer class       SkipWrapperObject  wrapper       public InnerObject   innerObjects      and  public class InnerObject        JsonProperty  name       public String name      Where the Jackson voodoo is implemented like    Retention RetentionPolicy RUNTIME   JacksonAnnotation public  interface SkipWrapperObject       String value        and  public class SkipWrapperObjectDeserializer extends JsonDeserializer lt Object gt  implements         ContextualDeserializer       private Class lt   gt  wrappedType      private String wrapperKey       public JsonDeserializer lt   gt  createContextual DeserializationContext ctxt              BeanProperty property  throws JsonMappingException           SkipWrapperObject skipWrapperObject   property                  getAnnotation SkipWrapperObject class           wrapperKey   skipWrapperObject value            JavaType collectionType   property getType            JavaType collectedType   collectionType containedType 0           wrappedType   collectedType getRawClass            return this              Override     public Object deserialize JsonParser parser  DeserializationContext ctxt              throws IOException  JsonProcessingException           ObjectMapper mapper   new ObjectMapper            ObjectNode objectNode   mapper readTree parser           JsonNode wrapped   objectNode get wrapperKey           Object mapped   mapIntoObject wrapped           return mapped             private Object mapIntoObject JsonNode node  throws IOException              JsonProcessingException           JsonParser parser   node traverse            ObjectMapper mapper   new ObjectMapper            return mapper readValue parser  wrappedType             Hope this is useful to someone

User · Answer

I m quite late to the party  but one approach is to use a static inner class to unwrap values  import com fasterxml jackson annotation JsonCreator  import com fasterxml jackson annotation JsonProperty  import com fasterxml jackson core JsonProcessingException  import com fasterxml jackson databind ObjectMapper   class Scratch       private final String aString      private final String bString      private final String cString      private final static String jsonString       static           jsonString    quot   n quot                     quot     quot wrap  quot      n quot                     quot       quot A  quot     quot foo  quot   n quot                     quot       quot B  quot     quot bar  quot   n quot                     quot       quot C  quot     quot baz  quot  n quot                     quot     n quot                     quot   quot               JsonCreator     Scratch  JsonProperty  quot A quot   String aString               JsonProperty  quot B quot   String bString               JsonProperty  quot C quot   String cString            this aString   aString          this bString   bString          this cString   cString              Override     public String toString             return  quot Scratch  quot                     quot aString   quot    aString                           quot   bString   quot    bString                           quot   cString   quot    cString                                          public static class JsonDeserializer           private final Scratch scratch            JsonCreator         public JsonDeserializer  JsonProperty  quot wrap quot   Scratch scratch                this scratch   scratch                     public Scratch getScratch                 return scratch                       public static void main String   args  throws JsonProcessingException           ObjectMapper objectMapper   new ObjectMapper            Scratch scratch   objectMapper readValue jsonString  Scratch JsonDeserializer class  getScratch            System out println scratch toString              However  it s probably easier to use objectMapper configure SerializationConfig Feature UNWRAP ROOT VALUE  true   in conjunction with  JsonRootName  quot aName quot    as pointed out by pb2q

[java] Jackson - How to process (deserialize) nested JSON?

Examples related to java

Examples related to json

Examples related to serialization

Examples related to jackson