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.
