Jackson Annotation Példák

1. Áttekintés

Ebben az oktatóanyagban mélyen elmélyülünk Jackson Annotations.

Meglátjuk, hogyan kell használni a meglévő kommentárokat, hogyan hozhatunk létre egyedi és végül hogyan tilthatjuk le azokat.

2. Jackson szerializációs kommentárok

Először megnézzük a szerializációs kommentárokat.

2.1. @JsonAnyGetter

A @JsonAnyGetter az annotáció lehetővé teszi az a használatának rugalmasságát Térkép mező standard tulajdonságokként.

Például a ExtendableBean entitás rendelkezik a név tulajdonság és kibővíthető attribútumok halmaza kulcs / érték párok formájában:

public class ExtendableBean {public String name; saját térképi ingatlanok; @JsonAnyGetter nyilvános térkép getProperties () {return tulajdonságok; }}

Amikor ennek az entitásnak egy példányát sorosítjuk, akkor az összes kulcsértéket megkapjuk Térkép alapfelszereltség, sima tulajdonságok:

{"name": "Saját babom", "attr2": "val2", "attr1": "val1"}

Így néz ki az entitás sorosítása a gyakorlatban:

@Test public void whenSerializingUsingJsonAnyGetter_thenCorrect () dobja a JsonProcessingException {ExtendableBean bean = new ExtendableBean ("Saját babom"); bab.add ("attr1", "val1"); bab.add ("attr2", "val2"); Karakterlánc eredménye = új ObjectMapper (). WriteValueAsString (bab); assertThat (eredmény, tartalmazzaString ("attr1")); assertThat (eredmény, tartalmazzaString ("val1")); }

Használhatjuk az opcionális argumentumot is engedélyezve mint hamis letiltani @JsonAnyGetter (). Ebben az esetben a Térkép konvertálódik JSON néven, és a tulajdonságait változó a szerializálás után.

2.2. @JsonGetter

A @JsonGetter az annotáció a @JsonProperty annotáció, amely egy metódust getter metódusként jelöl meg.

A következő példában meghatározzuk a módszert getTheName () mint a getter módszer név tulajdonsága a MyBean entitás:

nyilvános osztály MyBean {public int id; privát karakterlánc neve; @JsonGetter ("név") public String getTheName () {return name; }}

Így működik ez a gyakorlatban:

@Test public void whenSerializingUsingJsonGetter_thenCorrect () dobja a JsonProcessingException {MyBean bab = új MyBean (1, "Saját bab"); Karakterlánc eredménye = új ObjectMapper (). WriteValueAsString (bab); assertThat (eredmény, tartalmazzaString ("Saját babom")); assertThat (eredmény, tartalmazzaString ("1")); }

2.3. @JsonPropertyOrder

Használhatjuk a @JsonPropertyOrder megjegyzés a megadáshoz a tulajdonságok sorrendje a sorozatosításkor.

Állítsunk be egyedi sorrendet az a tulajdonságaihoz MyBean entitás:

@JsonPropertyOrder ({"név", "id"}) nyilvános osztály MyBean {public int id; public String név; }

Itt van a sorosítás eredménye:

{"name": "Saját babom", "id": 1}

Ezután elvégezhetünk egy egyszerű tesztet:

@Test public void whenSerializingUsingJsonPropertyOrder_thenCorrect () dobja a JsonProcessingException {MyBean bab = új MyBean (1, "Saját bab"); Karakterlánc eredménye = új ObjectMapper (). WriteValueAsString (bab); assertThat (eredmény, tartalmazzaString ("Saját babom")); assertThat (eredmény, tartalmazzaString ("1")); }

Használhatjuk is @JsonPropertyOrder (ábécé = igaz) a tulajdonságok betűrendbe rendezéséhez. Ebben az esetben a sorosítás kimenete a következő lesz:

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

2.4. @JsonRawValue

A @JsonRawValue annotáció lehet utasítsa Jackson-t, hogy egy tulajdonságot sorosítson pontosan úgy, ahogy van.

A következő példában azt használjuk @JsonRawValue néhány egyedi JSON beágyazása entitás értékeként:

RawBean nyilvános osztály {public String name; @JsonRawValue public String json; }

Az entitás sorosításának kimenete:

{"name": "Babom", "json": {"attr": hamis}}

Ezután itt van egy egyszerű teszt:

