Deserialisieren verschachtelten Array als ArrayList mit Jackson

Habe ich ein Stück von JSON sieht wie folgt aus:

{
  "authors": {
    "author": [
      {
        "given-name": "Adrienne H.",
        "surname": "Kovacs"
      },
      {
        "given-name": "Philip",
        "surname": "Moons"
      }
    ]
   }
 }

Habe ich eine Klasse zum speichern von Informationen zum Autor:

public class Author {
    @JsonProperty("given-name")
    public String givenName;
    public String surname;
}

Und zwei wrapper-Klassen:

public class Authors {
    public List<Author> author;
}

public class Response {
    public Authors authors;
}

Diese arbeitet, aber mit zwei wrapper-Klassen zu sein scheint, unnötig. Ich möchte einen Weg finden, zu entfernen Authors Klasse und haben eine Liste als Eigenschaft der Einstiegsklasse. Ist sowas möglich ist mit Jackson?

Update

Gelöst, dass mit benutzerdefinierten deserializer:

public class AuthorArrayDeserializer extends JsonDeserializer<List<Author>> {

    private static final String AUTHOR = "author";
    private static final ObjectMapper mapper = new ObjectMapper();
    private static final CollectionType collectionType =
            TypeFactory
            .defaultInstance()
            .constructCollectionType(List.class, Author.class);

    @Override
    public List<Author> deserialize(JsonParser jsonParser, DeserializationContext deserializationContext)
            throws IOException, JsonProcessingException {

        ObjectNode objectNode = mapper.readTree(jsonParser);
        JsonNode nodeAuthors = objectNode.get(AUTHOR);

        if (null == nodeAuthors                     //if no author node could be found
                || !nodeAuthors.isArray()           //or author node is not an array
                || !nodeAuthors.elements().hasNext())   //or author node doesn't contain any authors
            return null;

        return mapper.reader(collectionType).readValue(nodeAuthors);
    }
}

Und verwenden Sie es wie folgt:

@JsonDeserialize(using = AuthorArrayDeserializer.class)
public void setAuthors(List<Author> authors) {
    this.authors = authors;
}

Dank @wassgren für die Idee.

InformationsquelleAutor der Frage Dmitry | 2015-01-12

Sehe ich mindestens zwei Wege, um dies zu tun, wenn Sie wollen, um loszuwerden, wrapper-Klassen. Die erste ist die Verwendung der Jackson-Baum-Modell (JsonNode) und die zweite ist die Verwendung einer Deserialisierung feature namens UNWRAP_ROOT_VALUE.

Alternative 1: Verwendung JsonNode

Beim Deserialisieren von JSON mit Jackson gibt es mehrere Möglichkeiten, um zu Steuern, welche Art von Objekte, die erstellt werden sollen. Die ObjectMapper Deserialisieren können die JSON-z.B. MapJsonNode (über die readTree-Methode) oder ein POJO.

Wenn Sie kombinieren die readTree-Methode mit der POJO Umwandlung der Wrapper kann komplett entfernt werden. Beispiel:

//The author class (a bit cleaned up)
public class Author {
    private final String givenName;
    private final String surname;

    @JsonCreator
    public Author(
            @JsonProperty("given-name") final String givenName,
            @JsonProperty("surname") final String surname) {

        this.givenName = givenName;
        this.surname = surname;
    }

    public String getGivenName() {
        return givenName;
    }

    public String getSurname() {
        return surname;
    }
}

Die Deserialisierung kann dann wie folgt Aussehen:

//The JSON
final String json = "{\"authors\":{\"author\":[{\"given-name\":\"AdrienneH.\",\"surname\":\"Kovacs\"},{\"given-name\":\"Philip\",\"surname\":\"Moons\"}]}}";

ObjectMapper mapper = new ObjectMapper();

//Read the response as a tree model
final JsonNode response = mapper.readTree(json).path("authors").path("author");

//Create the collection type (since it is a collection of Authors)
final CollectionType collectionType =
        TypeFactory
                .defaultInstance()
                .constructCollectionType(List.class, Author.class);

//Convert the tree model to the collection (of Author-objects)
List<Author> authors = mapper.reader(collectionType).readValue(response);

//Now the authors-list is ready to use...

Wenn Sie das Baum-Modell-Ansatz der wrapper-Klassen kann vollständig entfernt werden.

Alternative 2: entfernen Sie eine der Wrapper und packen Sie das root-Wert
Der zweite Ansatz ist das entfernen nur einer der Wrapper. Angenommen, Sie entfernen die Authors Klasse, aber halten die Response-wrapper. Wenn Sie fügen Sie eine @JsonRootName-annotation können Sie später Auspacken der top-level-Namen.

@JsonRootName("authors") //This is new compared to your example
public class Response {
    private final List<Author> authors;

    @JsonCreator
    public Response(@JsonProperty("author") final List<Author> authors) {
        this.authors = authors;
    }

    @JsonProperty("author")
    public List<Author> getAuthors() {
        return authors;
    }
}

Dann, für die mapper verwenden Sie einfach:

ObjectMapper mapper = new ObjectMapper();

//Unwrap the root value i.e. the "authors"
mapper.configure(DeserializationFeature.UNWRAP_ROOT_VALUE, true);
final Response responsePojo = mapper.readValue(json, Response.class);

Dem zweiten Ansatz nur entfernt einer der wrapper-Klassen, sondern die parsing-Funktion ist Recht hübsch.

InformationsquelleAutor der Antwort wassgren

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.