Kartserialisering og deserialisering med Jackson

1. Oversikt

I denne artikkelen vil vi se på serialisering og deserialisering av Java-kart ved hjelp av Jackson.

Vi illustrerer hvordan du serialiserer og deserialiserer Kart, Kart, og Kart til og fra JSON-formatert Strenger.

2. Maven-konfigurasjon

 com.fasterxml.jackson.core jackson-databind 2.11.1 

Du kan få den nyeste versjonen av Jackson her.

3. Serialisering

Serialisering konverterer et Java-objekt til en strøm av byte, som kan vedvares eller deles etter behov. Java Kart er samlinger som kartlegger en nøkkel Gjenstand til en verdi Gjenstand og er ofte de minst intuitive objektene å serieisere.

3.1. Kart Serialisering

For det enkle tilfellet, la oss lage en Kart og serieiser den til JSON:

Kartkart = nytt HashMap (); map.put ("nøkkel", "verdi"); ObjectMapper mapper = ny ObjectMapper (); Streng jsonResult = mapper.writerWithDefaultPrettyPrinter () .writeValueAsString (kart);

ObjectMapper er Jacksons seriekartlegger, som lar oss serialisere vår kart og skriv det ut som en ganske trykt JSON String, bruker toString () metode i String:

{"key": "verdi"}

3.2. Kart Serialisering

Du kan serieisere et kart som inneholder en tilpasset Java-klasse med noen få ekstra trinn. La oss lage en MyPair klasse for å representere et par relaterte String gjenstander.

Merk: getters / settere skal være offentlige, og vi kommenterer toString () med @JsonValue for å sikre at Jackson bruker denne skikken toString () når du serierer:

offentlig klasse MyPair {privat streng først; private String andre; @ Override @ JsonValue public String toString () {return first + "and" + second; } // standard getter, setters, equals, hashCode, constructors}

La oss fortelle Jackson hvordan vi skal serien MyPair ved å utvide Jacksons JsonSerializer:

offentlig klasse MyPairSerializer utvider JsonSerializer {private ObjectMapper mapper = ny ObjectMapper (); @Override public void serialize (MyPair value, JsonGenerator gen, SerializerProvider serializers) kaster IOException, JsonProcessingException {StringWriter skribent = ny StringWriter (); mapper.writeValue (skribent, verdi); gen.writeFieldName (writer.toString ()); }}

JsonSerializer, som navnet antyder, serieres MyPair til JSON ved hjelp av MyPair‘S toString () metode. Jackson tilbyr mange Serializer-klasser som passer til seriekravene dine.

Vi søker MyPairSerializer til vår Kart med @JsonSerialize kommentar. Merk at vi bare har fortalt Jackson hvordan vi skal serien MyPair fordi den allerede vet hvordan man skal serien Streng:

@JsonSerialize (keyUsing = MyPairSerializer.class) Kartkart;

La oss teste kartserialiseringen vår:

kart = nytt HashMap (); MyPair-nøkkel = ny MyPair ("Abbott", "Costello"); map.put (nøkkel, "komedie"); Streng jsonResult = mapper.writerWithDefaultPrettyPrinter () .writeValueAsString (kart);

Den serielle JSON-utgangen er:

{"Abbott og Costello": "Komedie"}

3.3. Kart Serialisering

Det mest komplekse tilfellet er å serialisere en Kart, men det meste av arbeidet er allerede gjort. La oss bruke Jacksons MapSerializer for kartet vårt, og MyPairSerializer fra forrige avsnitt for kartets nøkkel- og verdityper:

@JsonSerialize (keyUsing = MapSerializer.class) Kartkart; @JsonSerialize (keyUsing = MyPairSerializer.class) MyPair mapKey; @JsonSerialize (keyUsing = MyPairSerializer.class) MyPair mapValue;

La oss teste ut serien Kart:

mapKey = nye MyPair ("Abbott", "Costello"); mapValue = new MyPair ("Comedy", "1940s"); map.put (mapKey, mapValue); Streng jsonResult = mapper.writerWithDefaultPrettyPrinter () .writeValueAsString (kart);

Serialisert JSON-utgang ved hjelp av MyPair‘S toString () metode, er:

{"Abbott og Costello": "Komedie og 1940-tallet"}

4. Deserialisering

Deserialisering konverterer en strøm av byte til et Java-objekt som vi kan bruke i kode. I denne delen vil vi deserialisere JSON-input til Karts av forskjellige signaturer.

4.1. Kart Deserialisering

For det enkle tilfellet, la oss ta en JSON-formatert inngangsstreng og konvertere den til en Kart Java-samling:

Streng jsonInput = "{\" nøkkel \ ": \" verdi \ "}"; Type Referanse typeRef = ny TypeReference() {}; Map map = mapper.readValue (jsonInput, typeRef);

