Úvod do nástroja Jackson ObjectMapper

1. Prehľad

Tento výukový program sa zameriava na pochopenie Jacksona ObjectMapper triedy a ako serializovať objekty Java do formátu JSON a deserializovať reťazec JSON do objektov Java.

Ak sa chcete dozvedieť viac o Jacksonovej knižnici všeobecne, Jacksonův výukový program je dobrým miestom, kde začať.

2. Závislosti

Najprv pridajme nasledujúce závislosti do pom.xml:

 com.fasterxml.jackson.core jackson-databind 2.11.1 

Táto závislosť tiež prechodne pridá do knižnice nasledujúce knižnice:

  1. anotácie jackson
  2. jackson-core

Vždy používajte najnovšie verzie z centrálneho úložiska Maven pre jackson-databind.

3. Čítanie a písanie pomocou ObjectMapper

Začnime základnými operáciami čítania a zápisu.

Jednoduché readValue API ObjectMapper je dobrým vstupným bodom. Môžeme ho použiť na analýzu alebo deserializáciu obsahu JSON na objekt Java.

Po stránke písania tiež môžeme použiť writeValue API na serializáciu ľubovoľného objektu Java ako výstupu JSON.

Použijeme nasledujúce Auto trieda s dvoma poľami ako objektom na serializáciu alebo deserializáciu v tomto článku:

public class Car {private String color; súkromný typ reťazca; // nastavovatelia štandardných getrov}

3.1. Objekt Java do formátu JSON

Pozrime sa na prvý príklad serializácie objektu Java do formátu JSON pomocou writeValue metóda ObjectMapper trieda:

ObjectMapper objectMapper = nový ObjectMapper (); Auto = nové auto („žltá“, „renault“); objectMapper.writeValue (nový súbor ("target / car.json"), auto); 

Výstup z vyššie uvedeného v súbore bude:

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

Metódy writeValueAsString a writeValueAsBytes z ObjectMapper trieda vygeneruje JSON z objektu Java a vráti vygenerovaný JSON ako reťazec alebo ako bajtové pole:

Reťazec carAsString = objectMapper.writeValueAsString (auto); 

3.2. Objekt JSON do Java

Ďalej je uvedený jednoduchý príklad prevodu reťazca JSON na objekt Java pomocou nástroja ObjectMapper trieda:

Reťazec json = "{\" farba \ ": \" Čierna \ ", \" typ \ ": \" BMW \ "}"; Car car = objectMapper.readValue (json, Car.class); 

The readValue () funkcia akceptuje aj iné formy vstupu, napríklad súbor obsahujúci reťazec JSON:

Car car = objectMapper.readValue (nový súbor ("src / test / resources / json_car.json"), Car.class);

alebo URL:

Car car = objectMapper.readValue (nová URL ("súbor: src / test / resources / json_car.json"), Car.class);

3.3. JSON Jacksonovi JsonNode

Alternatívne je možné JSON analyzovať na a JsonNode objekt a slúži na načítanie údajov z konkrétneho uzla:

Reťazec json = "{\" color \ ": \" Čierny \ ", \" typ \ ": \" FIAT \ "}"; JsonNode jsonNode = objectMapper.readTree (json); String color = jsonNode.get ("color"). AsText (); // Výstup: farba -> čierna 

3.4. Vytvorenie zoznamu Java z reťazca JSON Array

Môžeme analyzovať JSON vo forme poľa do zoznamu objektov Java pomocou a TypeReference:

Reťazec jsonCarArray = "[{\" color \ ": \" Black \ ", \" type \ ": \" BMW \ "}, {\" color \ ": \" Red \ ", \" type \ ": \ "FIAT \"}] "; Zoznam listCar = objectMapper.readValue (jsonCarArray, nový TypeReference(){}); 

3.5. Vytváranie mapy Java z reťazca JSON

Podobne môžeme analyzovať JSON na Java Mapa:

Reťazec json = "{\" farba \ ": \" Čierna \ ", \" typ \ ": \" BMW \ "}"; Mapa map = objectMapper.readValue (json, nový TypeReference(){}); 

