XML-Serialisierung und Deserialisierung mit Jackson

1. Übersicht

In diesem Tutorial werden wir uns ansehen, wie Java-Objekte mit Jackson 2.x in XML-Daten serialisiert und wieder in ein POJO deserialisiert werden .

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();

Dieser Mapper ist im jackson-dataformat-xml- Jar verfügbar , daher müssen wir ihn als Abhängigkeit zu unserer pom.xml hinzufügen :

 com.fasterxml.jackson.dataformat jackson-dataformat-xml 2.11.1 

Bitte überprüfen Sie die neueste Version der Abhängigkeit von jackson-dataformat-xml im Maven-Repository.

3. Serialisieren Sie Java in XML

XmlMapper ist eine Unterklasse von ObjectMapper, die bei der JSON-Serialisierung verwendet wird. Es werden jedoch einige XML-spezifische Optimierungen zur übergeordneten Klasse hinzugefügt.

Wir können uns nun ansehen, wie wir damit die eigentliche Serialisierung durchführen können. Lassen Sie uns zuerst eine Java-Klasse erstellen:

class SimpleBean { private int x = 1; private int y = 2; //standard setters and getters }

3.1. Serialisieren Sie in die XML- Zeichenfolge

Wir können unser Java-Objekt in den XML- String 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 Namen simple_bean.xml :

 1 2 

4. Deserialisieren Sie XML in Java

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 sie 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 in einen String .

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 wird erläutert, wie Szenarien behandelt werden, 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. Deserialize aus dem XML - String

Angenommen, 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 @JsonProperty versehen :

class SimpleBeanForCapitalizedFields { @JsonProperty("X") private int x = 1; private int y = 2; // standard getters, setters }

Wir können jetzt einen XML- String wieder korrekt 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 einen XML- String 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. Serialisieren Sie die Liste in XML

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

Our intent is to serialize a Person object, along with its composed Address object, into XML.

Our final XML will look something like:

 Rohan Daye  9911034731 9911033478   Name1 City1   Name2 City2  

Notice that our phone numbers are encapsulated in a phoneNumbers wrapper while our address is not.

We can express this nuance via the @JacksonXMLElementWrapper annotation in our Person class:

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 }

Actually, we can change the wrapping element name with @JacksonXmlElementWrapper(localName = ‘phoneNumbers'). Or, if we don't want to wrap our elements, we can disable the mapping with @JacksonXmlElementWrapper(useWrapping = false).

And then let's define our Address type:

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

Jackson kümmert sich für uns um den Rest. Wie zuvor können wir einfach wieder writeValue 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 in Liste

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

Wenn wir dasselbe XML wie zuvor verwenden, reicht die readValue- Methode aus:

@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 wurde veranschaulicht, wie ein einfaches POJO in XML serialisiert und ein POJO aus grundlegenden XML-Daten abgerufen wird.

Wir haben uns auch mit der Serialisierung und Deserialisierung komplexer Beans befasst, die Sammlungen enthalten.

Der diesem Artikel beiliegende Quellcode ist auf GitHub verfügbar.