XML-Serialisierung und Deserialisierung mit Jackson

XML-Serialisierung und -Deserialisierung mit Jackson

1. Überblick

In diesem Tutorial werden wir unshow to serialize Java objects to XML data using Jackson 2.x and deserialize it back to a POJO ansehen.

Wir konzentrieren uns auf die grundlegende Operation, die nicht viel Komplexität oder Anpassung erfordert.

**2. XmlMapper Objekt**

XmlMapper ist die Hauptklasse von Jackson 2.x, die uns bei der Serialisierung hilft. Daher müssen wir eine Instanz davon erstellen:

XmlMapper mapper = new XmlMapper();

Diesemapper is ist injackson-dataformat-xml jar verfügbar, daher müssen wir sie als Abhängigkeit zu unserenpom.xml hinzufügen:


    com.fasterxml.jackson.dataformat
    jackson-dataformat-xml
    2.9.8

Bitte überprüfen Siethe latest version of Jackson dependency hier.

3. Serialisieren Sie Java in XML

XmlMapper ist eine Unterklasse vonObjectMapper, die bei der JSON-Serialisierung verwendet wird. Es werden jedoch einige XML-spezifische Änderungen an der übergeordneten Klasse vorgenommen.

Wir können uns nun ansehen, wie man damit die eigentliche Serialisierung durchführt. Erstellen wir zuerst eine Java-Klasse:

class SimpleBean {
    private int x = 1;
    private int y = 2;

    //standard setters and getters
}

3.1. Serialisieren Sie zu XMLString

Wir können unser Java-Objekt in die XMLString serialisieren:

@Test
public void whenJavaSerializedToXmlStr_thenCorrect() throws JsonProcessingException {
    XmlMapper xmlMapper = new XmlMapper();
    String xml = xmlMapper.writeValueAsString(new SimpleBean());
    assertNotNull(xml);
}

Als Ergebnis erhalten wir:


    1
    2

3.2. Serialisieren Sie in die XML-Datei

Wir können unser Java-Objekt auch in die XML-Datei serialisieren:

@Test
public void whenJavaSerializedToXmlFile_thenCorrect() throws IOException {
    XmlMapper xmlMapper = new XmlMapper();
    xmlMapper.writeValue(new File("simple_bean.xml"), new SimpleBean());
    File file = new File("simple_bean.xml");
    assertNotNull(file);
}

Und unten sehen wir den Inhalt der resultierenden Datei mit dem Namensimple_bean.xml:


    1
    2

4. XML in Java deserialisieren

In diesem Abschnitt erfahren Sie, wie Sie Java-Objekte aus XML abrufen.

4.1. Deserialisieren aus der XML-Zeichenfolge

Wie bei der Serialisierung können wir auch einen XML-String wieder in ein Java-Objekt deserialisieren:

@Test
public void whenJavaGotFromXmlStr_thenCorrect() throws IOException {
    XmlMapper xmlMapper = new XmlMapper();
    SimpleBean value
      = xmlMapper.readValue("12", SimpleBean.class);
    assertTrue(value.getX() == 1 && value.getY() == 2);
}

4.2. Deserialisieren aus der XML-Datei

Wenn wir eine XML-Datei haben, können wir diese ebenfalls wieder in ein Java-Objekt konvertieren.

Hier lesen wir zuerst die Datei in einen Eingabestream und konvertieren dann den Eingabestream mit einer einfachen Dienstprogrammmethode inString.

Der Rest des Codes ähnelt dem aus Abschnitt 4.1:

@Test
public void whenJavaGotFromXmlFile_thenCorrect() throws IOException {
    File file = new File("simple_bean.xml");
    XmlMapper xmlMapper = new XmlMapper();
    String xml = inputStreamToString(new FileInputStream(file));
    SimpleBean value = xmlMapper.readValue(xml, SimpleBean.class);
    assertTrue(value.getX() == 1 && value.getY() == 2);
}

Die Dienstprogrammmethode:

public String inputStreamToString(InputStream is) throws IOException {
    StringBuilder sb = new StringBuilder();
    String line;
    BufferedReader br = new BufferedReader(new InputStreamReader(is));
    while ((line = br.readLine()) != null) {
        sb.append(line);
    }
    br.close();
    return sb.toString();
}

5. Umgang mit aktivierten Elementen

In diesem Abschnitt erfahren Sie, wie Sie mit Szenarien umgehen, in denen entweder XML mit großgeschriebenen Elementen zum Deserialisieren vorhanden ist oder Java-Objekte mit einem oder mehreren großgeschriebenen Elementen in XML serialisiert werden müssen.