4. Pokročilé funkcie

Jednou z najväčších silných stránok Jacksonovej knižnice je vysoko prispôsobiteľný proces serializácie a deserializácie.

V tejto časti si prejdeme niektoré pokročilé funkcie, kde sa vstupná alebo výstupná odpoveď JSON môžu líšiť od objektu, ktorý generuje alebo spotrebováva odpoveď.

4.1. Konfigurácia funkcie serializácie alebo deserializácie

Počas prevodu objektov JSON na triedy Java bude mať predvolený proces v prípade, že má reťazec JSON nejaké nové polia, výnimku:

Reťazec jsonString = "{\" farba \ ": \" Čierna \ ", \" typ \ ": \" Fiat \ ", \" rok \ ": \" 1970 \ "}"; 

Reťazec JSON vo vyššie uvedenom príklade v predvolenom procese syntaktickej analýzy na objekt Java pre objekt Trieda auta bude mať za následok UnrecognizedPropertyException výnimkou.

Cez konfigurovať metódou môžeme rozšíriť predvolený proces tak, aby ignoroval nové polia:

objectMapper.configure (DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); Car car = objectMapper.readValue (jsonString, Car.class); JsonNode jsonNodeRoot = objectMapper.readTree (jsonString); JsonNode jsonNodeYear = jsonNodeRoot.get ("rok"); Reťazec rok = jsonNodeYear.asText (); 

Ďalšia možnosť je založená na FAIL_ON_NULL_FOR_PRIMITIVES, ktorá definuje, či nulový hodnoty pre primitívne hodnoty sú povolené:

objectMapper.configure (DeserializationFeature.FAIL_ON_NULL_FOR_PRIMITIVES, false); 

Podobne FAIL_ON_NUMBERS_FOR_ENUM ovláda, či je možné hodnoty enum serializovať / deserializovať ako čísla:

objectMapper.configure (DeserializationFeature.FAIL_ON_NUMBERS_FOR_ENUMS, false);

Komplexný zoznam funkcií serializácie a deserializácie nájdete na oficiálnych stránkach.

4.2. Vytváranie vlastného serializátora alebo deserializátora

Ďalšou podstatnou vlastnosťou ObjectMapper triedy je schopnosť zaregistrovať vlastný serializátor a deserializátor.

Vlastné serializátory a deserializátory sú veľmi užitočné v situáciách, keď sa vstupná alebo výstupná odpoveď JSON líši štruktúrou od triedy Java, do ktorej sa musí serializovať alebo deserializovať.

Nižšie je uvedený príklad vlastného serializátora JSON:

public class CustomCarSerializer rozširuje StdSerializer {public CustomCarSerializer () {this (null); } public CustomCarSerializer (trieda t) {super (t); } @Override public void serialize (Auto, JsonGenerator jsonGenerator, SerializerProvider serializer) {jsonGenerator.writeStartObject (); jsonGenerator.writeStringField ("car_brand", car.getType ()); jsonGenerator.writeEndObject (); }} 

Tento vlastný serializátor sa dá vyvolať takto:

ObjectMapper mapovač = nový ObjectMapper (); Modul SimpleModule = nový SimpleModule ("CustomCarSerializer", nová verzia (1, 0, 0, null, null, null)); module.addSerializer (Car.class, nový CustomCarSerializer ()); mapper.registerModule (modul); Auto = nové auto („žltá“, „renault“); Reťazec carJson = mapper.writeValueAsString (auto); 

Tu je to, čo Auto vyzerá ako (ako výstup JSON) na strane klienta:

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

A tu je príklad vlastný deserializátor JSON:

