जैक्सन के साथ एक फ्लैट JSON ऑब्जेक्ट में एक सूची सामग्री को क्रमबद्ध करने के लिए कैसे?

Question

निम्नलिखित POJOs को देखते हुए ..

public class City { 

    private String title; 
    private List<Person> people; 
} 

...

public class Person { 

    private String name; 
    private int age; 
} 

मैं निम्नलिखित उदाहरण के लिए कक्षाओं के Jackson serialize उदाहरणों जाने के लिए JSON चाहते हैं:

{ 
    "title" : "New York", 
    "personName_1" : "Jane Doe", 
    "personAge_1" : 42, 
    "personName_2" : "John Doe", 
    "personAge_2" : 23 
} 

जेएसओएन प्रारूप को बाहरी एपीआई द्वारा परिभाषित किया गया है जिसे मैं नहीं बदल सकता।

मैं पहले से ही पता चला है कि मैं इस तरह के रूप में एक कस्टम serializer साथ सूची क्षेत्र टिप्पणी कर सकते हैं:

@JsonSerialize(using = PeopleSerializer.class) 
private List<Person> people; 

... और यहाँ एक बुनियादी कार्यान्वयन मैंने कोशिश की है:

public class PeopleSerializer extends JsonSerializer<List<Person>> { 

    private static final int START_INDEX = 1; 

    @Override 
    public void serialize(List<Person> people, 
          JsonGenerator generator, 
          SerializerProvider provider) throws IOException { 
     for (int i = 0; i < people.size(); ++i) { 
      Person person = people.get(i); 
      int index = i + START_INDEX; 
      serialize(person, index, generator); 
     } 
    } 

    private void serialize(Person person, int index, JsonGenerator generator) throws IOException { 
     generator.writeStringField(getIndexedFieldName("personName", index), 
            person.getName()); 
     generator.writeNumberField(getIndexedFieldName("personAge", index), 
            person.getAge()); 
    } 

    private String getIndexedFieldName(String fieldName, int index) { 
     return fieldName + "_" + index; 
    } 

} 

हालांकि, इस एक के साथ विफल:

JsonGenerationException: Can not write a field name, expecting a value 

मैं भी जैक्सन के Converter इंटरफेस लेकिन था का उपयोग कर में देखा टी नेस्टेड सूची ऑब्जेक्ट्स को खोलने के लिए उपयुक्त नहीं है।

• देखें: https://stackoverflow.com/a/41651324/356895

मैं भी @JsonUnwrapped के बारे में पता कर रहा हूँ, लेकिन यह सूची के साथ उपयोग के लिए डिज़ाइन नहीं किया गया है।

संबंधित पदों

• Serialize List content in a flat structure in jackson json (Java)
• Jackson: How to add custom property to the JSON without modifying the POJO
• How to serialize only the ID of a child with Jackson

संबंधित पोस्ट (अक्रमांकन)

• Jackson list deserialization. nested Lists

संबंधित पुस्तकालय

• Jackson JSON Interceptor Module

Answer 1

आप BeanSerializerModifier का उपयोग सीधे संशोधित करने के लिए कैसे एक संपत्ति का नाम और मान लिखे गए हैं कर सकते हैं। इसका उपयोग करके आप यह पता लगा सकते हैं कि कस्टम एनोटेशन मौजूद है या नहीं, इस मामले में मैंने @FlattenCollection नामक एक बनाया है। जब एनोटेशन मौजूद होता है तो सरणी या संग्रह सामान्य विधि का उपयोग नहीं किया जाता है बल्कि इसके बजाय कस्टम प्रॉपर्टी लेखक (FlattenCollectionPropertyWriter) द्वारा लिखा जाता है।

यह एनोटेशन 2 डी सरणी या अन्य किनारे के मामलों पर तोड़ने की संभावना है, मैंने उन लोगों का परीक्षण किया है, लेकिन संभवतः आप बिना किसी परेशानी के उनके लिए कोड कर सकते हैं, कम से कम एक सार्थक त्रुटि फेंक दें।

पूर्ण कार्य कोड है। उल्लेखनीय अंक

