Introduksjon til Jackson ObjectMapper

1. Oversikt

Denne opplæringen fokuserer på å forstå Jackson ObjectMapper klasse og hvordan du serialiserer Java-objekter til JSON og deserialiserer JSON-streng til Java-objekter.

For å forstå mer om Jackson-biblioteket generelt, er Jackson Tutorial et godt sted å starte.

2. Avhengigheter

La oss først legge til følgende avhengigheter til pom.xml:

 com.fasterxml.jackson.core jackson-databind 2.11.1

Denne avhengigheten vil også legge til følgende biblioteker til klassestien:

jackson-merknader
jackson-core

Bruk alltid de nyeste versjonene fra Maven sentrale arkiv for jackson-databind.

3. Lese og skrive ved hjelp ObjectMapper

La oss starte med de grunnleggende lese- og skriveoperasjonene.

Det enkle readValue API for ObjectMapper er et godt inngangspunkt. Vi kan bruke den til å analysere eller deserialisere JSON-innhold til et Java-objekt.

Også på skrivesiden, vi kan bruke writeValue API for å serieisere ethvert Java-objekt som JSON-utgang.

Vi bruker følgende Bil klasse med to felt som gjenstand for å serieisere eller deserialisere gjennom denne artikkelen:

offentlig klasse Bil {privat Strengfarge; privat streng type; // standard getters setter}

3.1. Java-objekt til JSON

La oss se et første eksempel på serialisering av et Java-objekt til JSON ved hjelp av writeValue metoden for ObjectMapper klasse:

ObjectMapper objectMapper = ny ObjectMapper (); Bilbil = ny bil ("gul", "renault"); objectMapper.writeValue (ny fil ("target / car.json"), bil);

Resultatet av ovennevnte i filen vil være:

{"color": "gul", "type": "renault"}

Metodene writeValueAsString og writeValueAsBytes av ObjectMapper klasse genererer en JSON fra et Java-objekt og returnerer den genererte JSON som en streng eller som en byte-array:

String carAsString = objectMapper.writeValueAsString (car);

3.2. JSON til Java-objekt

Nedenfor er et enkelt eksempel på å konvertere en JSON-streng til et Java-objekt ved hjelp av ObjectMapper klasse:

String json = "{\" color \ ": \" Black \ ", \" type \ ": \" BMW \ "}"; Car car = objectMapper.readValue (json, Car.class);

De readValue () funksjonen godtar også andre former for inngang, for eksempel en fil som inneholder JSON-streng:

Bilbil = objectMapper.readValue (ny fil ("src / test / resources / json_car.json"), Car.class);

eller en URL:

Car car = objectMapper.readValue (ny URL ("fil: src / test / resources / json_car.json"), Car.class);

3.3. JSON til Jackson JsonNode

Alternativt kan en JSON analyseres i en JsonNode objekt og brukes til å hente data fra en bestemt node:

String json = "{\" color \ ": \" Black \ ", \" type \ ": \" FIAT \ "}"; JsonNode jsonNode = objectMapper.readTree (json); Strengfarge = jsonNode.get ("farge"). Som Tekst (); // Utgang: farge -> Svart

3.4. Opprette en Java-liste fra en JSON Array-streng

Vi kan analysere en JSON i form av en matrise i en Java-objektliste ved hjelp av a Type Referanse:

String jsonCarArray = "[{\" color \ ": \" Black \ ", \" type \ ": \" BMW \ "}, {\" color \ ": \" Red \ ", \" type \ ": \ "FIAT \"}] "; List listCar = objectMapper.readValue (jsonCarArray, ny TypeReference(){});

3.5. Opprette Java-kart fra JSON-streng

På samme måte kan vi analysere en JSON i en Java Kart:

String json = "{\" color \ ": \" Black \ ", \" type \ ": \" BMW \ "}"; Map map = objectMapper.readValue (json, ny TypeReference(){});

4. Avanserte funksjoner

En av de største styrkene ved Jackson-biblioteket er den svært tilpassbare serie- og deserialiseringsprosessen.

I denne delen vil vi gå gjennom noen avanserte funksjoner der inngangen eller utgangen JSON-respons kan være forskjellig fra objektet som genererer eller forbruker svaret.

4.1. Konfigurere Serialization eller Deserialization Feature

Mens JSON-objekter konverteres til Java-klasser, i tilfelle JSON-strengen har noen nye felt, vil standardprosessen resultere i et unntak:

String jsonString = "{\" color \ ": \" Black \ ", \" type \ ": \" Fiat \ ", \" year \ ": \" 1970 \ "}";

JSON-strengen i eksemplet ovenfor i standard parsingsprosessen til Java-objektet for Klassebil vil resultere i UnrecognizedPropertyException unntak.

Gjennom konfigurere metode, kan vi utvide standardprosessen for å ignorere de nye feltene:

objectMapper.configure (DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); Car car = objectMapper.readValue (jsonString, Car.class); JsonNode jsonNodeRoot = objectMapper.readTree (jsonString); JsonNode jsonNodeYear = jsonNodeRoot.get ("år"); Strengår = jsonNodeYear.asText ();

Nok et alternativ er basert på FAIL_ON_NULL_FOR_PRIMITIVES, som definerer om null verdier for primitive verdier er tillatt:

objectMapper.configure (DeserializationFeature.FAIL_ON_NULL_FOR_PRIMITIVES, false);

På samme måte, FAIL_ON_NUMBERS_FOR_ENUM kontrollerer om enumverdier er tillatt å serieiseres / deserialiseres som tall:

