Wie wickeln Sie eine Liste als top-level element im JSON-Format generiert, die von Jackson

Habe ich ein problem, bei dem ich versucht bin, um eine Liste der root-Knoten, aber ich kann nicht scheinen, um in der Lage sein, diese zu bekommen. Lassen Sie mich erklären. Sagen wir, wir haben eine Klasse "TestClass"

class TestClass{
    String propertyA;       
}

Nun, einige utility-Methode dies ist, was ich tun

String utilityMethod(){
   List<TestClass> list = someService.getList();
   new ObjectMapper().writeValueAsString(list); 
}

Den Ausgang bin ich versucht, zu JSON ist

{"ListOfTestClasses":[{"propertyA":"propertyAValue"},{"propertyA":"someOtherPropertyValue"}]}

Habe ich versucht,

objMapper.getSerializationConfig().set(Feature.WRAP_ROOT_VALUE, true);

Aber, ich weiß immer noch nicht scheinen, um es richtig zu machen.

Gerade jetzt, ich bin nur die Schaffung eines Map < String,TestClass > und ich Schreibe, dass zu erreichen, was ich versuche zu tun, was funktioniert, aber klar ist das ein hack. Könnte mir bitte jemand helfen mit eine elegantere Lösung? Dank

InformationsquelleAutor Seagull | 2013-04-15

  1. 15

    Leider auch mit der WRAP_ROOT_VALUE Funktion aktiviert ist, müssen Sie noch zusätzliche Logik für die Steuerung der root-name generiert, wenn serialisieren eines Java-collection (siehe diese Antwort für details, warum). Die Blätter, die Sie mit den Optionen:

    • mit einer Halter-Klasse zum definieren der root-name -
    • mit einer Karte.
    • mithilfe einer benutzerdefinierten ObjectWriter

    Hier ist etwas code zur Veranschaulichung der drei verschiedenen Optionen:

    public class TestClass {
    private String propertyA;

    //constructor/getters/setters
}

public class TestClassListHolder {

    @JsonProperty("ListOfTestClasses")
    private List<TestClass> data;

    //constructor/getters/setters
}

public class TestHarness {

    protected List<TestClass> getTestList() {
        return Arrays.asList(new TestClass("propertyAValue"), new TestClass(
                "someOtherPropertyValue"));
    }

    @Test
    public void testSerializeTestClassListDirectly() throws Exception {
        final ObjectMapper mapper = new ObjectMapper();
        mapper.configure(SerializationFeature.WRAP_ROOT_VALUE, true);
        System.out.println(mapper.writeValueAsString(getTestList()));
    }

    @Test
    public void testSerializeTestClassListViaMap() throws Exception {
        final ObjectMapper mapper = new ObjectMapper();
        final Map<String, List<TestClass>> dataMap = new HashMap<String, List<TestClass>>(
                4);
        dataMap.put("ListOfTestClasses", getTestList());
        System.out.println(mapper.writeValueAsString(dataMap));
    }

    @Test
    public void testSerializeTestClassListViaHolder() throws Exception {
        final ObjectMapper mapper = new ObjectMapper();
        final TestClassListHolder holder = new TestClassListHolder();
        holder.setData(getTestList());
        System.out.println(mapper.writeValueAsString(holder));
    }

    @Test
    public void testSerializeTestClassListViaWriter() throws Exception {
        final ObjectMapper mapper = new ObjectMapper();
        final ObjectWriter writer = mapper.writer().withRootName(
                "ListOfTestClasses");
        System.out.println(writer.writeValueAsString(getTestList()));
    }
}

    Ausgabe:

    {"ArrayList":[{"propertyA":"propertyAValue"},{"propertyA":"someOtherPropertyValue"}]}

    {"ListOfTestClasses":[{"propertyA":"propertyAValue"},{"propertyA":"someOtherPropertyValue"}]}

    {"ListOfTestClasses":[{"propertyA":"propertyAValue"},{"propertyA":"someOtherPropertyValue"}]}

    {"ListOfTestClasses":[{"propertyA":"propertyAValue"},{"propertyA":"someOtherPropertyValue"}]}

    Mit einem ObjectWriter ist sehr bequem - nur im Hinterkopf kahl, dass alle top-level-Objekte serialisiert mit es wird die gleiche root-name. Wenn das nicht erwünscht, dann verwenden Sie eine Karte oder eine Halter-Klasse statt.

    +1 würde für die Verwendung von annotations

    InformationsquelleAutor Perception

  2. 1

    Ich würde erwarten, dass die grundlegende Idee, so etwas wie:

    class UtilityClass {
    List listOfTestClasses;
    UtilityClass(List tests) {
        this.listOfTestClasses = tests;
    }
}

String utilityMethod(){
    List<TestClass> list = someService.getList();
    UtilityClass wrapper = new UtilityClass(list);
    new ObjectMapper().writeValueAsString(wrapper); 
}
    Ist das wirklich die beste Lösung?
    Es ist sehr ähnlich zu der "Karte" - Lösung, die ich bin derzeit mit.

    InformationsquelleAutor searlea

Schreibe einen Kommentar