5.1. Deserialisieren Aus dem XMLString

Nehmen wir an, wir haben ein XML mit einem großgeschriebenen Feld:


    1
    2

Um großgeschriebene Elemente korrekt zu behandeln, müssen wir das Feld "x" mit der Annotation@JsonPropertyversehen:

class SimpleBeanForCapitalizedFields {
    @JsonProperty("X")
    private int x = 1;
    private int y = 2;

    // standard getters, setters
}

Wir können jetzt XMLString korrekt wieder in ein Java-Objekt deserialisieren:

@Test
public void whenJavaGotFromXmlStrWithCapitalElem_thenCorrect() throws IOException {
    XmlMapper xmlMapper = new XmlMapper();
    SimpleBeanForCapitalizedFields value
      = xmlMapper.readValue(
      "12",
      SimpleBeanForCapitalizedFields.class);
    assertTrue(value.getX() == 1 && value.getY() == 2);
}

5.2. Serialisieren Sie in die XML-Zeichenfolge

Durch Annotieren der erforderlichen Felder mit@JsonProperty, können wir ein Java-Objekt korrekt in ein XMLString mit einem oder mehreren großgeschriebenen Elementen serialisieren:

@Test
public void whenJavaSerializedToXmlFileWithCapitalizedField_thenCorrect()
  throws IOException {
    XmlMapper xmlMapper = new XmlMapper();
    xmlMapper.writeValue(new File("target/simple_bean_capitalized.xml"),
      new SimpleBeanForCapitalizedFields());
    File file = new File("target/simple_bean_capitalized.xml");
    assertNotNull(file);
}

6. **Serialize List to XML**

MitXmlMapper kann eine gesamte Java-Bean in ein Dokument serialisiert werden. Um ein Java-Objekt in XML zu konvertieren, nehmen wir ein einfaches Beispiel mit dem verschachtelten Objekt und den Arrays.

Unsere Absicht ist es, einPerson-Objekt zusammen mit seinem zusammengesetztenAddress-Objekt in XML zu serialisieren.

Unser endgültiges XML sieht ungefähr so aus:

Beachten Sie, dass unsere Telefonnummern in einemphoneNumbers-Wrapper eingekapselt sind, unsere Adresse jedoch nicht.

Wir können diese Nuance über die Annotation@JacksonXMLElementWrapperin unserer KlassePersonausdrücken:

public final class Person {
    private String firstName;
    private String lastName;
    private List phoneNumbers = new ArrayList<>();
    @JacksonXmlElementWrapper(useWrapping = false)
    private List address = new ArrayList<>();

    //standard setters and getters
}

Tatsächlich können wir den Namen des Umbruchelements mit@JacksonXmlElementWrapper(localName = ‘phoneNumbers'). ändern. Wenn wir unsere Elemente nicht umbrechen möchten, können wir die Zuordnung mit@JacksonXmlElementWrapper(useWrapping = false) deaktivieren.

Und dann definieren wir unserenAddress -Styp:

public class Address {
    String streetName;
    String city;
    //standard setters and getters
}

Jackson takes care of the rest for us. Wie zuvor können wir einfach wiederwriteValue aufrufen:

private static final String XML = "...";

@Test
public void whenJavaSerializedToXmlFile_thenSuccess() throws IOException {
    XmlMapper xmlMapper = new XmlMapper();
    Person person = testPerson(); // test data
    ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
    xmlMapper.writeValue(byteArrayOutputStream, person);
    assertEquals(XML, byteArrayOutputStream.toString());
}

7. Deserialisieren Sie XML inList

Jackson kann XML lesen, das auch Listen von Objekten enthält.

Wenn wir dasselbe XML wie zuvor verwenden, funktioniert diereadValue -Smethodik einwandfrei:

@Test
public void whenJavaDeserializedFromXmlFile_thenCorrect() throws IOException {
    XmlMapper xmlMapper = new XmlMapper();
    Person value = xmlMapper.readValue(XML, Person.class);
    assertEquals("City1", value.getAddress().get(0).getCity());
    assertEquals("City2", value.getAddress().get(1).getCity());
}

8. Fazit

In diesem einfachen Artikel wird veranschaulicht, wie Sie ein einfaches POJO in XML serialisieren und ein POJO aus grundlegenden XML-Daten abrufen.

Wir haben auch untersucht, wie komplexe Beans, die Sammlungen enthalten, serialisiert und deserialisiert werden können.

Der diesem Artikel beiliegende Quellcode ist aufGitHub verfügbar.

TOC

XML-Serialisierung und Deserialisierung mit Jackson