Jak serializować zawartość listy do płaskiego obiektu JSON z Jacksonem?

Question

Biorąc pod uwagę następujące POJOs ..

public class City { 

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

...

public class Person { 

    private String name; 
    private int age; 
} 

Chciałbym niech Jackson instancje serializacji z klas następującemu przykład JSON:

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

Format JSON jest zdefiniowany przez zewnętrzny interfejs API, którego nie można zmienić.

I już, że mogę opisywać pole listy z niestandardowych serializatora takich jak:

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

... i tutaj jest podstawowym realizacja Próbowałem:

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

} 

to jednak nie powiodło się z:

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

Sprawdziłem również przy użyciu interfejsu Jacksona Converter, ale t nie nadaje się do rozpakowania zagnieżdżonych obiektów list.

• Patrz: https://stackoverflow.com/a/41651324/356895

Jestem też świadomy @JsonUnwrapped ale nie jest przeznaczony do stosowania z list.

Notki

• 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

Podobne posty (deserializacji)

• Jackson list deserialization. nested Lists

pokrewne biblioteka

• Jackson JSON Interceptor Module

Answer 1

Można użyć BeanSerializerModifier bezpośrednio modyfikować jak nazwa właściwości i wartości są zapisywane. Dzięki temu możesz wykryć, czy niestandardowa adnotacja jest obecna, w tym przypadku utworzyłem jeden o nazwie @FlattenCollection. Gdy adnotacja jest obecna, tablica lub kolekcja nie została zapisana przy użyciu normalnej metody, ale zamiast tego została zapisana przez niestandardowy program piszący (FlattenCollectionPropertyWriter).

Ta adnotacja prawdopodobnie zostanie przerwana na tablicach 2d lub innych skrajnych przypadkach, których nie testowałem, ale prawdopodobnie mógłbyś dla nich napisać bez większych problemów, przynajmniej rzucić sensowny błąd.

Oto pełny działający kod. Ważniejsze punkty są

• FlattenCollectionSerializerModifier.changeProperties
• FlattenCollectionPropertyWriter.serializeAsField
• Para TODO i umieścić tam dla ciebie.

wyjściowa:

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

Kod:

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

podstawie this link Podejrzewam adnotacji pola poziomie tylko delegaci Zapis wartości nie całe właściwości.

A (raczej kludgey) Rozwiązaniem może być posiadanie własnego serializatora dla całej klasy Miasto:

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

...a następnie

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

}