raccolta serializzazione personalizzata per JSON: Jackson

Question

Sto cercando di JSON-serializzare un MyRootClass classe con una proprietà che è un insieme di elementi di secondo classe MyClass:

public class MyRootClass {
   private List<MyInterface> list = new ArrayList<MyInterface>();
   // getter / setter
}

public class MyClass implements MyInterface {
   private String value = "test";    
   // getter / setter
}

Il seguente codice:

MyRootClass root = new MyRootClass();
root.getList().add(new MyClass());
ObjectMapper mapper = new ObjectMapper();
mapper.writeValue(System.out, root);

genera questo output JSON:

{"list": [ {"value":"test"} ] }

al posto di quello che mi serve, ogni oggetto della collezione serializzato con un nome:

{"list": [ {"myclass": {"value":"test"}} ] }

C'è un modo per raggiungerlo usando Jackson? Ho pensato di scrivere un serializzatore personalizzato, ma non ho trovato tutto ciò che riguarda un insieme di oggetti.

Answer 1

Dipende da che cosa esattamente si vuole raggiungere con il nome; ma sì, questo può essere fatto se si desidera includere 'MyClass' ecco le informazioni sul tipo (o può agire come se fosse stato utilizzato, se non si utilizza Jackson per deserializzare esso non importa).

Se è così, si farebbe annotate MyInterface:

@JsonTypeInfo(use=Id.NAME, include=As.WRAPPER_OBJECT)

e MyClass con:

@JsonTypeName("myclass")

(se non si definisce che, nome di default sarebbe nome non qualificato della classe)

@JsonTypeInfo sopra definisce che nome del tipo deve essere utilizzato (al posto di Java nome di classe, o metodo personalizzato), e l'inclusione viene fatto utilizzando un oggetto involucro (alternative sono involucro array e come-property)

Quindi, si dovrebbe quindi vedere risultati attesi.

Answer 2

Ciò che si vuole è quella di includere il nome della classe in uscita. Questo non è come serializzatori JSON si comportano -. Comprendono solo i nomi dei campi

Che cosa si può fare è quello di introdurre un'altra classe.

class MyClass implements MyInterface {
    private MyOtherClass myclass;
}

class MyOtherClass {
    private String value = "test";
}

Answer 3

È possibile utilizzare un oggetto helper in questo modo:

public static class MyObject {
    public int i;
    public MyObject(int i) { this.i = i; }
    public MyObject() {}
}

@JsonDeserialize(contentAs=MyObject.class)
public static class MyHelperClass extends ArrayList<MyObject> {

}

@Test
public void testCollection() throws JsonGenerationException, JsonMappingException, IOException {
    final Collection<MyObject> l = new ArrayList<MyObject>();
    l.add(new MyObject(1));
    l.add(new MyObject(2));
    l.add(new MyObject(3));

    final ObjectMapper mapper = new ObjectMapper();

    final String s = mapper.writeValueAsString(l);
    final Collection<MyObject> back = mapper.readValue(s, MyHelperClass.class);

}