objectMapper.configure (DeserializationFeature.FAIL_ON_NUMBERS_FOR_ENUMS, false);

Du finner den omfattende listen over funksjoner for serialisering og deserialisering på det offisielle nettstedet.

4.2. Opprette egendefinert Serializer eller Deserializer

Et annet viktig trekk ved ObjectMapper klasse er muligheten til å registrere en tilpasset serializer og deserializer.

Egendefinerte serie- og deserialiserere er veldig nyttige i situasjoner der inngangen eller utgangen JSON-respons har en annen struktur enn Java-klassen som den må serialiseres eller deserialiseres til.

Nedenfor er et eksempel på en tilpasset JSON-serialisator:

offentlig klasse CustomCarSerializer utvider StdSerializer {offentlig CustomCarSerializer () {dette (null); } offentlig CustomCarSerializer (klasse t) {super (t); } @ Override public void serialize (Car car, JsonGenerator jsonGenerator, SerializerProvider serializer) {jsonGenerator.writeStartObject (); jsonGenerator.writeStringField ("car_brand", car.getType ()); jsonGenerator.writeEndObject (); }}

Denne egendefinerte serialisereren kan påberopes slik:

ObjectMapper mapper = ny ObjectMapper (); SimpleModule-modul = ny SimpleModule ("CustomCarSerializer", ny versjon (1, 0, 0, null, null, null)); module.addSerializer (Car.class, ny CustomCarSerializer ()); mapper.registerModule (modul); Bilbil = ny bil ("gul", "renault"); String carJson = mapper.writeValueAsString (bil);

Her er hva Bil ser ut som (som JSON-utgang) på klientsiden:

var carJson = {"car_brand": "renault"}

Og her er et eksempel på en tilpasset JSON deserializer:

offentlig klasse CustomCarDeserializer utvider StdDeserializer {offentlig CustomCarDeserializer () {dette (null); } offentlig CustomCarDeserializer (klasse vc) {super (vc); } @ Override public Car deserialize (JsonParser parser, DeserializationContext deserializer) {Car car = new Car (); ObjectCodec codec = parser.getCodec (); JsonNode-node = codec.readTree (parser); // prøv fangstblokk JsonNode colorNode = node.get ("farge"); Strengfarge = colorNode.asText (); car.setColor (farge); returbil; }}

Denne egendefinerte deserialisereren kan påberopes på denne måten:

String json = "{\" color \ ": \" Black \ ", \" type \ ": \" BMW \ "}"; ObjectMapper mapper = ny ObjectMapper (); SimpleModule-modul = ny SimpleModule ("CustomCarDeserializer", ny versjon (1, 0, 0, null, null, null)); module.addDeserializer (Car.class, ny CustomCarDeserializer ()); mapper.registerModule (modul); Car car = mapper.readValue (json, Car.class);

4.3. Håndtering av datoformater

Standard serialisering av java.util.Date produserer et tall, dvs. epoke tidsstempel (antall millisekunder siden 1. januar 1970, UTC). Men dette er ikke veldig leselig for mennesker og krever at ytterligere konvertering skal vises i et lesbart format.

La oss pakke inn Bil eksempel vi brukte så langt inne i Be om klasse med kjøpt dato eiendom:

offentlig klasse Forespørsel {privat bilbil; privat Dato datoKjøpt; // standard getters setters}

For å kontrollere strengformatet til en dato og sette den til f.eks. åååå-MM-dd HH: mm a z, vurder følgende kodebit:

ObjectMapper objectMapper = ny ObjectMapper (); DateFormat df = new SimpleDateFormat ("åååå-MM-dd HH: mm a z"); objectMapper.setDateFormat (df); String carAsString = objectMapper.writeValueAsString (forespørsel); // output: {"car": {"color": "yellow", "type": "renault"}, "datePurchased": "2016-07-03 11:43 CEST"}

Hvis du vil lære mer om seriellisering av datoer med Jackson, kan du lese vår mer grundige beskrivelse.

4.4. Håndtering av samlinger

En annen liten, men nyttig funksjon som er tilgjengelig gjennom Deserialisering Funksjon klasse er evnen til å generere den typen samling vi ønsker fra et JSON Array-svar.

For eksempel kan vi generere resultatet som en matrise:

String jsonCarArray = "[{\" color \ ": \" Black \ ", \" type \ ": \" BMW \ "}, {\" color \ ": \" Red \ ", \" type \ ": \ "FIAT \"}] "; ObjectMapper objectMapper = ny ObjectMapper (); objectMapper.configure (DeserializationFeature.USE_JAVA_ARRAY_FOR_JSON_ARRAY, true); Car [] cars = objectMapper.readValue (jsonCarArray, Car []. Class); // trykkbiler

Eller som en Liste:

String jsonCarArray = "[{\" color \ ": \" Black \ ", \" type \ ": \" BMW \ "}, {\" color \ ": \" Red \ ", \" type \ ": \ "FIAT \"}] "; ObjectMapper objectMapper = ny ObjectMapper (); List listCar = objectMapper.readValue (jsonCarArray, ny TypeReference() {}); // trykkbiler

Mer informasjon om håndtering av samlinger med Jackson er tilgjengelig her.

5. Konklusjon

Jackson er et solid og modent JSON-serialiserings- / deserialiseringsbibliotek for Java. De ObjectMapper API gir en enkel måte å analysere og generere JSON-responsobjekter med mye fleksibilitet. Denne artikkelen diskuterte hovedfunksjonene som gjør biblioteket så populært.

Kildekoden som følger med artikkelen finner du på GitHub.

streamalism.org