Primjeri Jacksonovih bilješki

1. Pregled

U ovom uputstvu duboko ćemo zaroniti u Jackson Bilješke.

Vidjet ćemo kako koristiti postojeće napomene, kako stvoriti prilagođene i na kraju kako ih onemogućiti.

2. Jackson-ove bilješke o serializaciji

Prvo ćemo pogledati napomene o serializaciji.

2.1. @JsonAnyGetter

The @JsonAnyGetter napomena omogućuje fleksibilnost korištenja a Karta polje kao standardna svojstva.

Na primjer, ExtendableBean entitet ima Ime svojstvo i skup proširivih atributa u obliku parova ključ / vrijednost:

javni razred ExtendableBean {naziv javnog niza; privatna svojstva karte; @JsonAnyGetter javna karta getProperties () {return svojstva; }}

Kada serializiramo instancu ovog entiteta, dobivamo sve ključne vrijednosti u Karta kao standardna, obična svojstva:

{"name": "Moj grah", "attr2": "val2", "attr1": "val1"}

Evo kako u praksi izgleda serializacija ovog entiteta:

@Test public void whenSerializingUsingJsonAnyGetter_thenCorrect () baca JsonProcessingException {ExtendableBean bean = new ExtendableBean ("My bean"); bean.add ("attr1", "val1"); bean.add ("attr2", "val2"); Rezultat niza = novi ObjectMapper (). WriteValueAsString (grah); assertThat (rezultat, sadržiString ("attr1")); assertThat (rezultat, sadržiString ("val1")); }

Možemo se poslužiti i neobaveznim argumentom omogućeno kao lažno onemogućiti @JsonAnyGetter (). U ovom slučaju, Karta pretvorit će se u JSON i pojavit će se pod Svojstva varijabla nakon serializacije.

2.2. @JsonGetter

The @JsonGetter napomena je alternativa @JsonProperty napomena koja označava metodu kao gettersku metodu.

U sljedećem primjeru navodimo metodu getTheName () kao getter metoda Ime svojstvo a MyBean entitet:

javna klasa MyBean {javni int id; privatni naziv niza; @JsonGetter ("name") javni niz getTheName () {return ime; }}

Evo kako ovo funkcionira u praksi:

@Test public void whenSerializingUsingJsonGetter_thenCorrect () baca JsonProcessingException {MyBean bean = new MyBean (1, "My bean"); Rezultat niza = novi ObjectMapper (). WriteValueAsString (grah); assertThat (rezultat, sadržiString ("Moj grah")); assertThat (rezultat, sadržiString ("1")); }

2.3. @JsonPropertyOrder

Možemo koristiti @JsonPropertyOrder napomena za specificiranje red svojstava na serializaciji.

Postavimo prilagođeni redoslijed svojstava a MyBean entitet:

@JsonPropertyOrder ({"name", "id"}) javna klasa MyBean {public int id; naziv javnog niza; }

Evo rezultata serializacije:

{"name": "Moj grah", "id": 1}

Tada možemo napraviti jednostavan test:

@Test public void whenSerializingUsingJsonPropertyOrder_thenCorrect () baca JsonProcessingException {MyBean bean = new MyBean (1, "My bean"); Rezultat niza = novi ObjectMapper (). WriteValueAsString (grah); assertThat (rezultat, sadržiString ("Moj grah")); assertThat (rezultat, sadržiString ("1")); }

Možemo i koristiti @JsonPropertyOrder (abecedno = točno) da biste svojstva poredali po abecedi. U tom će slučaju rezultat serializacije biti:

{"id": 1, "name": "Moj grah"}

2.4. @JsonRawValue

The @JsonRawValue anotacija može uputiti Jacksona da serializira vlasništvo točno onakvo kakvo jest.

U sljedećem primjeru koristimo @JsonRawValue za ugrađivanje nekog prilagođenog JSON-a kao vrijednosti entiteta:

javna klasa RawBean {naziv javnog niza; @JsonRawValue javni niz json; }

Rezultat serializacije entiteta je:

{"name": "Moj grah", "json": {"attr": false}}

Slijedi jednostavan test:

