जैक्सन का उपयोग कर कस्टम क्रमबद्धता/deserialization कैसे करें?

Question

मैं निम्नलिखित जीएसएस क्रमबद्धता को जैक्सन क्रमबद्धता में बदलने की कोशिश कर रहा हूं। कृपया मुझे बताएं कि इसे जैक्सन

public class AbstractElementAdapter 
    implements JsonSerializer<AbstractElement>, JsonDeserializer<AbstractElement> 
{ 
    @Override 
    public JsonElement serialize(AbstractElement src, Type typeOfSrc, JsonSerializationContext context) { 
     JsonObject result = new JsonObject(); 
     JsonObject properties = context.serialize(src, src.getClass()).getAsJsonObject(); 

     if (src instanceof TruncatedElement) { 
      result.add("type", new JsonPrimitive(((TruncatedElement) src).getClassName())); 
      properties.remove("className"); 
     } else { 
      result.add("type", new JsonPrimitive(src.getClass().getSimpleName())); 
     } 

     result.add("properties", properties); 

     return result; 
    } 

    @Override 
    public AbstractElement deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException { 
     JsonObject jsonObject = json.getAsJsonObject(); 
     String type = jsonObject.get("type").getAsString(); 
     JsonElement element = jsonObject.get("properties"); 

     try { 
      return context.deserialize(element, Class.forName("com.zreflect.emyed.whiteboard.model.element." + type)); 
     } catch (ClassNotFoundException cnfe) { 
      throw new JsonParseException("Unknown element type: " + type, cnfe); 
     } 
    } 
} 

Answer 1

जैक्सन आपको एनोटेशन के माध्यम से धारावाहिक निर्दिष्ट करने की अनुमति देता है। उदाहरण के लिए, नीचे तुच्छ उदाहरण देखें: फिर

@JsonSerialize(using FooToStringSerializer) 
public class Foo implements Serializable { 

    private String bar; 

    public Foo(String bar) { 
     this.bar = bar; 
} 

, सभी अगर मैं यह देखने के लिए जब वस्तु धारावाहिक bar था, मैं तो जैसे serializer बनाने चाहते थे:

public class FooToStringSerializer extends JsonSerializer<Foo> { 

    @Override 
    public void serialize(final Foo value, final JsonGenerator jgen, 
     final SerializerProvider provider) throws IOException 
    { 
     jgen.writeObject(value.getBar()); 
    } 

अक्रमांकन के लिए, आप एक deserializer बना सकते हैं और इसे ObjectMapper के साथ पंजीकृत कर सकते हैं जो deserialization कर रहे हैं।

एक वस्तु नक्शाकार के साथ एक deserializer रजिस्टर करने के लिए नीचे दिए गए कार्य करें:

ObjectMapper mapper = new ObjectMapper(); 
SimpleModule module = new SimpleModule(); 
module.addDeserializer(Item.class, new FooDeserializer()); 
mapper.registerModule(module); 

एक वास्तव में आसान कस्टम अक्रमांकन के उदाहरण का अनुसरण करने के लिए, को देखने के लिए इस लिंक के लिए: http://www.baeldung.com/jackson-deserialization

Answer 2

आप एक कस्टम बना सकते हैं serializer, इस तरह कुछ:

public class ItemSerializer extends JsonSerializer<AbstractElement> { 
     @Override 
     public void serialize(AbstractElement src, JsonGenerator jgen, SerializerProvider provider) 
       throws IOException, JsonProcessingException { 
      jgen.writeStartObject(); 

      if (src instanceof TruncatedElement) { 
       jgen.writeStringField("type",((TruncatedElement) src).getClassName()); 
       jgen.writeObjectFieldStart("properties"); 
       //use jgen.writeStringField(); 
       //jgen.writeNumberField(); 
       //etc to every one of the values, 
       //but skipping className 
       jgen.writeEndObject(); 


      } else { 
       jgen.writeStringField("type", src.getClass().getSimpleName()); 
       //write everythin 
       jgen.writeObjectField("properties", src); 
      } 

      jgen.writeEndObject(); 
     } 
    } 

और इसे ऑब्जेक्टमैपर के साथ पंजीकृत करें और फिर क्रमबद्ध करें:

ObjectMapper mapper = new ObjectMapper(); 

SimpleModule module = new SimpleModule(); 
module.addSerializer(yourObject.class, new ItemSerializer()); 
mapper.registerModule(module); 

String serialized = mapper.writeValueAsString(yourObject); 

className, आप भी एक कस्टम फ़ील्ड फिल्टर का उपयोग करना चाहते हो सकता है लंघन की चाल करने के लिए

, तो आप एक महान उदाहरण यहाँ है: http://www.baeldung.com/jackson-ignore-properties-on-serialization