Comment renommer une clé racine dans la sérialisation JSON avec Jackson

Je suis à l'aide de Jackson pour la sérialisation JSON d'une liste d'objets.

Voici ce que j'obtiens:

{"ArrayList":[{"id":1,"name":"test name"}]}

Mais ce que je veux c' :

{"rootname":[{"id":1,"name":"test name"}]} //ie showing the string I want as the root name.

Voici ma démarche:

Interface:

public interface MyInterface {
    public long getId();
    public String getName();
}

Mise en œuvre de la classe:

@JsonRootName(value = "rootname")
public class MyImpl implements MyInterface {
    private final long id;
    private String name;

    public MyImpl(final long id,final name) {
        this.id = id;
        this.name = name;
    }

   //getters     
}

La sérialisation JSon:

public class MySerializer {
    public static String serializeList(final List<MyInterface> lists) {
        //check for null value.Throw Exception
        final ObjectMapper mapper = new ObjectMapper();
        mapper.configure(SerializationConfig.Feature.WRAP_ROOT_VALUE, true);
        return mapper.writeValueAsString(lists);
    }
}

Test:

final List<MyInterface> list = new ArrayList<MyImpl>();
MyImpl item = new MyImpl(1L,"test name");
list.add(item);
final String json = MySerializer.serializeList(list);
System.out.println(json);

Voici ce que j'obtiens:

{"ArrayList":[{"id":1,"name":"test name"}]}

Mais ce que je veux c' :

{"rootname":[{"id":1,"name":"test name"}]} //ie showing the string I want as the root     name.

J'ai essayé toutes les solutions proposées que j'ai pu trouver, mais a échoué à atteindre mon objectif. J'ai regardé:

Ou ai-je raté quelque chose? Je suis à l'aide de jackson 1.9.12 pour cela. Toute aide à ce sujet est la bienvenue.

essayez de sérialiser une instance de MyImpl pas une Liste de MyImpl. Le processus est en train de faire son travail depuis qu'il est à la recouvrant d'une Liste et non un MyInterface objet.

InformationsquelleAutor user2266861 | 2013-04-10

30

Bien, par défaut Jackson utilise l'un des deux annotations lorsque vous essayez de déterminer le nom de la racine à afficher pour enveloppé valeurs - @XmlRootElement ou @JsonRootName. Il s'attend à ce que l'annotation d'être sur le type de sérialisées, sinon il utilisera le simple nom de du type que le nom de la racine.

Dans votre cas, vous êtes de la sérialisation d'une liste, c'est pourquoi le nom de la racine est 'ArrayList' (simple nom du type sérialisé). Chaque élément de la liste peut être annotée avec @JsonRootName, mais la liste elle-même n'est pas.

Lorsque la racine de la valeur que vous essayez de retour à la ligne est une collection, alors vous devez trouver un moyen de définir l'écharpe nom:

Titulaire/Classe Wrapper

Vous pouvez créer une classe wrapper pour contenir la liste, avec une annotation pour définir la propriété nom (vous ne devez utiliser cette méthode si vous n'avez pas le contrôle direct de la ObjectMapper/JSON processus de transformation):
```
class MyInterfaceList {
    @JsonProperty("rootname")
    private List<MyInterface> list;

    public List<MyInterface> getList() {
        return list;
    }

    public void setList(List<MyInterface> list) {
        this.list = list;
    }
}

final List<MyInterface> lists = new ArrayList<MyInterface>(4);
lists.add(new MyImpl(1L, "test name"));
MyInterfaceList listHolder = new MyInterfaceList();
listHolder.setList(lists);
final String json = mapper.writeValueAsString(listHolder);
```
Objet Écrivain

C'est l'option préférable. Utiliser un configuré ObjectWriter exemple pour générer du JSON. En particulier, nous nous intéressons à la withRootName méthode:
```
final List<MyInterface> lists = new ArrayList<MyInterface>(4);
lists.add(new MyImpl(1L, "test name"));
final ObjectWriter writer = mapper.writer().withRootName("rootName");
final String json = writer.writeValueAsString(lists);
```
- Pour le cas lorsque vous créez un objectmapper et de le transmettre à la 3e partie libs, comment pouvez-vous mettre en œuvre la ObjectWriter cas générique? Je ne vois aucun moyen de dire jackson "Utiliser ce objectwriter pour ces types de tous les temps".
- Tout faire en une seule ligne new ObjectMapper().enable(SerializationFeature.WRAP_ROOT_VALUE).writer().withRootName("rootName").writeValueAsString(lists)
InformationsquelleAutor Perception

Je sais, je suis en retard , mais j'ai une meilleure approche qui ne nécessitent pas Titulaire/Classe Wrapper. Il vient de la racine de la clé à partir de l'annotation.

package com.test;

import com.fasterxml.jackson.annotation.JsonRootName;


@JsonRootName("Products")
public class ProductDTO {
    private String name;
    private String description;

    public String getName() {
        return name;
    }

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

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }
}

Ici est la classe de test:-

package com.test;

import java.io.IOException;
import java.util.ArrayList;

import org.junit.Test;

import com.fasterxml.jackson.annotation.JsonRootName;
import com.fasterxml.jackson.core.JsonGenerationException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;


public class ProductDTOTestCase {
    @Test
    public void testPersistAndFindById() throws JsonGenerationException, JsonMappingException, IOException {
        ObjectMapper mapper = new ObjectMapper();
        ProductDTO productDTO = new ProductDTO();
        productDTO.setDescription("Product 4 - Test");

        ArrayList<ProductDTO> arrayList = new ArrayList<ProductDTO>();
        arrayList.add(productDTO);

        String rootName = ProductDTO.class.getAnnotation(JsonRootName.class).value();
        System.out.println(mapper.writer().withRootName(rootName).writeValueAsString(arrayList));

    }


}

Il va donner suite à la sortie

{"Products":[{"name":null,"description":"Product 4 - Test"}]}

InformationsquelleAutor Vaibhav

@JsonTypeName("usuarios")
@JsonTypeInfo(include= JsonTypeInfo.As.WRAPPER_OBJECT,use= JsonTypeInfo.Id.NAME)
public class UsuarioDT extends ArrayList<Usuario> {

    @JsonProperty("rowsAffected")
    private Integer afectados;

    public Integer getAfectados() {
        return afectados;
    }

    public void setAfectados(Integer afectados) {
        this.afectados = afectados;
    }
}

Veuillez considérer l'ajout d'une explication quant à la pourquoi c'est la réponse.

InformationsquelleAutor Jose Montestruque

0

Vous avez besoin pour utiliser cette annotation en haut de la classe

@JsonTypeName("rootname")

InformationsquelleAutor ekv

Vous devez vous connecter pour publier un commentaire.

Titulaire/Classe Wrapper

Objet Écrivain