streamalism.org

1. Oversikt

I denne opplæringen skal vi se på hvordan du serialiserer Java-objekter til XML-data ved hjelp av Jackson 2.x og deserialiserer dem tilbake til en POJO.

Vi vil fokusere på den grunnleggende operasjonen som ikke krever mye kompleksitet eller tilpasning.

2. XmlMapper Gjenstand

XmlMapper er hovedklassen fra Jackson 2.x som hjelper oss med serialisering, så vi må lage en forekomst av den:

XmlMapper-kartlegger = ny XmlMapper ();

Dette kartlegger er tilgjengelig i jackson-dataformat-xml krukke, så vi må legge den til som en avhengighet av vår pom.xml:

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

Vennligst sjekk den siste versjonen av jackson-dataformat-xml avhengighet i Maven repository.

3. Serialiser Java til XML

XmlMapper er en underklasse av ObjectMapper som brukes i JSON-serialisering. Imidlertid legger det til noen XML-spesifikke justeringer til foreldreklassen.

Vi kan nå se på hvordan du bruker den til å gjøre den faktiske serialiseringen. La oss lage en Java-klasse først:

klasse SimpleBean {privat int x = 1; privat int y = 2; // standard setters og getters}

3.1. Serialiser til XML String

Vi kan serieisere Java-objektet vårt til XML String:

@Test offentlig ugyldig nårJavaSerializedToXmlStr_thenCorrect () kaster JsonProcessingException {XmlMapper xmlMapper = ny XmlMapper (); Streng xml = xmlMapper.writeValueAsString (ny SimpleBean ()); assertNotNull (xml); }

Som et resultat får vi:

 1 2 

3.2. Serialiser til XML-filen

Vi kan også serieisere Java-objektet vårt til XML-filen:

@Test offentlig ugyldig nårJavaSerializedToXmlFile_thenCorrect () kaster IOException {XmlMapper xmlMapper = ny XmlMapper (); xmlMapper.writeValue (ny fil ("simple_bean.xml"), ny SimpleBean ()); Filfil = ny fil ("simple_bean.xml"); assertNotNull (fil); }

Og nedenfor kan vi se innholdet i den resulterende filen som heter simple_bean.xml:

 1 2 

4. Deserialiser XML til Java

I denne delen vil vi se på hvordan du skaffer Java-objekter fra XML.

4.1. Deserialiser fra XML-strengen

Som med serialisering kan vi også deserialisere en XML-streng tilbake til et Java-objekt:

@Test offentlig ugyldig nårJavaGotFromXmlStr_thenCorrect () kaster IOException {XmlMapper xmlMapper = ny XmlMapper (); SimpleBean-verdi = xmlMapper.readValue ("12", SimpleBean.class); assertTrue (value.getX () == 1 && value.getY () == 2); }

4.2. Deserialiser fra XML-filen

På samme måte, hvis vi har en XML-fil, kan vi konvertere den tilbake til et Java-objekt.

Her leser vi først filen til en inngangsstrøm og konverterer deretter inngangsstrømmen til en String med en enkel verktøymetode.

Resten av koden ligner den fra avsnitt 4.1:

@Test offentlig ugyldig nårJavaGotFromXmlFile_thenCorrect () kaster IOException {File file = new File ("simple_bean.xml"); XmlMapper xmlMapper = ny XmlMapper (); Streng xml = inputStreamToString (ny FileInputStream (fil)); SimpleBean-verdi = xmlMapper.readValue (xml, SimpleBean.class); assertTrue (value.getX () == 1 && value.getY () == 2); }

Verktøymetoden:

offentlig String inputStreamToString (InputStream er) kaster IOException {StringBuilder sb = ny StringBuilder (); Streng linje; BufferedReader br = ny BufferedReader (ny InputStreamReader (er)); mens ((linje = br.readLine ())! = null) {sb.append (linje); } br.close (); returner sb.toString (); }

5. Håndtering av aktiverte elementer

I denne delen vil vi se på hvordan vi skal håndtere scenarier der vi enten har XML med store bokstaver for å deserialisere, eller vi trenger å serieisere Java-objekter til XML med ett eller flere store og små bokstaver.

5.1. Deserialiser fra XML String

La oss si at vi har en XML med ett felt med stort:

 1 2 

For å kunne håndtere store bokstaver, må vi kommentere “x” -feltet med @JsonProperty kommentar:

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

Vi kan nå deserialisere en XML riktig String tilbake til et Java-objekt:

@Test offentlig ugyldig nårJavaGotFromXmlStrWithCapitalElem_thenCorrect () kaster IOException {XmlMapper xmlMapper = ny XmlMapper (); SimpleBeanForCapitalizedFields value = xmlMapper.readValue ("12", SimpleBeanForCapitalizedFields.class); assertTrue (value.getX () == 1 && value.getY () == 2); }

5.2. Serialiser til XML-strengen

Ved å kommentere obligatoriske felt med @JsonProperty, vi kan riktig serieisere et Java-objekt til en XML String med ett eller flere store bokstaver:

@Test offentlig annullert nårJavaSerializedToXmlFileWithCapitalizedField_thenCorrect () kaster IOException {XmlMapper xmlMapper = ny XmlMapper (); xmlMapper.writeValue (ny fil ("target / simple_bean_capitalized.xml"), nye SimpleBeanForCapitalizedFields ()); Filfil = ny fil ("target / simple_bean_capitalized.xml"); assertNotNull (fil); }

6. Serialiser Liste til XML

De XmlMapper er i stand til å serieisere en hel Java-bønne til et dokument. For å konvertere Java-objekt til XML, tar vi et enkelt eksempel med nestet objekt og arrays.

Vår hensikt er å serieisere en Person objekt, sammen med det sammensatte Adresse objekt, inn i XML.

Vår endelige XML vil se ut som:

 Rohan Daye 9911034731 9911033478 Navn1 By1 Navn2 By2 

Legg merke til at telefonnumrene våre er innkapslet i a telefonnummer innpakning mens adressen vår ikke er.

Vi kan uttrykke denne nyansen via @JacksonXMLElementWrapper kommentar i vår Person klasse:

offentlig sluttklasse Person {privat streng fornavn; privat streng etternavn; private List phoneNumbers = new ArrayList (); @JacksonXmlElementWrapper (useWrapping = false) privat Listeadresse = ny ArrayList (); // standard setters og getters}

Egentlig kan vi endre innpakningselementnavnet med @JacksonXmlElementWrapper (localName = ‘telefonnumre’). Eller hvis vi ikke vil pakke inn elementene våre, kan vi deaktivere kartleggingen med @JacksonXmlElementWrapper (useWrapping = false).

Og så la oss definere våre Adresse type:

offentlig klasse Adresse {String streetName; Strengby; // standard settere og getters}

Jackson tar seg av resten for oss. Som før kan vi bare ringe writeValue en gang til:

privat statisk slutt String XML = "..."; @Test offentlig ugyldig nårJavaSerializedToXmlFile_thenSuccess () kaster IOException {XmlMapper xmlMapper = ny XmlMapper (); Personperson = testPerson (); // testdata ByteArrayOutputStream byteArrayOutputStream = ny ByteArrayOutputStream (); xmlMapper.writeValue (byteArrayOutputStream, person); assertEquals (XML, byteArrayOutputStream.toString ()); }

7. Deserialiser XML til Liste

Jackson kan lese XML som også inneholder lister over objekter.

Hvis vi tar vår samme XML som før, blir readValue metoden gjør det bra:

@Test offentlig ugyldig nårJavaDeserializedFromXmlFile_thenCorrect () kaster IOException {XmlMapper xmlMapper = ny XmlMapper (); Personverdi = xmlMapper.readValue (XML, Person.class); assertEquals ("City1", value.getAddress (). get (0) .getCity ()); assertEquals ("City2", value.getAddress (). get (1) .getCity ()); }

8. Konklusjon

Denne enkle artikkelen illustrerte hvordan du serierer en enkel POJO til XML og skaffer en POJO fra grunnleggende XML-data.

Vi har også sett på hvordan vi kan serieisere og deserialisere komplekse bønner som inneholder samlinger.

Kildekoden som følger med denne artikkelen er tilgjengelig på GitHub.