@Test public void whenSerializingUsingJsonRawValue_thenCorrect () baca JsonProcessingException {RawBean bean = new RawBean ("My bean", "{\" attr \ ": false}"); Rezultat niza = novi ObjectMapper (). WriteValueAsString (grah); assertThat (rezultat, sadržiString ("Moj grah")); assertThat (rezultat, sadržiString ("{\" attr \ ": false}")); }

Također se možemo poslužiti neobaveznim logičkim argumentom vrijednost koji definira je li ova napomena aktivna ili ne.

2.5. @JsonValue

@JsonValue označava jednu metodu koju će knjižnica koristiti za serializaciju cijele instance.

Na primjer, u enumu bilježimo getName s @JsonValue tako da se bilo koji takav entitet serializira kroz njegovo ime:

javni nabraja TypeEnumWithValue {TIP1 (1, "Tip A"), TIP2 (2, "Tip 2"); privatni cijeli broj; privatni naziv niza; // standardni konstruktori @JsonValue public String getName () {return name; }}

Evo našeg testa:

@Test public void whenSerializingUsingJsonValue_thenCorrect () baca JsonParseException, IOException {String enumAsString = new ObjectMapper () .writeValueAsString (TypeEnumWithValue.TYPE1); assertThat (enumAsString, is ("" Tip A "")); }

2.6. @JsonRootName

The @JsonRootName napomena se koristi, ako je omotavanje omogućeno, za određivanje naziva korijenskog omota koji će se koristiti.

Omotavanje znači da umjesto serializacije a Korisnik na nešto poput:

{"id": 1, "name": "Ivan"}

Bit će zamotan ovako:

{"Korisnik": {"id": 1, "ime": "Ivan"}}

Pa pogledajmo primjer. Wkoristit ćemo @JsonRootName napomena za označavanje naziva ovog potencijalnog entiteta omota:

@JsonRootName (value = "user") javna klasa UserWithRoot {javni int id; naziv javnog niza; }

Prema zadanim postavkama, naziv omota bio bi naziv klase - UserWithRoot. Korištenjem bilješke dobivamo čistiji izgled korisnik:

@Test public void whenSerializingUsingJsonRootName_thenCorrect () baca JsonProcessingException {UserWithRoot user = novi korisnik (1, "John"); Mapa ObjectMapper = novi ObjectMapper (); mapper.enable (SerializationFeature.WRAP_ROOT_VALUE); Rezultat niza = mapper.writeValueAsString (korisnik); assertThat (rezultat, sadržiString ("Ivan")); assertThat (rezultat, sadržiString ("korisnik")); }

Evo rezultata serializacije:

{"user": {"id": 1, "name": "John"}}

Od Jacksona 2.4, novi neobavezni argument prostor imena dostupan je za upotrebu s formatima podataka kao što je XML. Ako ga dodamo, postat će dijelom potpuno kvalificiranog imena:

@JsonRootName (value = "user", namespace = "users") javna klasa UserWithRootNamespace {public int id; naziv javnog niza; // ...}

Ako ga serializiramo s XmlMapper, izlaz će biti:

 1. Ivana 

2.7. @JsonSerialize

@JsonSerialize označava prilagođeni serializator koji se koristi kada marširanje entitet.

Pogledajmo brzi primjer. Koristit ćemo @JsonSerialize za serializaciju datum događaja nekretnina s a CustomDateSerializer:

javna klasa EventWithSerializer {naziv javnog niza; @JsonSerialize (koristeći = CustomDateSerializer.class) javni datum eventDate; }

Evo jednostavnog prilagođenog Jacksonovog serializatora:

javna klasa CustomDateSerializer proširuje StdSerializer {privatni statički SimpleDateFormat formatter = novi SimpleDateFormat ("dd-MM-yyyy hh: mm: ss"); javni CustomDateSerializer () {this (null); } javni CustomDateSerializer (klasa t) {super (t); } @Override public void serialize (vrijednost datuma, JsonGenerator gen, SerializerProvider arg2) baca IOException, JsonProcessingException {gen.writeString (formatter.format (value)); }}

Sada upotrijebimo ovo u testu:

@Test public void whenSerializingUsingJsonSerialize_thenCorrect () baca JsonProcessingException, ParseException {SimpleDateFormat df = new SimpleDateFormat ("dd-MM-yyyy hh: mm: ss"); String toParse = "20-12-2014 02:30:00"; Datum datum = df.parse (toParse); EventWithSerializer događaj = novi EventWithSerializer ("stranka", datum); Rezultat niza = novi ObjectMapper (). WriteValueAsString (događaj); assertThat (rezultat, sadržiString (toParse)); }

3. Jackson Deserialization Bilješke

Dalje istražimo Jacksonove napomene o deserializaciji.

3.1. @JsonCreator

Možemo koristiti @JsonCreator napomena za podešavanje konstruktora / tvornice koja se koristi u deserializaciji.

Vrlo je korisno kada moramo deserializirati neki JSON koji se ne podudara točno s ciljnim entitetom koji trebamo dobiti.

Pogledajmo primjer. Recimo da moramo deserializirati sljedeći JSON:

{"id": 1, "theName": "Moj grah"}

Međutim, ne postoji Ime polje u našem ciljnom entitetu postoji samo Ime polje. Sada ne želimo mijenjati sam entitet, samo trebamo malo više kontrole nad postupkom uklanjanja oznaka dodavanjem bilješki u konstruktor s @JsonCreator, i koristeći @JsonProperty napomena također:

javna klasa BeanWithCreator {javni int id; naziv javnog niza; @JsonCreator javni BeanWithCreator (@JsonProperty ("id") int id, @JsonProperty ("theName") Ime niza) {this.id = id; this.name = ime; }}

Pogledajmo ovo na djelu:

@Test public void whenDeserializingUsingJsonCreator_thenCorrect () baca IOException {String json = "{\" id \ ": 1, \" theName \ ": \" My bean \ "}"; BeanWithCreator bean = new ObjectMapper () .readerFor (BeanWithCreator.class) .readValue (json); assertEquals ("Moj grah", bean.name); }

3.2. @JacksonInject

@JacksonInject označava da će svojstvo vrijednost dobiti iz injekcije, a ne iz JSON podataka.

U sljedećem primjeru koristimo @JacksonInject ubrizgati imovinu iskaznica:

javna klasa BeanWithInject {@JacksonInject javni int id; naziv javnog niza; }

Evo kako to funkcionira:

@Test public void whenDeserializingUsingJsonInject_thenCorrect () baca IOException {String json = "{\" name \ ": \" My bean \ "}"; InjectableValues ​​inject = new InjectableValues.Std () .addValue (int.class, 1); BeanWithInject bean = new ObjectMapper (). Čitač (ubrizgavanje) .forType (BeanWithInject.class) .readValue (json); assertEquals ("Moj grah", bean.name); assertEquals (1, bean.id); }

3.3. @JsonAnySetter

@JsonAnySetter omogućuje nam fleksibilnost korištenja a Karta kao standardna svojstva. Pri deserializaciji svojstva iz JSON-a jednostavno će se dodati na kartu.

Prvo ćemo upotrijebiti @JsonAnySetter za deserializaciju entiteta ExtendableBean:

javni razred ExtendableBean {naziv javnog niza; privatna svojstva karte; @JsonAnySetter public void add (String key, String value) {properties.put (key, value); }}

Ovo je JSON koji moramo deserializirati:

{"name": "Moj grah", "attr2": "val2", "attr1": "val1"}

Zatim evo kako se sve to povezuje:

@Test public void whenDeserializingUsingJsonAnySetter_thenCorrect () baca IOException {String json = "{\" name \ ": \" My bean \ ", \" attr2 \ ": \" val2 \ ", \" attr1 \ ": \" val1 \ "}"; ExtendableBean bean = novi ObjectMapper () .readerFor (ExtendableBean.class) .readValue (json); assertEquals ("Moj grah", bean.name); assertEquals ("val2", bean.getProperties (). get ("attr2")); }

3.4. @JsonSetter

@JsonSetter je alternativa @JsonProperty koja označava metodu kao metodu postavljanja.

To je nevjerojatno korisno kada moramo pročitati neke JSON podatke, ali klasa ciljnog entiteta ne odgovara točno tim podacima, i zato moramo prilagoditi postupak kako bi ga prilagodio.

U sljedećem ćemo primjeru odrediti metodu setTheName () kao postavljač Ime vlasništvo u našem MyBean entitet:

javna klasa MyBean {javni int id; privatni naziv niza; @JsonSetter ("name") javna praznina setTheName (ime niza) {this.name = name; }}

Sada kada moramo ukloniti neke JSON podatke, ovo savršeno funkcionira:

@Test public void whenDeserializingUsingJsonSetter_thenCorrect () baca IOException {String json = "{\" id \ ": 1, \" name \ ": \" My bean \ "}"; MyBean bean = novi ObjectMapper () .readerFor (MyBean.class) .readValue (json); assertEquals ("Moj grah", bean.getTheName ()); }

3.5. @JsonDeserialize

@JsonDeserialize označava upotrebu prilagođenog deserializatora.

Prvo ćemo upotrijebiti @JsonDeserialize da deserializira datum događaja vlasništvo s CustomDateDeserializer:

javna klasa EventWithSerializer {naziv javnog niza; @JsonDeserialize (koristeći = CustomDateDeserializer.class) javni datum eventDate; }

Evo prilagođenog deserijalizatora:

javna klasa CustomDateDeserializer proširuje StdDeserializer {private static SimpleDateFormat formatter = new SimpleDateFormat ("dd-MM-yyyy hh: mm: ss"); javni CustomDateDeserializer () {this (null); } javni CustomDateDeserializer (klasa vc) {super (vc); } @Override public Date deserialize (JsonParser jsonparser, DeserializationContext context) baca IOException {String date = jsonparser.getText (); pokušajte {return formatter.parse (datum); } catch (ParseException e) {throw new RuntimeException (e); }}}

Slijedi test back-to-back:

@Test public void whenDeserializingUsingJsonDeserialize_thenCorrect () baca IOException {String json = "{" name ":" party "," eventDate ":" 20-12-2014 02:30:00 "}"; SimpleDateFormat df = novi SimpleDateFormat ("dd-MM-yyyy hh: mm: ss"); EventWithSerializer događaj = novi ObjectMapper () .readerFor (EventWithSerializer.class) .readValue (json); assertEquals ("20-12-2014 02:30:00", df.format (event.eventDate)); }

3.6. @JsonAlias

The @JsonAlias definira jedan ili više alternativnih naziva svojstva tijekom deserializacije.

Pogledajmo kako ova napomena funkcionira na brzom primjeru:

javna klasa AliasBean {@JsonAlias ​​({"fName", "f_name"}) private String firstName; private String lastName; }

Ovdje imamo POJO i želimo deserializirati JSON s vrijednostima kao što su fName, ime_f, i ime u ime varijabla POJO.

Ispod je test kojim se osigurava da ova napomena funkcionira prema očekivanjima:

@Test public void whenDeserializingUsingJsonAlias_thenCorrect () baca IOException {String json = "{\" fName \ ": \" John \ ", \" lastName \ ": \" Green \ "}"; AliasBean aliasBean = novi ObjectMapper (). ReaderFor (AliasBean.class) .readValue (json); assertEquals ("Ivan", aliasBean.getFirstName ()); }

4. Bilješke o uključivanju imovine Jacksona

4.1. @JsonIgnoreProperties

@JsonIgnoreProperties je napomena na razini klase koja označava svojstvo ili popis svojstava koja će Jackson ignorirati.

Pogledajmo brzi primjer ignoriranja imovine iskaznica od serializacije:

@JsonIgnoreProperties ({"id"}) javna klasa BeanWithIgnore {javni int id; naziv javnog niza; }

Evo testa koji osigurava da se dogodi ignoriranje:

@Test public void whenSerializingUsingJsonIgnoreProperties_thenCorrect () baca JsonProcessingException {BeanWithIgnore bean = new BeanWithIgnore (1, "My bean"); Rezultat niza = novi ObjectMapper () .writeValueAsString (grah); assertThat (rezultat, sadržiString ("Moj grah")); assertThat (rezultat, ne (sadržiString ("id"))); }

Da zanemarimo bilo koja nepoznata svojstva u JSON ulazu bez iznimke, možemo postaviti ignoreUnknown = true od @JsonIgnoreProperties bilješka.

4.2. @JsonIgnore

Suprotno tome, @JsonIgnore napomena se koristi za označavanje svojstva koje će se zanemariti na razini polja.

Iskoristimo @JsonIgnore zanemariti svojstvo iskaznica od serializacije:

javna klasa BeanWithIgnore {@JsonIgnore public int id; naziv javnog niza; }

Zatim ćemo testirati kako bismo se uvjerili iskaznica je uspješno zanemaren:

@Test public void whenSerializingUsingJsonIgnore_thenCorrect () baca JsonProcessingException {BeanWithIgnore bean = new BeanWithIgnore (1, "My bean"); Rezultat niza = novi ObjectMapper () .writeValueAsString (grah); assertThat (rezultat, sadržiString ("Moj grah")); assertThat (rezultat, ne (sadržiString ("id"))); }

4.3. @JsonIgnoreType

@JsonIgnoreType označava sva svojstva označenog tipa koja će se zanemariti.

Bilješkom možemo označiti sva svojstva tipa Ime zanemariti:

javni razred korisnika {javni int id; javno Ime; @JsonIgnoreType javna statička klasa Ime {public String firstName; javni String lastName; }}

Također možemo testirati kako bi osigurali da ignoriranje radi ispravno:

@Test public void whenSerializingUsingJsonIgnoreType_thenCorrect () baca JsonProcessingException, ParseException {User.Name name = new User.Name ("John", "Doe"); Korisnik korisnik = novi korisnik (1, ime); Rezultat niza = novi ObjectMapper () .writeValueAsString (korisnik); assertThat (rezultat, sadržiString ("1")); assertThat (rezultat, ne (sadržiString ("ime"))); assertThat (rezultat, ne (sadržiString ("Ivan"))); }

4.4. @JsonInclude

Možemo koristiti @JsonInclude za izuzeće svojstava s praznim / null / default vrijednostima.

Pogledajmo primjer koji isključuje nule iz serializacije:

@JsonInclude (Include.NON_NULL) javna klasa MyBean {public int id; naziv javnog niza; }

Evo cjelovitog testa:

javna praznina whenSerializingUsingJsonInclude_thenCorrect () baca JsonProcessingException {MyBean bean = new MyBean (1, null); Rezultat niza = novi ObjectMapper () .writeValueAsString (grah); assertThat (rezultat, sadržiString ("1")); assertThat (rezultat, ne (sadržiString ("ime"))); }

4.5. @JsonAutoDetect

@JsonAutoDetect može nadjačati zadanu semantiku koja su svojstva vidljiva, a koja ne.

Prvo, pogledajmo kako napomena može biti od velike pomoći na jednostavnom primjeru; omogućimo serializiranje privatnih svojstava:

@JsonAutoDetect (fieldVisibility = Visibility.ANY) javna klasa PrivateBean {private int id; privatni naziv niza; }

Zatim test:

@Test public void whenSerializingUsingJsonAutoDetect_thenCorrect () baca JsonProcessingException {PrivateBean bean = new PrivateBean (1, "My bean"); Rezultat niza = novi ObjectMapper () .writeValueAsString (grah); assertThat (rezultat, sadržiString ("1")); assertThat (rezultat, sadržiString ("Moj grah")); }

5. Bilješke o rukovanju polimorfnim tipom Jacksona

Dalje, pogledajmo napomene o rukovanju polimorfnim tipom Jacksona:

  • @JsonTypeInfo - ukazuje na detalje o vrsti podataka koje treba uključiti u serializaciju
  • @JsonSubTypes - označava podvrste označenog tipa
  • @JsonTypeName - definira naziv logičkog tipa koji će se koristiti za označenu klasu

Ispitajmo složeniji primjer i upotrijebimo sva tri - @JsonTypeInfo, @JsonSubTypes, i @JsonTypeName - za serializaciju / deserializaciju entiteta Zoološki vrt:

javni razred Zoo {javna Životinjska životinja; @JsonTypeInfo (use = JsonTypeInfo.Id.NAME, include = As.PROPERTY, property = "type") @JsonSubTypes ({@ JsonSubTypes.Type (value = Dog.class, name = "dog"), @ JsonSubTypes.Type ( value = Cat.class, name = "cat")}) javna statička klasa Animal {public String name; } @JsonTypeName ("pas") javna statička klasa Pas proširuje Animal {public double barkVolume; } @JsonTypeName ("mačka") javna statička klasa Mačka proširuje Animal {boolean likesCream; javni int životi; }}

Kada radimo serializaciju:

@Test public void whenSerializingPolymorphic_thenCorrect () baca JsonProcessingException {Zoo.Dog dog = new Zoo.Dog ("lacy"); Zoološki vrt = novi Zoološki vrt (pas); Rezultat niza = novi ObjectMapper () .writeValueAsString (zoološki vrt); assertThat (rezultat, sadržiString ("tip")); assertThat (rezultat, sadržiString ("pas")); }

Evo što serializiranje Zoološki vrt primjer s Pas rezultirat će:

{"animal": {"type": "dog", "name": "lacy", "barkVolume": 0}}

Sada za de-serializaciju. Počnimo sa sljedećim JSON ulazom:

{"životinja": {"ime": "čipkasto", "tip": "mačka"}}

Onda da vidimo kako će to biti bez premca Zoološki vrt primjer:

@Test public void whenDeserializingPolymorphic_thenCorrect () baca IOException {String json = "{\" animal \ ": {\" name \ ": \" lacy \ ", \" type \ ": \" cat \ "}}"; Zoološki vrt zoo = novi ObjectMapper () .readerFor (Zoo.class) .readValue (json); assertEquals ("čipkasti", zoo.životinja.ime); assertEquals (Zoo.Cat.class, zoo.animal.getClass ()); }

6. Opće bilješke Jacksona

Dalje razgovarajmo o nekim Jacksonovim općenitijim bilješkama.

6.1. @JsonProperty

Možemo dodati the @JsonProperty napomena za označavanje naziva svojstva u JSON-u.

Iskoristimo @JsonProperty za serializaciju / deserializaciju imovine Ime kada imamo posla s nestandardnim geterima i postavljačima:

javna klasa MyBean {javni int id; privatni naziv niza; @JsonProperty ("name") javna praznina setTheName (ime niza) {this.name = name; } @JsonProperty ("name") javni niz getTheName () {return name; }}

Slijedi naš test:

@Test public void whenUsingJsonProperty_thenCorrect () baca IOException {MyBean bean = new MyBean (1, "My bean"); Rezultat niza = novi ObjectMapper (). WriteValueAsString (grah); assertThat (rezultat, sadržiString ("Moj grah")); assertThat (rezultat, sadržiString ("1")); MyBean resultBean = novi ObjectMapper () .readerFor (MyBean.class) .readValue (rezultat); assertEquals ("Moj grah", resultBean.getTheName ()); }

6.2. @JsonFormat

The @JsonFormat napomena navodi format prilikom serializacije vrijednosti Datum / Vrijeme.

U sljedećem primjeru koristimo @JsonFormat za kontrolu formata svojstva datum događaja:

javna klasa EventWithFormat {naziv javnog niza; @JsonFormat (shape = JsonFormat.Shape.STRING, pattern = "dd-MM-yyyy hh: mm: ss") javni datum eventDate; }

Eto testa:

@Test public void whenSerializingUsingJsonFormat_thenCorrect () baca JsonProcessingException, ParseException {SimpleDateFormat df = new SimpleDateFormat ("dd-MM-yyyy hh: mm: ss"); df.setTimeZone (TimeZone.getTimeZone ("UTC")); String toParse = "20-12-2014 02:30:00"; Datum datum = df.parse (toParse); EventWithFormat događaj = novi EventWithFormat ("stranka", datum); Rezultat niza = novi ObjectMapper (). WriteValueAsString (događaj); assertThat (rezultat, sadržiString (toParse)); }

6.3. @JsonUnwrapped

@JsonUnwrapped definira vrijednosti koje bi se trebale raspakirati / poravnati kada se serijaliziraju / deserializiraju.

Pogledajmo točno kako ovo funkcionira; upotrijebit ćemo bilješku za odmotavanje svojstva Ime:

javna klasa UnwrappedUser {public int id; @JsonUnwrapped javno ime; javna statička klasa Name {public String firstName; javni String lastName; }}

Ajmo sada serializirati primjerak ove klase:

@Test public void whenSerializingUsingJsonUnwrapped_thenCorrect () baca JsonProcessingException, ParseException {UnwrappedUser.Name name = new UnwrappedUser.Name ("John", "Doe"); UnwrappedUser user = novi UnwrappedUser (1, ime); Rezultat niza = novi ObjectMapper (). WriteValueAsString (korisnik); assertThat (rezultat, sadržiString ("Ivan")); assertThat (rezultat, ne (sadržiString ("ime"))); }

Konačno, evo kako izgleda izlaz - polja statičke ugniježđene klase odmotana zajedno s drugim poljem:

{"id": 1, "firstName": "John", "lastName": "Srna"}

6.4. @JsonView

@JsonView označava prikaz u kojem će se svojstvo uključiti u serializaciju / deserializaciju.

Na primjer, koristit ćemo @JsonView za serializiranje instance Artikal entitet.

Prvo, krenimo od pogleda:

prikazi javne klase {public static class Public {} public static class Internal extends Public {}}

Sljedeća je Artikal entitet koji koristi poglede:

stavka javne klase {@JsonView (Views.Public.class) public int id; @JsonView (Views.Public.class) javni String itemName; @JsonView (Views.Internal.class) javni String ownerName; }

Na kraju, puni test:

@Test public void whenSerializingUsingJsonView_thenCorrect () baca JsonProcessingException {Item item = new Item (2, "book", "John"); Rezultat niza = novi ObjectMapper () .writerWithView (Views.Public.class) .writeValueAsString (stavka); assertThat (rezultat, sadržiString ("knjiga")); assertThat (rezultat, sadržiString ("2")); assertThat (rezultat, ne (sadržiString ("Ivan"))); }

6.5. @JsonManagedReference, @JsonBackReference

The @JsonManagedReference i @JsonBackReference napomene se mogu nositi s odnosima roditelja i djeteta i radite oko petlji.

U sljedećem primjeru koristimo @JsonManagedReference i @JsonBackReference da seriziramo naš ItemWithRef entitet:

javna klasa ItemWithRef {javni int id; public String itemName; @JsonManagedReference javni korisnik UserWithRef; }

Naše UserWithRef entitet:

javna klasa UserWithRef {javni int id; naziv javnog niza; @JsonBackReference javni popis userItems; }

Zatim test:

@Test public void whenSerializingUsingJacksonReferenceAnnotation_thenCorrect () baca JsonProcessingException {UserWithRef user = new UserWithRef (1, "John"); ItemWithRef item = novi ItemWithRef (2, "knjiga", korisnik); user.addItem (stavka); Rezultat niza = novi ObjectMapper (). WriteValueAsString (stavka); assertThat (rezultat, sadržiString ("knjiga")); assertThat (rezultat, sadržiString ("Ivan")); assertThat (rezultat, ne (sadržiString ("userItems"))); }

6.6. @JsonIdentityInfo

@JsonIdentityInfo ukazuje na to da bi se identitet objekta trebao koristiti prilikom serializiranja / deserializiranja vrijednosti, na primjer, kada se rješavaju problemi s beskonačnom rekurzijom.

U sljedećem primjeru imamo ItemWithIdentity subjekt u dvosmjernom odnosu s UserWithIdentity entitet:

@JsonIdentityInfo (generator = ObjectIdGenerators.PropertyGenerator.class, property = "id") javna klasa ItemWithIdentity {javni int id; public String itemName; javni korisnik UserWithIdentity; }

The UserWithIdentity entitet:

@JsonIdentityInfo (generator = ObjectIdGenerators.PropertyGenerator.class, property = "id") javna klasa UserWithIdentity {javni int id; naziv javnog niza; javni popis userItems; }

Sada da vidimo kako se rješava problem beskonačne rekurzije:

@Test public void whenSerializingUsingJsonIdentityInfo_thenCorrect () baca JsonProcessingException {UserWithIdentity user = new UserWithIdentity (1, "John"); ItemWithIdentity item = novi ItemWithIdentity (2, "knjiga", korisnik); user.addItem (stavka); Rezultat niza = novi ObjectMapper (). WriteValueAsString (stavka); assertThat (rezultat, sadržiString ("knjiga")); assertThat (rezultat, sadržiString ("Ivan")); assertThat (rezultat, sadržiString ("userItems")); }

Evo punih rezultata serializirane stavke i korisnika:

{"id": 2, "itemName": "book", "owner": {"id": 1, "name": "John", "userItems": [2]}}

6.7. @JsonFilter

The @JsonFilter napomena navodi filtar koji će se koristiti tijekom serializacije.

Prvo definiramo entitet i ukazujemo na filtar:

@JsonFilter ("myFilter") javna klasa BeanWithFilter {public int id; naziv javnog niza; }

Sada u cjelovitom testu definiramo filtar koji isključuje sva ostala svojstva osim Ime od serializacije:

@Test public void whenSerializingUsingJsonFilter_thenCorrect () baca JsonProcessingException {BeanWithFilter bean = new BeanWithFilter (1, "My bean"); FilterProvider filtri = novi SimpleFilterProvider (). AddFilter ("myFilter", SimpleBeanPropertyFilter.filterOutAllExcept ("name")); Rezultat niza = novi ObjectMapper () .writer (filtri) .writeValueAsString (bean); assertThat (rezultat, sadržiString ("Moj grah")); assertThat (rezultat, ne (sadržiString ("id"))); }

7. Prilagođena Jacksonova bilješka

Dalje, pogledajmo kako stvoriti prilagođenu Jacksonovu napomenu. Možemo se poslužiti @JacksonAnnotationsInside napomena:

@Retention (RetentionPolicy.RUNTIME) @JacksonAnnotationsInside @JsonInclude (Include.NON_NULL) @JsonPropertyOrder ({"name", "id", "dateCreated"}) public @interface CustomAnnotation {}

Sada, ako novu bilješku koristimo na entitetu:

@CustomAnnotation javna klasa BeanWithCustomAnnotation {public int id; naziv javnog niza; javni Datum Datum Stvoren; }

Možemo vidjeti kako kombinira postojeće bilješke u jednostavnu prilagođenu koju možemo koristiti kao skraćenicu:

@Test public void whenSerializingUsingCustomAnnotation_thenCorrect () baca JsonProcessingException {BeanWithCustomAnnotation bean = new BeanWithCustomAnnotation (1, "My bean", null); Rezultat niza = novi ObjectMapper (). WriteValueAsString (grah); assertThat (rezultat, sadržiString ("Moj grah")); assertThat (rezultat, sadržiString ("1")); assertThat (rezultat, ne (sadržiString ("dateCreate"))); }

Rezultat postupka serializacije:

{"name": "Moj grah", "id": 1}

8. Jackson MixIn Bilješke

Dalje, pogledajmo kako koristiti napomene Jackson MixIn.

Na primjer, upotrijebimo napomene MixIn da zanemarimo svojstva tipa Korisnik:

predmet javne klase {public int id; public String itemName; javni korisnik; }
@JsonIgnoreType javna klasa MyMixInForIgnoreType {}

Onda da vidimo ovo na djelu:

@Test public void whenSerializingUsingMixInAnnotation_thenCorrect () baca JsonProcessingException {Item item = new Item (1, "book", null); Rezultat niza = novi ObjectMapper (). WriteValueAsString (stavka); assertThat (rezultat, sadržiString ("vlasnik")); Mapa ObjectMapper = novi ObjectMapper (); mapper.addMixIn (User.class, MyMixInForIgnoreType.class); rezultat = mapper.writeValueAsString (stavka); assertThat (rezultat, ne (sadržiString ("vlasnik"))); }

9. Onemogućite Jacksonovu napomenu

Napokon, da vidimo kako možemo onemogućiti sve Jacksonove bilješke. To možemo učiniti onemogućavanjem MapperFeature.USE_ANNOTATIONS kao u sljedećem primjeru:

@JsonInclude (Include.NON_NULL) @JsonPropertyOrder ({"name", "id"}) javna klasa MyBean {public int id; naziv javnog niza; }

Nakon onemogućavanja napomena, one ne bi trebale imati učinka i trebale bi se primijeniti zadane postavke knjižnice:

@Test public void whenDisablingAllAnnotations_thenAllDisabled () baca IOException {MyBean bean = new MyBean (1, null); Mapa ObjectMapper = novi ObjectMapper (); mapper.disable (MapperFeature.USE_ANNOTATIONS); Rezultat niza = mapper.writeValueAsString (grah); assertThat (rezultat, sadržiString ("1")); assertThat (rezultat, sadržiString ("ime")); }

Rezultat serializacije prije onemogućavanja napomena:

{"id": 1}

Rezultat serializacije nakon onemogućavanja napomena:

{"id": 1, "name": null}

10. Zaključak

U ovom smo članku pregledali Jacksonove bilješke, samo grebući površinu fleksibilnosti koju možemo dobiti pravilnom njihovom upotrebom.

Provedbu svih ovih primjera i isječaka koda možete pronaći na GitHubu.