public class CustomCarDeserializer rozširuje StdDeserializer {public CustomCarDeserializer () {this (null); } public CustomCarDeserializer (Class vc) {super (vc); } @Override public Car deserialize (JsonParser parser, DeserializationContext deserializer) {Car car = new Car (); Kodek ObjectCodec = parser.getCodec (); Uzol JsonNode = codec.readTree (analyzátor); // skúsiť chytiť blok JsonNode colorNode = node.get ("color"); Farba reťazca = colorNode.asText (); car.setColor (farba); spiatočné auto; }} 

Tento vlastný deserializátor je možné vyvolať týmto spôsobom:

Reťazec json = "{\" farba \ ": \" Čierna \ ", \" typ \ ": \" BMW \ "}"; ObjectMapper mapovač = nový ObjectMapper (); Modul SimpleModule = nový SimpleModule ("CustomCarDeserializer", nová verzia (1, 0, 0, null, null, null)); module.addDeserializer (Car.class, nový CustomCarDeserializer ()); mapper.registerModule (modul); Car car = mapper.readValue (json, Car.class); 

4.3. Nakladanie s formátmi dátumu

Predvolená serializácia java.util.Date vytvorí číslo, t. j. epochová časová značka (počet milisekúnd od 1. januára 1970, UTC). Ale to nie je veľmi dobre čitateľné človekom a vyžaduje si ďalšiu konverziu, aby sa zobrazila v ľudsky čitateľnom formáte.

Zabalíme Auto inštanciu, ktorú sme doteraz používali vo vnútri Žiadosť trieda s dátum nákupu nehnuteľnosť:

public class Request {private Car car; súkromné ​​Dátum a dátumKúpené; // nastavovatelia štandardných getrov} 

Ovládanie reťazcového formátu dátumu a jeho nastavenie napr. rrrr-MM-dd HH: mm a z, zvážte nasledujúci úryvok:

ObjectMapper objectMapper = nový ObjectMapper (); DateFormat df = nový SimpleDateFormat ("rrrr-MM-dd HH: mm a z"); objectMapper.setDateFormat (df); Reťazec carAsString = objectMapper.writeValueAsString (požiadavka); // output: {"car": {"color": "yellow", "type": "renault"}, "datePurchased": "2016-07-03 11:43 CEST"} 

Ak sa chcete dozvedieť viac informácií o serializácii dátumov pomocou Jacksona, prečítajte si náš podrobnejší zápis.

4.4. Manipulácia so zbierkami

Ďalšia malá, ale užitočná funkcia dostupná prostredníctvom servera Funkcia deserializácie class je schopnosť generovať požadovaný typ kolekcie z odpovede JSON Array.

Výsledok môžeme napríklad vygenerovať ako pole:

Reťazec jsonCarArray = "[{\" color \ ": \" Black \ ", \" type \ ": \" BMW \ "}, {\" color \ ": \" Red \ ", \" type \ ": \ "FIAT \"}] "; ObjectMapper objectMapper = nový ObjectMapper (); objectMapper.configure (DeserializationFeature.USE_JAVA_ARRAY_FOR_JSON_ARRAY, true); Car [] cars = objectMapper.readValue (jsonCarArray, Car []. Class); // tlač automobilov

Alebo ako Zoznam:

Reťazec jsonCarArray = "[{\" farba \ ": \" Čierna \ ", \" typ \ ": \" BMW \ "}, {\" farba \ ": \" Červená \ ", \" typ \ ": \ "FIAT \"}] "; ObjectMapper objectMapper = nový ObjectMapper (); Zoznam listCar = objectMapper.readValue (jsonCarArray, nový TypeReference() {}); // tlač automobilov

Viac informácií o spracovávaní zbierok s Jacksonom je k dispozícii tu.

5. Záver

Jackson je pevná a vyspelá knižnica serializácie / deserializácie JSON pre Javu. The ObjectMapper API poskytuje priamy spôsob analýzy a generovania objektov odpovedí JSON s veľkou flexibilitou. Tento článok pojednáva o hlavných funkciách, vďaka ktorým je knižnica taká populárna.

Zdrojový kód, ktorý je priložený k článku, nájdete na GitHub.