जैक्सन - नेस्टेड JSON को कैसे संसाधित (deserialize)?

Question

{ 
    vendors: [ 
    { 
     vendor: { 
     id: 367, 
     name: "Kuhn-Pollich", 
     company_id: 1, 
     } 
    }, 
    { 
     vendor: { 
     id: 374, 
     name: "Sawayn-Hermann", 
     company_id: 1, 
     } 
    }] 
} 

मैं एक वेंडर उद्देश्य यह है कि ठीक से एक भी "विक्रेता" json से deserialized किया जा सकता है, लेकिन मैं एक Vendor[] में इस deserialize करने के लिए, मैं सिर्फ यह पता लगाने नहीं कर सकते कि जैक्सन सहयोग करना चाहते हैं। कोई सुझाव?

Answer 1

आपका डेटा समस्याग्रस्त है कि आपके भीतर आपके रैपर ऑब्जेक्ट्स हैं। संभवतः आपके Vendor ऑब्जेक्ट को id, name, company_id को संभालने के लिए डिज़ाइन किया गया है, लेकिन उनमें से प्रत्येक ऑब्जेक्ट को एक ऑब्जेक्ट में एक ही संपत्ति vendor के साथ लपेटा गया है।

मुझे लगता है कि आप जैक्सन Data Binding मॉडल का उपयोग कर रहे हैं।

यदि ऐसा है तो वहाँ दो बातों पर विचार करने के लिए कर रहे हैं:

पहले एक विशेष जैक्सन config संपत्ति का उपयोग कर रहा है। जैक्सन - 1.9 से मेरा मानना ​​है कि यदि आप जैक्सन के पुराने संस्करण का उपयोग कर रहे हैं तो यह उपलब्ध नहीं हो सकता है - UNWRAP_ROOT_VALUE प्रदान करता है। यह उन मामलों के लिए डिज़ाइन किया गया है जहां आपके परिणाम शीर्ष-स्तरीय सिंगल-प्रॉपर्टी ऑब्जेक्ट में लपेटे गए हैं जिन्हें आप त्यागना चाहते हैं। आवरण वस्तुओं का उपयोग कर रहा

objectMapper.configure(SerializationConfig.Feature.UNWRAP_ROOT_VALUE, true); 

दूसरा:

तो, के साथ चारों ओर खेलते हैं। बाहरी रैपर ऑब्जेक्ट को छोड़ने के बाद भी आपको एक ही-संपत्ति ऑब्जेक्ट में लिपटे Vendor ऑब्जेक्ट्स की समस्या है। इस के आसपास पाने के लिए एक आवरण का उपयोग करें:

class VendorWrapper 
{ 
    Vendor vendor; 

    // gettors, settors for vendor if you need them 
} 

इसी तरह, बजाय UNWRAP_ROOT_VALUES का उपयोग कर के, आप भी एक आवरण वर्ग बाहरी वस्तु को संभालने के लिए निर्धारित कर सकते हैं। यह मानते हुए कि आपके पास सही Vendor, VendorWrapper वस्तु, आप को परिभाषित कर सकते हैं:

class VendorsWrapper 
{ 
    List<VendorWrapper> vendors = new ArrayList<VendorWrapper>(); 

    // gettors, settors for vendors if you need them 
} 

// in your deserialization code: 
ObjectMapper mapper = new ObjectMapper(); 
JsonNode rootNode = mapper.readValue(jsonInput, VendorsWrapper.class); 

VendorsWrapper के लिए वस्तु पेड़ आपके JSON के अनुरूप है:

VendorsWrapper: 
    vendors: 
    [ 
     VendorWrapper 
      vendor: Vendor, 
     VendorWrapper: 
      vendor: Vendor, 
     ... 
    ] 

अंत में, आप जैक्सन Tree Model उपयोग कर सकते हैं इस पार्स करने के लिए

mapper.readValue(node.get("vendor").getTextValue(), Vendor.class); 

: JsonNodes, बाहरी नोड को त्यागकर, और ArrayNode में प्रत्येक JsonNode के लिए, बुला में

जिसके परिणामस्वरूप कम कोड हो सकता है, लेकिन यह दो रैपर का उपयोग करने से कम बेकार लगता है।

Answer 2

यहां एक मोटा लेकिन अधिक घोषणात्मक समाधान है। मैं इसे एक ही टिप्पणी में नहीं ले पाया, लेकिन ऐसा लगता है कि यह अच्छी तरह से काम करता है। बड़े डेटा सेट पर प्रदर्शन के बारे में भी सुनिश्चित नहीं है।

को देखते हुए इस JSON:

{ 
    "list": [ 
     { 
      "wrapper": { 
       "name": "Jack" 
      } 
     }, 
     { 
      "wrapper": { 
       "name": "Jane" 
      } 
     } 
    ] 
} 

और ये मॉडल वस्तुओं:

public class RootObject { 
    @JsonProperty("list") 
    @JsonDeserialize(contentUsing = SkipWrapperObjectDeserializer.class) 
    @SkipWrapperObject("wrapper") 
    public InnerObject[] innerObjects; 
} 

और

public class InnerObject { 
    @JsonProperty("name") 
    public String name; 
} 

कहाँ जैक्सन वूडू की तरह कार्यान्वित किया जाता है:

@Retention(RetentionPolicy.RUNTIME) 
@JacksonAnnotation 
public @interface SkipWrapperObject { 
    String value(); 
} 

और

public class SkipWrapperObjectDeserializer extends JsonDeserializer<Object> implements 
     ContextualDeserializer { 
    private Class<?> wrappedType; 
    private String wrapperKey; 

    public JsonDeserializer<?> 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); 
    } 
} 

इस आशा किसी के लिए उपयोगी है!

Answer 3

@Patrick मैं अपने समाधान थोड़ा

@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; 
} 

में सुधार होगा यह तेजी से काम करता है :)