Vi bruker Jacksons ObjectMapper som vi gjorde for serialisering, ved hjelp av readValue () å behandle innspillene. Vær også oppmerksom på bruken av Jackson Type Referanse, som vi vil bruke i alle våre deserialiseringseksempler, for å beskrive typen destinasjon Kart. Her er toString () representasjon av kartet vårt:

{nøkkel = verdi}

4.2. Kart Deserialisering

La oss nå endre innspill JSON og Type Referanse av destinasjonen vår til Kart:

String jsonInput = "{\" Abbott og Costello \ ": \" Komedie \ "}"; Type Referanse typeRef = ny TypeReference() {}; Map map = mapper.readValue (jsonInput, typeRef);

Vi må lage en konstruktør for MyPair det tar en String med begge elementene og analyserer dem til MyPair elementer:

offentlig MyPair (String begge deler) {String [] par = both.split ("og"); this.first = par [0] .trim (); dette.sekund = par [1] .trim (); }

Og toString () av vår Kart objektet er:

{Abbott og Costello = komedie}

Det er et annet alternativ for saken når vi deserialiserer til en Java-klasse som inneholder en Kart - vi kan bruke Jacksons KeyDeserializer klasse, en av mange Deserialization-klasser som Jackson tilbyr. Vi kommenterer vår ClassWithAMap med @JsonCreator, @JsonProperty, og @JsonDeserialize:

offentlig klasse ClassWithAMap {@JsonProperty ("kart") @JsonDeserialize (keyUsing = MyPairDeserializer.class) privat kartkart; @JsonCreator public ClassWithAMap (Map map) {this.map = map; } // offentlige getters / setters utelatt}

Vi ber Jackson om å avregistrere Kart oppbevart i ClassWithAMap, så vi må utvide KeyDeserializer for å beskrive hvordan du deserialiserer kartets nøkkel, a MyPair objekt, fra en inngang String:

offentlig klasse MyPairDeserializer utvider KeyDeserializer {@Override public MyPair deserializeKey (String key, DeserializationContext ctxt) kaster IOException, JsonProcessingException {return new MyPair (key); }}

Vi tester deserialiseringen ved hjelp av readValue:

String jsonInput = "{\" Abbott og Costello \ ": \" Komedie \ "}"; ClassWithAMap classWithMap = mapper.readValue (jsonInput, ClassWithAMap.class);

Igjen, den toString () metode for vår ClassWithAMap's kart gir oss den produksjonen vi forventer:

{Abbott og Costello = komedie}

4.3. Kart Deserialisering

Til slutt, la oss endre innspill JSON og Type Referanse av destinasjonen vår til Kart:

String jsonInput = "{\" Abbott and Costello \ ": \" Komedie og 1940-tallet \ "}"; Type Referanse typeRef = ny TypeReference() {}; Map map = mapper.readValue (jsonInput, typeRef);

Og toString () av vår Kart objektet er:

{Abbott og Costello = komedie og 1940-tallet}

5. Konklusjon

I denne raske opplæringen har vi sett hvordan du serialiserer og deserialiserer Java Kart til og fra JSON-formaterte strenger.

Som alltid kan du sjekke eksemplet i denne artikkelen i GitHub-arkivet.