• FlattenCollectionSerializerModifier.changeProperties
• FlattenCollectionPropertyWriter.serializeAsField
• जोड़ी Todos मैं आप के लिए वहाँ में डाल रहे हैं।

आउटपुट:

{ 
    "titleCity" : "New York", 
    "personName_1" : "Foo", 
    "personAge_1" : 123, 
    "personName_2" : "Baz", 
    "personAge_2" : 22 
} 

कोड: क्योंकि `के लिए serializer City` लिखते

import com.fasterxml.jackson.core.JsonGenerator; 
import com.fasterxml.jackson.databind.*; 
import com.fasterxml.jackson.databind.ser.*; 
import com.fasterxml.jackson.databind.util.NameTransformer; 

import java.lang.annotation.ElementType; 
import java.lang.annotation.Retention; 
import java.lang.annotation.RetentionPolicy; 
import java.lang.annotation.Target; 
import java.util.*; 

public class SO45698499 { 


    public static void main(String [] args) throws Exception { 
     ObjectWriter writer = createMapper().writerWithDefaultPrettyPrinter(); 
     String val = writer.writeValueAsString(new City("New York", 
       Arrays.asList(new Person("Foo", 123), new Person("Baz", 22)))); 

     System.out.println(val); 
    } 


    /** 
    * Constructs our mapper with the serializer modifier in mind 
    * @return 
    */ 
    public static ObjectMapper createMapper() { 
     FlattenCollectionSerializerModifier modifier = new FlattenCollectionSerializerModifier(); 
     SerializerFactory sf = BeanSerializerFactory.instance.withSerializerModifier(modifier); 
     ObjectMapper mapper = new ObjectMapper(); 
     mapper.setSerializerFactory(sf); 

     return mapper; 
    } 

    @Target({ElementType.ANNOTATION_TYPE, ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER}) 
    @Retention(RetentionPolicy.RUNTIME) 
    public @interface FlattenCollection { 
    } 

    /** 
    * Looks for the FlattenCollection annotation and modifies the bean writer 
    */ 
    public static class FlattenCollectionSerializerModifier extends BeanSerializerModifier { 

     @Override 
     public List<BeanPropertyWriter> changeProperties(SerializationConfig config, BeanDescription beanDesc, List<BeanPropertyWriter> beanProperties) { 
      for (int i = 0; i < beanProperties.size(); i++) { 
       BeanPropertyWriter writer = beanProperties.get(i); 
       FlattenCollection annotation = writer.getAnnotation(FlattenCollection.class); 
       if (annotation != null) { 
        beanProperties.set(i, new FlattenCollectionPropertyWriter(writer)); 
       } 
      } 
      return beanProperties; 
     } 
    } 

    /** 
    * Instead of writing a collection as an array, flatten the objects down into values. 
    */ 
    public static class FlattenCollectionPropertyWriter extends BeanPropertyWriter { 
     private final BeanPropertyWriter writer; 

     public FlattenCollectionPropertyWriter(BeanPropertyWriter writer) { 
      super(writer); 
      this.writer = writer; 
     } 

     @Override 
     public void serializeAsField(Object bean, 
            JsonGenerator gen, 
            SerializerProvider prov) throws Exception { 
      Object arrayValue = writer.get(bean); 

      // lets try and look for array and collection values 
      final Iterator iterator; 
      if(arrayValue != null && arrayValue.getClass().isArray()) { 
       // deal with array value 
       iterator = Arrays.stream((Object[])arrayValue).iterator(); 
      } else if(arrayValue != null && Collection.class.isAssignableFrom(arrayValue.getClass())) { 
       iterator = ((Collection)arrayValue).iterator(); 
      } else { 
       iterator = null; 
      } 

      if(iterator == null) { 
       // TODO: write null? skip? dunno, you gonna figure this one out 
      } else { 
       int index=0; 
       while(iterator.hasNext()) { 
        index++; 
        Object value = iterator.next(); 
        if(value == null) { 
         // TODO: skip null values and still increment or maybe dont increment? You decide 
        } else { 
         // TODO: OP - update your prefix/suffix here, its kinda weird way of making a prefix 
         final String prefix = value.getClass().getSimpleName().toLowerCase(); 
         final String suffix = "_"+index; 
         prov.findValueSerializer(value.getClass()) 
           .unwrappingSerializer(new FlattenNameTransformer(prefix, suffix)) 
           .serialize(value, gen, prov); 
        } 
       } 
      } 
     } 
    } 