@Test public void whenSerializingUsingJsonRawValue_thenCorrect () dobja a JsonProcessingException {RawBean bab = új RawBean ("Saját bab", "{\" attr \ ": hamis}"); Karakterlánc eredménye = új ObjectMapper (). WriteValueAsString (bab); assertThat (eredmény, tartalmazzaString ("Saját babom")); assertThat (eredmény, tartalmazzaString ("{\" attr \ ": hamis}")); }

Használhatjuk az opcionális logikai argumentumot is érték ez meghatározza, hogy ez az annotáció aktív-e vagy sem.

2.5. @JsonValue

@JsonValue egyetlen metódust jelöl, amelyet a könyvtár a teljes példány sorosítására fog használni.

Például egy enumban feljegyezzük a getName val vel @JsonValue úgy, hogy bármely ilyen entitás a nevén keresztül soros legyen:

public enum TypeEnumWithValue {TYPE1 (1, "Type A"), TYPE2 (2, "Type 2"); magán egész szám; privát karakterlánc neve; // standard konstruktorok @JsonValue public String getName () {return name; }}

Most itt van a tesztünk:

@Test public void whenSerializingUsingJsonValue_thenCorrect () dobja a JsonParseException, IOException {String enumAsString = new ObjectMapper () .writeValueAsString (TypeEnumWithValue.TYPE1); assertThat (enumAsString, is ("" A típus "")); }

2.6. @JsonRootName

A @JsonRootName annotációt használunk, ha a csomagolás engedélyezve van, megadjuk a használni kívánt gyökérpakolás nevét.

A csomagolás azt jelenti, hogy a sorosítás helyett a Felhasználó olyasmi, mint:

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

Így fogják becsomagolni:

{"Felhasználó": {"id": 1, "név": "John"}}

Tehát nézzünk meg egy példát. Whasználni fogjuk a @JsonRootName annotáció a potenciális burkoló entitás nevének feltüntetésére:

@JsonRootName (value = "user") public class UserWithRoot {public int id; public String név; }

Alapértelmezés szerint a csomagoló neve az osztály neve lenne - UserWithRoot. Az annotáció használatával tisztább megjelenést kapunk felhasználó:

@Test public void whenSerializingUsingJsonRootName_thenCorrect () dobja a JsonProcessingException {UserWithRoot user = new User (1, "John"); ObjectMapper mapper = új ObjectMapper (); mapper.enable (SerializationFeature.WRAP_ROOT_VALUE); Karakterlánc eredménye = mapper.writeValueAsString (felhasználó); assertThat (eredmény, tartalmazzaString ("John")); assertThat (eredmény, tartalmazzaString ("felhasználó")); }

Itt van a sorosítás eredménye:

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

A Jackson 2.4 óta új választható érv névtér olyan adatformátumokkal használható, mint az XML. Ha hozzáadjuk, a teljes minősítésű név részévé válik:

@JsonRootName (value = "user", namespace = "users") public class UserWithRootNamespace {public int id; public String név; // ...}

Ha azzal sorosítjuk XmlMapper, a kimenet a következő lesz:

 1 János 

2.7. @JsonSerialize

@JsonSerialize jelzi, hogy mikor használatos egyedi sorosító rendezés az entitás.

Nézzünk meg egy gyors példát. Használni fogjuk @JsonSerialize hogy sorosítsa a esemény dátum ingatlan a CustomDateSerializer:

public class EventWithSerializer {public karakterlánc neve; @JsonSerialize (using = CustomDateSerializer.class) public Date eventDate; }

Íme az egyszerű, egyedi Jackson-sorozatszerelő:

public class CustomDateSerializer kiterjeszti az StdSerializer {privát statikus SimpleDateFormat formázó = új SimpleDateFormat ("dd-MM-éééé óó: pp: ss"); public CustomDateSerializer () {this (null); } public CustomDateSerializer (t osztály) {super (t); } @Orride public void serialize (Dátumérték, JsonGenerator gen, SerializerProvider arg2) dobja az IOException, JsonProcessingException {gen.writeString (formatter.format (érték)); }}

Most használjuk ezeket egy tesztben:

@Test public void whenSerializingUsingJsonSerialize_thenCorrect () dobja a JsonProcessingException, ParseException {SimpleDateFormat df = új SimpleDateFormat ("dd-MM-yyyy hh: mm: ss"); String toParse = "2014.12.20. 02:30:00"; Dátum dátum = df.parse (toParse); EventWithSerializer event = új EventWithSerializer ("party", dátum); Karakterlánc eredménye = új ObjectMapper (). WriteValueAsString (esemény); assertThat (eredmény, tartalmazzaString (toParse)); }

3. Jackson deserializációs kommentárok

Ezután vizsgáljuk meg a Jackson deserializációs kommentárjait.

3.1. @JsonCreator

Használhatjuk a @JsonCreator annotáció a deserializáláshoz használt konstruktor / gyár hangolásához.

Nagyon hasznos, ha deszerializálnunk kell néhány JSON-t, amely nem egyezik meg pontosan azzal a cél entitással, amelyet meg kell szereznünk.

Nézzünk meg egy példát. Tegyük fel, hogy deszerializálnunk kell a következő JSON-t:

{"id": 1, "theName": "Babom"}

Nincs azonban a név mező a cél entitásunkban, csak a név terület. Most nem akarjuk megváltoztatni magát az entitást, csak egy kicsit több ellenőrzésre van szükségünk a lebontási folyamat felett azzal, hogy a konstruktort @JsonCreator, és a @JsonProperty kommentár is:

public class BeanWithCreator {public int id; public String név; @JsonCreator public BeanWithCreator (@JsonProperty ("id") int id, @JsonProperty ("theName") karakterlánc neve) {this.id = id; ez.név = név; }}

Lássuk ezt működés közben:

@Test public void whenDeserializingUsingJsonCreator_thenCorrect () dobja az IOException {String json = "{\" id \ ": 1, \" theName \ ": \" My bab \ "}"; BeanWithCreator bean = new ObjectMapper () .readerFor (BeanWithCreator.class) .readValue (json); assertEquals ("Babom", bab.neve); }

3.2. @JacksonInject

@JacksonInject azt jelzi, hogy egy tulajdonság az injekcióból, és nem a JSON-adatokból kapja meg az értékét.

A következő példában azt használjuk @JacksonInject hogy beadja az ingatlant id:

public class BeanWithInject {@JacksonInject public int id; public String név; }

Így működik:

@Test public void, amikorDeserializingUsingJsonInject_thenCorrect () dobja az IOException {String json = "{\" name \ ": \" My bab \ "}"; InjectableValues ​​inject = new InjectableValues.Std () .addValue (int.osztály, 1); BeanWithInject bean = új ObjectMapper (). Olvasó (injekció) .forType (BeanWithInject.class) .readValue (json); assertEquals ("Babom", bab.neve); assertEquals (1, bab.id); }

3.3. @JsonAnySetter

@JsonAnySetter lehetővé teszi számunkra az a Térkép mint standard tulajdonságok. Dezerializáláskor a JSON tulajdonságai egyszerűen hozzáadódnak a térképhez.

Először is használni fogjuk @JsonAnySetter hogy deserializálja az entitást ExtendableBean:

public class ExtendableBean {public String name; saját térképi ingatlanok; @JsonAnySetter public void add (String kulcs, String érték) {properties.put (kulcs, érték); }}

Ez az a JSON, amelyet deszerializálnunk kell:

{"name": "Saját babom", "attr2": "val2", "attr1": "val1"}

Akkor az alábbiak szerint kapcsolódik egymáshoz:

@Test public void whenDeserializingUsingJsonAnySetter_thenCorrect () dobja az IOException {String json = "{\" name \ ": \" My bab \ ", \" attr2 \ ": \" val2 \ ", \" attr1 \ ": \" val1 \ "}"; ExtendableBean bean = new ObjectMapper () .readerFor (ExtendableBean.class) .readValue (json); assertEquals ("Babom", babnév); assertEquals ("val2", bean.getProperties (). get ("attr2")); }

3.4. @JsonSetter

@JsonSetter alternatívája a @JsonProperty amely szetter módszerként jelöli a módszert.

Ez hihetetlenül hasznos, ha el kell olvasnunk néhány JSON-adatot, de a cél entitás osztály nem pontosan egyezik meg az adatokkal, és ezért be kell hangolnunk a folyamatot, hogy illeszkedjen.

A következő példában megadjuk az s módszertetTheName () mint az név ingatlan a mi MyBean entitás:

nyilvános osztály MyBean {public int id; privát karakterlánc neve; @JsonSetter ("név") public void setTheName (karakterlánc neve) {this.name = név; }}

Most, amikor fel kell oldanunk néhány JSON-adatot, ez tökéletesen működik:

@Test public void, amikorDeserializingUsingJsonSetter_thenCorrect () dobja az IOException {String json = "{\" id \ ": 1, \" name \ ": \" My bab \ "}"; MyBean bab = new ObjectMapper () .readerFor (MyBean.class) .readValue (json); assertEquals ("Saját babom", bab.getTheName ()); }

3.5. @JsonDeserialize

@JsonDeserialize az egyedi deserializer használatát jelzi.

Először is használni fogjuk @JsonDeserialize deserializálni a esemény dátum ingatlan a CustomDateDeserializer:

public class EventWithSerializer {public String name; @JsonDeserialize (using = CustomDateDeserializer.class) public Date eventDate; }

Itt van az egyedi deserializer:

public class CustomDateDeserializer kiterjeszti a StdDeserializer {privát statikus SimpleDateFormat formázó = új SimpleDateFormat ("dd-MM-éééé óó: pp: ss"); public CustomDateDeserializer () {this (null); } public CustomDateDeserializer (vc osztály) {super (vc); } @Orride public Date deserialize (JsonParser jsonparser, DeserializationContext context) dobja az IOException {String date = jsonparser.getText (); próbáld ki a {return formatter.parse (dátum); } catch (ParseException e) {dobjon új RuntimeException (e); }}}

Ezután itt van a back-to-back teszt:

@Test public void whenDeserializingUsingJsonDeserialize_thenCorrect () dobja az IOException {String json = "{" name ":" party "," eventDate ":" 2014-12-20 02:30:00 "}"; SimpleDateFormat df = új SimpleDateFormat ("éééé-hh-éééé óó: pp: ss"); EventWithSerializer event = new ObjectMapper () .readerFor (EventWithSerializer.class) .readValue (json); assertEquals ("2014.12.20. 02:30:00", df.format (event.eventDate)); }

3.6. @JsonAlias

A @JsonAlias meghatározza egy vagy több alternatív név egy tulajdonságra a deserializáció során.

Nézzük meg, hogyan működik ez a kommentár, egy gyors példával:

public class AliasBean {@JsonAlias ​​({"fName", "f_name"}) private String firstName; privát karakterlánc vezetéknév; }

Itt van egy POJO, és szeretnénk a JSON-t deserializálni olyan értékekkel, mint a fName, f_name, és keresztnév ba,-be keresztnév a POJO változója.

Az alábbiakban egy tesztet győződünk meg arról, hogy ez a kommentár a várt módon működik:

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

4. Jackson Property Inclusion Annotations

4.1. @JsonIgnoreProperties

@JsonIgnoreProperties osztály szintű kommentár, amely olyan tulajdonságot vagy tulajdonságok listáját jelöli, amelyeket Jackson figyelmen kívül hagy.

Nézzünk meg egy gyors példát, figyelmen kívül hagyva az ingatlant id a sorosítástól:

@JsonIgnoreProperties ({"id"}) nyilvános osztály BeanWithIgnore {public int id; public String név; }

Itt van a teszt, amely biztosítja, hogy a figyelmen kívül hagyás megtörténjen:

@Test public void whenSerializingUsingJsonIgnoreProperties_thenCorrect () dobja a JsonProcessingException {BeanWithIgnore babot = új BeanWithIgnore (1, "Saját babom"); Karakterlánc eredménye = new ObjectMapper () .writeValueAsString (bab); assertThat (eredmény, tartalmazzaString ("Saját babom")); assertThat (eredmény, nem (tartalmazzaString ("id"))); }

Beállíthatjuk, hogy kivétel nélkül figyelmen kívül hagyjuk a JSON bemenet ismeretlen tulajdonságait ignoreUnknown = true nak,-nek @JsonIgnoreProperties annotáció.

4.2. @JsonIgnore

Ezzel szemben a @JsonIgnore az annotációval egy olyan tulajdonságot jelölhetünk, amelyet a mező szintjén figyelmen kívül hagyunk.

Használjuk @JsonIgnore hogy figyelmen kívül hagyja az ingatlant id sorosítástól:

public class BeanWithIgnore {@JsonIgnore public int id; public String név; }

Akkor teszteljük, hogy megbizonyosodjunk arról id sikeresen figyelmen kívül hagyták:

@Test public void whenSerializingUsingJsonIgnore_thenCorrect () dobja a JsonProcessingException {BeanWithIgnore bean = new BeanWithIgnore (1, "Saját bab"); Karakterlánc eredménye = new ObjectMapper () .writeValueAsString (bab); assertThat (eredmény, tartalmazzaString ("Saját babom")); assertThat (eredmény, nem (tartalmazzaString ("id"))); }

4.3. @JsonIgnoreType

@JsonIgnoreType a kommentált típus összes tulajdonságát figyelmen kívül hagyja.

Használhatjuk az annotációt a típus minden tulajdonságának megjelölésére Név figyelmen kívül kell hagyni:

public class Felhasználó {public int id; public Név neve; @JsonIgnoreType public static class Name {public String keresztnév; public String vezetéknév; }}

Azt is tesztelhetjük, hogy a figyelmen kívül hagyás megfelelően működik-e:

@Test public void whenSerializingUsingJsonIgnoreType_thenCorrect () dobja a JsonProcessingException, ParseException {User.Name name = új User.Name ("John", "Doe"); Felhasználó felhasználó = új Felhasználó (1, név); Karakterlánc eredménye = új ObjectMapper () .writeValueAsString (felhasználó); assertThat (eredmény, tartalmazzaString ("1")); assertThat (eredmény, nem (tartalmazzaString ("név"))); assertThat (eredmény, nem (tartalmazzaString ("John"))); }

4.4. @JsonInclude

Tudjuk használni @JsonInclude az üres / null / alapértelmezett értékekkel rendelkező tulajdonságok kizárásához.

Nézzünk meg egy példát, amely kizárja a nullákat a sorosításból:

@JsonInclude (Include.NON_NULL) nyilvános osztály MyBean {public int id; public String név; }

Itt van a teljes teszt:

public void whenSerializingUsingJsonInclude_thenCorrect () dobja a JsonProcessingException {MyBean bab = új MyBean (1, null); Karakterlánc eredménye = new ObjectMapper () .writeValueAsString (bab); assertThat (eredmény, tartalmazzaString ("1")); assertThat (eredmény, nem (tartalmazzaString ("név"))); }

4.5. @JsonAutoDetect

@JsonAutoDetect felülírhatja az alapértelmezett szemantikáját mely tulajdonságok láthatók és melyek nem.

Először vessünk egy pillantást arra, hogy az annotáció nagyon hasznos lehet-e egy egyszerű példával; engedélyezzük a magántulajdonok sorosítását:

@JsonAutoDetect (fieldVisibility = Visibility.ANY) public class PrivateBean {private int id; privát karakterlánc neve; }

Ezután a teszt:

@Test public void whenSerializingUsingJsonAutoDetect_thenCorrect () dobja a JsonProcessingException {PrivateBean bab = új PrivateBean (1, "Saját bab"); Karakterlánc eredménye = new ObjectMapper () .writeValueAsString (bab); assertThat (eredmény, tartalmazzaString ("1")); assertThat (eredmény, tartalmazzaString ("Saját babom")); }

5. Jackson polimorf típusú kezelő kommentárok

Ezután vessünk egy pillantást a Jackson polimorf típusú kezelési kommentárjaira:

  • @JsonTypeInfo - jelzi, hogy milyen típusú információkat kell felvenni a szerializációba
  • @JsonSubTypes - a feljegyzett típus altípusait jelöli
  • @JsonTypeName - meghatároz egy logikai típusú nevet, amelyet a jegyzetekkel ellátandó osztályhoz használhatunk

Vizsgáljuk meg egy összetettebb példát, és használjuk mindhármat - @JsonTypeInfo, @JsonSubTypes, és @JsonTypeName - az entitás sorosítására / deszerializálására Állatkert:

közosztályú állatkert {nyilvános állatállat; @JsonTypeInfo (use = JsonTypeInfo.Id.NAME, include = As.PROPERTY, property = "type") @JsonSubTypes ({@ JsonSubTypes.Type (value = Dog.class, name = "dog"), @ JsonSubTypes.Type ( érték = Cat.class, name = "cat")}) public static class Animal {public String name; } @JsonTypeName ("kutya") nyilvános statikus osztály A kutya kiterjeszti az állatot {nyilvános kettős ugatásVolume; } @JsonTypeName ("cat") public static class Cat meghosszabbítja az állatot {boolean likesCream; nyilvános int élet; }}

Amikor sorosítunk:

@Test public void whenSerializingPolymorphic_thenCorrect () dobja a JsonProcessingException {Zoo.Dog dog = new Zoo.Dog ("csipkés"); Állatkert állatkert = új Állatkert (kutya); Karakterlánc eredménye = new ObjectMapper () .writeValueAsString (állatkert); assertThat (eredmény, tartalmazzaString ("típus")); assertThat (eredmény, tartalmazzaString ("kutya")); }

Itt olvasható a Állatkert például a Kutya eredményez:

{"állat": {"type": "kutya", "név": "csipkés", "barkVolume": 0}}

Most a sorosítás megszüntetéséről. Kezdjük a következő JSON bemenettel:

{"állat": {"név": "csipkés", "típus": "macska"}}

Akkor nézzük meg, hogy ez hogyan válik szembe a Állatkert példa:

@Test public void whenDeserializingPolymorphic_thenCorrect () dobja az IOException {String json = "{\" animal \ ": {\" name \ ": \" csipkés \ ", \" type \ ": \" cat \ "}}"; Állatkert állatkert = new ObjectMapper () .readerFor (Zoo.class) .readValue (json); assertEquals ("csipkés", állatkert.állatnév); assertEquals (Zoo.Cat.class, zoo.animal.getClass ()); }

6. Jackson általános kommentárjai

Ezután tárgyaljuk Jackson néhány általánosabb feljegyzését.

6.1. @JsonProperty

Hozzátehetjük a @JsonProperty annotáció a tulajdonság nevének a JSON-ban való feltüntetésére.

Használjuk @JsonProperty a tulajdon sorosítása / deszerializálása érdekében név amikor nem szabványos mérőeszközökkel és beállítókkal van dolgunk:

nyilvános osztály MyBean {public int id; privát karakterlánc neve; @JsonProperty ("név") public void setTheName (karakterlánc neve) {this.name = név; } @JsonProperty ("név") public String getTheName () {return név; }}

A következő a tesztünk:

@Test public void, amikor aUsingJsonProperty_thenCorrect () az IOException-t dobja {MyBean bean = new MyBean (1, "My bab"); Karakterlánc eredménye = új ObjectMapper (). WriteValueAsString (bab); assertThat (eredmény, tartalmazzaString ("Saját babom")); assertThat (eredmény, tartalmazzaString ("1")); MyBean resultBean = new ObjectMapper () .readerFor (MyBean.class) .readValue (eredmény); assertEquals ("Saját babom", resultBean.getTheName ()); }

6.2. @JsonFormat

A @JsonFormat az annotáció megad egy formátumot a Dátum / Idő értékek sorosítása során.

A következő példában azt használjuk @JsonFormat a tulajdonság formátumának szabályozásához esemény dátum:

public class EventWithFormat {public String name; @JsonFormat (shape = JsonFormat.Shape.STRING, pattern = "dd-MM-yyyy hh: mm: ss") public Date eventDate; }

Akkor itt van a teszt:

@Test public void whenSerializingUsingJsonFormat_thenCorrect () dobja a JsonProcessingException, ParseException {SimpleDateFormat df = új SimpleDateFormat ("dd-MM-yyyy hh: mm: ss"); df.setTimeZone (TimeZone.getTimeZone ("UTC")); String toParse = "2014.12.20. 02:30:00"; Dátum dátum = df.parse (toParse); EventWithFormat event = new EventWithFormat ("party", dátum); Karakterlánc eredménye = új ObjectMapper (). WriteValueAsString (esemény); assertThat (eredmény, tartalmazzaString (toParse)); }

6.3. @JsonUnwrapped

@JsonUnwrapped meghatározza azokat az értékeket, amelyeket sorosítva / deserializálva kell kibontani / lapítani.

Nézzük meg pontosan, hogy működik ez; a felirat használatával kibontjuk az ingatlant név:

public class UnwrappedUser {public int id; @JsonUnwrapped public Name név; public static class Név {public String keresztnév; public String vezetéknév; }}

Most sorosítsuk az osztály egyik példányát:

@Test public void whenSerializingUsingJsonUnwrapped_thenCorrect () dobja a JsonProcessingException, ParseException {UnwrappedUser.Name name = new UnwrappedUser.Name ("John", "Doe"); UnwrappedUser felhasználó = new UnwrappedUser (1, név); Karakterlánc eredménye = új ObjectMapper (). WriteValueAsString (felhasználó); assertThat (eredmény, tartalmazzaString ("John")); assertThat (eredmény, nem (tartalmazzaString ("név"))); }

Végül a következőképpen néz ki a kimenet: a statikusan beágyazott osztály mezői kibontva a másik mezővel:

{"id": 1, "keresztnév": "John", "vezetékNév": "Doe"}

6.4. @JsonView

@JsonView azt a nézetet jelöli, amelyben a tulajdonság sorosítás / deserializálás céljából szerepel.

Például használjuk @JsonView sorosítani egy példányát Tétel entitás.

Először kezdjük a nézetekkel:

public class Views {public static class Public {} public static class Internal extens Public {}}

Következő itt a Tétel a nézeteket használó entitás:

public class Item {@JsonView (Views.Public.class) public int id; @JsonView (Views.Public.class) public String itemName; @JsonView (Views.Internal.class) public String tulajdonosNév; }

Végül a teljes teszt:

@Test public void whenSerializingUsingJsonView_thenCorrect () dobja a JsonProcessingException {Item item = new Item (2, "book", "John"); Karakterlánc eredménye = új ObjectMapper () .writerWithView (Views.Public.class) .writeValueAsString (elem); assertThat (eredmény, tartalmazzaString ("könyv")); assertThat (eredmény, tartalmazzaString ("2")); assertThat (eredmény, nem (tartalmazzaString ("John"))); }

6.5. @JsonManagedReference, @JsonBackReference

A @JsonManagedReference és @JsonBackReference az annotációk kezelhetik a szülő / gyermek kapcsolatokat és körbejárja a hurkokat.

A következő példában azt használjuk @JsonManagedReference és @JsonBackReference hogy szerializáljuk ItemWithRef entitás:

public class ItemWithRef {public int id; public String itemName; @JsonManagedReference public UserWithRef tulajdonos; }

A mi UserWithRef entitás:

public class UserWithRef {public int id; public String név; @JsonBackReference public List userItems; }

Ezután a teszt:

@Test public void whenSerializingUsingJacksonReferenceAnnotation_thenCorrect () dobja a JsonProcessingException {UserWithRef user = new UserWithRef (1, "John"); ItemWithRef item = new ItemWithRef (2, "könyv", felhasználó); user.addItem (elem); Karakterlánc eredménye = új ObjectMapper (). WriteValueAsString (elem); assertThat (eredmény, tartalmazzaString ("könyv")); assertThat (eredmény, tartalmazzaString ("John")); assertThat (eredmény, nem (tartalmazzaString ("userItems"))); }

6.6. @JsonIdentityInfo

@JsonIdentityInfo azt jelzi, hogy az objektumazonosítót kell használni az értékek sorosításához / deszerializálásához, például a végtelen rekurziós típusú problémák kezeléséhez.

A következő példában van egy ItemWithIdentity - kétirányú kapcsolatban álló szervezet a UserWithIdentity entitás:

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

A UserWithIdentity entitás:

@JsonIdentityInfo (generator = ObjectIdGenerators.PropertyGenerator.class, property = "id") public class UserWithIdentity {public int id; public String név; public List userItems; }

Most nézzük meg, hogyan kezelik a végtelen rekurziós problémát:

@Test public void whenSerializingUsingJsonIdentityInfo_thenCorrect () dobja a JsonProcessingException {UserWithIdentity user = new UserWithIdentity (1, "John"); ItemWithIdentity item = új ItemWithIdentity (2, "könyv", felhasználó); user.addItem (elem); Karakterlánc eredménye = új ObjectMapper (). WriteValueAsString (elem); assertThat (eredmény, tartalmazzaString ("könyv")); assertThat (eredmény, tartalmazzaString ("John")); assertThat (eredmény, tartalmazzaString ("userItems")); }

Itt van a sorosított tétel és a felhasználó teljes kimenete:

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

6.7. @JsonFilter

A @JsonFilter az annotation meghatározza a sorosítás során használandó szűrőt.

Először meghatározzuk az entitást, és rámutatunk a szűrőre:

@JsonFilter ("myFilter") nyilvános osztály BeanWithFilter {public int id; public String név; }

Most a teljes tesztben meghatározzuk a szűrőt, amely kizár minden egyéb tulajdonságot, kivéve név sorosítástól:

@Test public void whenSerializingUsingJsonFilter_thenCorrect () dobja a JsonProcessingException {BeanWithFilter bean = new BeanWithFilter (1, "Saját bab"); FilterProvider szűrők = new SimpleFilterProvider (). AddFilter ("myFilter", SimpleBeanPropertyFilter.filterOutAllExcept ("név")); Karakterlánc eredménye = új ObjectMapper () .writer (szűrők) .writeValueAsString (bab); assertThat (eredmény, tartalmazzaString ("Saját babom")); assertThat (eredmény, nem (tartalmazzaString ("id"))); }

7. Custom Jackson Annotation

Ezután nézzük meg, hogyan hozhatunk létre egyedi Jackson-feljegyzéseket. Használhatjuk a @JacksonAnnotationsInside kommentár:

@Retention (RetentionPolicy.RUNTIME) @JacksonAnnotationsInside @JsonInclude (Include.NON_NULL) @JsonPropertyOrder ({"név", "id", "dateCreated"}) nyilvános @interface CustomAnnotation {}

Most, ha egy entitáson használjuk az új jegyzetet:

@CustomAnnotation public class BeanWithCustomAnnotation {public int id; public String név; public Date dateCreated; }

Láthatjuk, hogyan ötvözi a meglévő kommentárokat egy egyszerű szokássá, amelyet gyorsírásként használhatunk:

@Test public void whenSerializingUsingCustomAnnotation_thenCorrect () dobja a JsonProcessingException {BeanWithCustomAnnotation babot = új BeanWithCustomAnnotation (1, "Saját babom", null); Karakterlánc eredménye = új ObjectMapper (). WriteValueAsString (bab); assertThat (eredmény, tartalmazzaString ("Saját babom")); assertThat (eredmény, tartalmazzaString ("1")); assertThat (eredmény, nem (tartalmazzaString ("dateCreated"))); }

A sorosítási folyamat kimenete:

{"name": "Saját babom", "id": 1}

8. Jackson MixIn kommentárok

Ezután nézzük meg, hogyan kell használni a Jackson MixIn kommentárokat.

Például használjuk a MixIn kommentárokat a típus tulajdonságainak figyelmen kívül hagyására Felhasználó:

public class Item {public int id; public String itemName; nyilvános Felhasználótulajdonos; }
@JsonIgnoreType nyilvános osztály MyMixInForIgnoreType {}

Akkor lássuk ezt működés közben:

@Test public void whenSerializingUsingMixInAnnotation_thenCorrect () dobja a JsonProcessingException {Item item = new Item (1, "book", null); Karakterlánc eredménye = új ObjectMapper (). WriteValueAsString (elem); assertThat (eredmény, tartalmazzaString ("tulajdonos")); ObjectMapper mapper = új ObjectMapper (); mapper.addMixIn (Felhasználó.osztály, MyMixInForIgnoreType.osztály); eredmény = mapper.writeValueAsString (elem); assertThat (eredmény, nem (tartalmazzaString ("tulajdonos"))); }

9. Tiltsa le a Jackson Annotation funkciót

Végül nézzük meg, hogyan tudunk tiltsa le az összes Jackson annotációt. Ezt megtehetjük a MapperFeature.USE_ANNOTATIONS, mint a következő példában:

@JsonInclude (Include.NON_NULL) @JsonPropertyOrder ({"név", "id"}) nyilvános osztály MyBean {public int id; public String név; }

A kommentárok letiltása után ezeknek nincs hatása, és a könyvtár alapértelmezett értékeit kell alkalmazni:

@Test public void, amikorDisabledAllAnnotations_thenAllDisabled () dobja az IOException-t {MyBean bean = new MyBean (1, null); ObjectMapper mapper = új ObjectMapper (); mapper.disable (MapperFeature.USE_ANNOTATIONS); Karakterlánc eredménye = mapper.writeValueAsString (bab); assertThat (eredmény, tartalmazzaString ("1")); assertThat (eredmény, tartalmazzaString ("név")); }

A jelölések letiltása előtti sorosítás eredménye:

{"id": 1}

A sorosítás eredménye a kommentárok letiltása után:

{"id": 1, "név": null}

10. Következtetés

Ebben a cikkben megvizsgáltuk a Jackson annotációit, csak megkarcoltuk annak a rugalmasságnak a felületét, amelyet megfelelő használatukkal elérhetünk.

Ezen példák és kódrészletek megvalósítása megtalálható a GitHub-on.