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.