    public static class FlattenNameTransformer extends NameTransformer { 

     private final String prefix; 
     private final String suffix; 

     public FlattenNameTransformer(String prefix, String suffix) { 
      this.prefix = prefix; 
      this.suffix = suffix; 
     } 

     @Override 
     public String transform(String name) { 
      // captial case the first letter, to prepend the suffix 
      String transformedName = Character.toUpperCase(name.charAt(0)) + name.substring(1); 
      return prefix + transformedName + suffix; 
     } 
     @Override 
     public String reverse(String transformed) { 
      if (transformed.startsWith(prefix)) { 
       String str = transformed.substring(prefix.length()); 
       if (str.endsWith(suffix)) { 
        return str.substring(0, str.length() - suffix.length()); 
       } 
      } 
      return null; 
     } 
     @Override 
     public String toString() { return "[FlattenNameTransformer('"+prefix+"','"+suffix+"')]"; } 
    } 


    /*=============================== 
    * POJOS 
    ===============================*/ 
    public static class Person { 
     private String name; 
     private int age; 

     public Person(String name, int age) { 
      this.name = name; 
      this.age = age; 
     } 

     public String getName() { 
      return name; 
     } 

     public void setName(String name) { 
      this.name = name; 
     } 

     public int getAge() { 
      return age; 
     } 

     public void setAge(int age) { 
      this.age = age; 
     } 
    } 

    public static class City { 
     private String titleCity; 
     private List<Person> people; 

     public City(String title, List<Person> people) { 
      this.titleCity = title; 
      this.people = people; 
     } 

     public String getTitleCity() { 
      return titleCity; 
     } 

     public void setTitleCity(String titleCity) { 
      this.titleCity = titleCity; 
     } 

     @FlattenCollection 
     public List<Person> getPeople() { 
      return people; 
     } 

     public void setPeople(List<Person> people) { 
      this.people = people; 
     } 
    } 
} 

Answer 2

मैं क्षेत्र स्तरीय एनोटेशन संदेह पर this link आधार पर केवल मूल्य नहीं पूरे गुण लेखन प्रतिनिधियों।

एक (बल्कि kludgey) वैकल्पिक हल पूरे शहर वर्ग के लिए एक कस्टम serializer के लिए हो सकता है:

@JsonSerialize(using = CitySerializer.class) 
public class City { 
    private String title; 
    @JsonIgnore 
    private List<Person> people; 
} 

...और फिर

public class CitySerializer extends JsonSerializer<City> { 

    private static final int START_INDEX = 1; 

    @Override 
    public void serialize(City city, 
          JsonGenerator generator, 
          SerializerProvider provider) throws IOException { 
     generator.writeStartObject(); 

     // Write all properties (except ignored) 
     JavaType javaType = provider.constructType(City.class); 
     BeanDescription beanDesc = provider.getConfig().introspect(javaType); 
     JsonSerializer<Object> serializer = BeanSerializerFactory.instance.findBeanSerializer(provider, 
       javaType, 
       beanDesc); 
     serializer.unwrappingSerializer(null).serialize(value, jgen, provider);` 

     // Custom serialization of people 
     List<Person> people = city.getPeople(); 
     for (int i = 0; i < people.size(); ++i) { 
      Person person = people.get(i); 
      int index = i + START_INDEX; 
      serialize(person, index, generator); 
     } 

     generator.writeEndObject(); 
    } 

    private void serialize(Person person, int index, JsonGenerator generator) throws IOException { 
     generator.writeStringField(getIndexedFieldName("personName", index), 
            person.getName()); 
     generator.writeNumberField(getIndexedFieldName("personAge", index), 
            person.getAge()); 
    } 

    private String getIndexedFieldName(String fieldName, int index) { 
     return fieldName + "_" + index; 
    } 

}