Príklady anotácií Jacksona
1. Prehľad
V tejto príručke sa podrobne ponoríme Jacksonove anotácie.
Uvidíme, ako použiť existujúce anotácie, ako vytvoriť vlastné a nakoniec ako ich deaktivovať.
2. Jacksonove serializačné anotácie
Najskôr sa pozrieme na poznámky o serializácii.
2.1. @JsonAnyGetter
The @JsonAnyGetter anotácia umožňuje flexibilitu použitia a Mapa pole ako štandardné vlastnosti.
Napríklad ExtendableBean subjekt má názov vlastnosť a sada rozšíriteľných atribútov vo forme dvojíc kľúč / hodnota:
public class ExtendableBean {public Názov reťazca; súkromné vlastnosti mapy; @JsonAnyGetter verejná mapa getProperties () {návratové vlastnosti; }}Keď serializujeme inštanciu tejto entity, dostaneme všetky páry kľúč - hodnota v Mapa štandardne, obyčajné vlastnosti:
{"name": "My bean", "attr2": "val2", "attr1": "val1"}Takto vyzerá serializácia tejto entity v praxi:
@Test public void whenSerializingUsingJsonAnyGetter_thenCorrect () hodí JsonProcessingException {ExtendableBean bean = new ExtendableBean ("My bean"); bean.add ("attr1", "val1"); bean.add ("attr2", "val2"); Výsledok reťazca = nový ObjectMapper (). WriteValueAsString (fazuľa); assertThat (result, containsString ("attr1")); assertThat (result, containsString ("val1")); }Môžeme tiež použiť voliteľný argument povolené ako nepravdivé zakázať @JsonAnyGetter (). V takom prípade Mapa budú prevedené ako JSON a zobrazia sa pod vlastnosti premenná po serializácii.
2.2. @JsonGetter
The @JsonGetter anotácia je alternatívou k @JsonProperty anotácia, ktorá označuje metódu ako getrovú metódu.
V nasledujúcom príklade určíme metódu getTheName () ako getrovacia metóda názov majetok a MyBean subjekt:
public class MyBean {public int id; súkromné meno reťazca; @JsonGetter ("meno") public String getTheName () {návratové meno; }}Takto to funguje v praxi:
@Test public void whenSerializingUsingJsonGetter_thenCorrect () vyvolá JsonProcessingException {MyBean bean = new MyBean (1, "My bean"); Výsledok reťazca = nový ObjectMapper (). WriteValueAsString (fazuľa); assertThat (result, containsString ("My bean")); assertThat (result, containsString ("1")); }2.3. @JsonPropertyOrder
Môžeme použiť @JsonPropertyOrder anotáciu upresniť poradie vlastností pri serializácii.
Poďme nastaviť vlastné poradie pre vlastnosti a MyBean subjekt:
@JsonPropertyOrder ({"name", "id"}) verejná trieda MyBean {public int id; verejné meno reťazca; }Tu je výstup serializácie:
{"name": "My bean", "id": 1}Potom môžeme urobiť jednoduchý test:
@ Test public void whenSerializingUsingJsonPropertyOrder_thenCorrect () vyvolá JsonProcessingException {MyBean bean = new MyBean (1, "My bean"); Výsledok reťazca = nový ObjectMapper (). WriteValueAsString (fazuľa); assertThat (result, containsString ("My bean")); assertThat (result, containsString ("1")); }Môžeme tiež použiť @JsonPropertyOrder (abecedné = pravda) zoradiť vlastnosti podľa abecedy. V takom prípade bude výstupom serializácie:
{"id": 1, "name": "My bean"}2.4. @JsonRawValue
The @JsonRawValue anotácia môže dajte Jacksonovi pokyn, aby serializoval vlastnosť presne tak, ako je.
V nasledujúcom príklade používame @JsonRawValue vložiť nejaký vlastný JSON ako hodnotu entity:
public class RawBean {public String name; @JsonRawValue verejný reťazec JSON; }Výstupom serializácie entity je:
{"name": "My bean", "json": {"attr": false}}Ďalej je tu jednoduchý test:
@Test public void whenSerializingUsingJsonRawValue_thenCorrect () hodí JsonProcessingException {RawBean bean = new RawBean ("My bean", "{\" attr \ ": false}"); Výsledok reťazca = nový ObjectMapper (). WriteValueAsString (fazuľa); assertThat (result, containsString ("My bean")); assertThat (result, containsString ("{\" attr \ ": false}")); }Môžeme tiež použiť voliteľný logický argument hodnotu ktorá definuje, či je táto anotácia aktívna alebo nie.
2.5. @JsonValue
@JsonValue označuje jednu metódu, ktorú knižnica použije na serializáciu celej inštancie.
Napríklad v enume anotujeme getName s @JsonValue aby každá takáto entita bola serializovaná pomocou jej názvu:
public enum TypeEnumWithValue {TYPE1 (1, "Type A"), TYPE2 (2, "Type 2"); súkromné celé číslo; súkromné meno reťazca; // štandardné konštruktory @JsonValue public String getName () {návratové meno; }}Teraz je tu náš test:
@Test public void whenSerializingUsingJsonValue_thenCorrect () hodí JsonParseException, IOException {String enumAsString = new ObjectMapper () .writeValueAsString (TypeEnumWithValue.TYPE1); assertThat (enumAsString, je ("" Typ A "")); }2.6. @JsonRootName
The @JsonRootName anotácia sa používa, ak je povolené zalamovanie, na určenie názvu koreňového obalu, ktorý sa má použiť.
Zalomenie znamená, že namiesto serializácie a Používateľ na niečo ako:
{"id": 1, "name": "John"}Bude to zabalené takto:
{"User": {"id": 1, "name": "John"}}Pozrime sa teda na príklad. Žpoužijem @JsonRootName anotácia označujúca názov tejto potenciálnej obalovej entity:
@JsonRootName (hodnota = "užívateľ") verejná trieda UserWithRoot {verejné int id; verejné meno reťazca; }V predvolenom nastavení by názov obálky bol názov triedy - UserWithRoot. Použitím anotácie dostaneme vzhľad čističa užívateľ:
@ Test public void whenSerializingUsingJsonRootName_thenCorrect () vyvolá JsonProcessingException {UserWithRoot user = nový používateľ (1, "John"); ObjectMapper mapovač = nový ObjectMapper (); mapper.enable (SerializationFeature.WRAP_ROOT_VALUE); Výsledok reťazca = mapper.writeValueAsString (užívateľ); assertThat (result, containsString ("John")); assertThat (result, containsString ("user")); }Tu je výstup serializácie:
{"user": {"id": 1, "name": "John"}}Od verzie Jackson 2.4, nový voliteľný argument menný priestor je k dispozícii na použitie s dátovými formátmi, ako je XML. Ak ho pridáme, stane sa súčasťou plne kvalifikovaného názvu:
@JsonRootName (hodnota = "užívateľ", namespace = "užívatelia") verejná trieda UserWithRootNamespace {public int id; verejné meno reťazca; // ...}Keby sme to serializovali s XmlMapper, výstup bude:
1 Ján 2.7. @JsonSerialize
@JsonSerialize označuje vlastný serializátor, ktorý sa má použiť, keď zoradenie subjektu.
Pozrime sa na rýchly príklad. Ideme použiť @JsonSerialize na pokračovanie dátum udalosti nehnuteľnosť s a CustomDateSerializer:
public class EventWithSerializer {public String name; @JsonSerialize (using = CustomDateSerializer.class) public Date eventDate; }Tu je jednoduchý prispôsobený Jacksonov serializátor:
verejná trieda CustomDateSerializer rozširuje StdSerializer {private static SimpleDateFormat formatter = nový SimpleDateFormat ("dd-MM-rrrr hh: mm: ss"); public CustomDateSerializer () {this (null); } public CustomDateSerializer (trieda t) {super (t); } @Override public void serialize (hodnota dátumu, JsonGenerator gen, SerializerProvider arg2) hodí IOException, JsonProcessingException {gen.writeString (formatter.format (hodnota)); }}Teraz ich použijeme v teste:
@Test public void whenSerializingUsingJsonSerialize_thenCorrect () hodí JsonProcessingException, ParseException {SimpleDateFormat df = new SimpleDateFormat ("dd-MM-rrrr hh: mm: ss"); String toParse = "20-12-2014 02:30:00"; Dátum dátum = df.parse (toParse); EventWithSerializer event = nový EventWithSerializer ("párty", dátum); Výsledok reťazca = nový ObjectMapper (). WriteValueAsString (udalosť); assertThat (result, containsString (toParse)); }3. Jacksonove deserializačné anotácie
Ďalej sa pozrieme na anotácie Jacksonovej deserializácie.
3.1. @JsonCreator
Môžeme použiť @JsonCreator anotácia na vyladenie konštruktéra / továrne použitej pri deserializácii.
Je to veľmi užitočné, keď potrebujeme deserializovať nejaký JSON, ktorý sa presne nezhoduje s cieľovou entitou, ktorú potrebujeme získať.
Pozrime sa na príklad. Povedzme, že musíme deserializovať nasledujúci JSON:
{"id": 1, "theName": "Moja fazuľa"}Neexistuje však žiadna názov pole v našej cieľovej entite, existuje iba a názov lúka. Teraz nechceme meniť samotnú entitu, len potrebujeme trochu väčšiu kontrolu nad procesom zjednávania anotovaním konštruktora pomocou @JsonCreator, a pomocou @JsonProperty anotácia tiež:
public class BeanWithCreator {public int id; verejné meno reťazca; @JsonCreator public BeanWithCreator (@JsonProperty ("id") int id, @JsonProperty ("theName") Názov reťazca) {this.id = id; this.name = meno; }}Uvidíme v akcii:
@ Test public void whenDeserializingUsingJsonCreator_thenCorrect () vyvolá IOException {String json = "{\" id \ ": 1, \" theName \ ": \" My bean \ "}"; BeanWithCreator bean = nový ObjectMapper () .readerFor (BeanWithCreator.class) .readValue (json); assertEquals ("Moja fazuľa", bean.name); }3.2. @JacksonInject
@JacksonInject označuje, že vlastnosť získa svoju hodnotu z injekcie, a nie z údajov JSON.
V nasledujúcom príklade používame @JacksonInject vložiť majetok id:
public class BeanWithInject {@JacksonInject public int id; verejné meno reťazca; }Funguje to takto:
@ Test public void whenDeserializingUsingJsonInject_thenCorrect () vyvolá IOException {String json = "{\" name \ ": \" My bean \ "}"; InjectableValues inject = new InjectableValues.Std () .addValue (int.class, 1); BeanWithInject bean = nový ObjectMapper (). Reader (inject) .forType (BeanWithInject.class) .readValue (json); assertEquals ("Moja fazuľa", bean.name); assertEquals (1, bean.id); }3.3. @JsonAnySetter
@JsonAnySetter nám umožňuje flexibilitu používania a Mapa ako štandardné vlastnosti. Pri deserializácii sa vlastnosti z JSONu jednoducho pridajú na mapu.
Najprv použijeme @JsonAnySetter deserializovať entitu ExtendableBean:
public class ExtendableBean {public Názov reťazca; súkromné vlastnosti mapy; @JsonAnySetter public void add (kľúč reťazca, hodnota reťazca) {properties.put (kľúč, hodnota); }}Toto je JSON, ktorý musíme deserializovať:
{"name": "My bean", "attr2": "val2", "attr1": "val1"}Tu je príklad, ako to všetko spolu súvisí:
@ Test public void whenDeserializingUsingJsonAnySetter_thenCorrect () vyvolá IOException {String json = "{\" name \ ": \" My bean \ ", \" attr2 \ ": \" val2 \ ", \" attr1 \ ": \" val1 \ "}"; Fazuľa ExtendableBean = nový ObjectMapper () .readerFor (ExtendableBean.class) .readValue (json); assertEquals ("Moja fazuľa", bean.name); assertEquals ("val2", bean.getProperties (). get ("attr2")); }3.4. @JsonSetter
@JsonSetter je alternatívou k @JsonProperty ktorá označuje metódu ako metódu setter.
To je neuveriteľne užitočné, keď potrebujeme prečítať nejaké údaje JSON, ale trieda cieľovej entity sa nezhoduje presne s týmito údajmi, a preto musíme vyladiť postup tak, aby vyhovoval.
V nasledujúcom príklade zadáme metódu setTheName () ako zakladateľ spoločnosti názov majetok v našom MyBean subjekt:
public class MyBean {public int id; súkromné meno reťazca; @JsonSetter ("meno") public void setTheName (názov reťazca) {this.name = meno; }}Teraz, keď potrebujeme zrušiť zdieľanie niektorých údajov JSON, to funguje úplne dobre:
@ Test public void whenDeserializingUsingJsonSetter_thenCorrect () vyvolá IOException {String json = "{\" id \ ": 1, \" name \ ": \" My bean \ "}"; MyBean bean = nový ObjectMapper () .readerFor (MyBean.class) .readValue (json); assertEquals ("Moja fazuľa", bean.getTheName ()); }3.5. @JsonDeserialize
@JsonDeserialize označuje použitie vlastného deserializátora.
Najprv použijeme @JsonDeserialize rekonštruovať dátum udalosti majetok s CustomDateDeserializer:
public class EventWithSerializer {public String name; @JsonDeserialize (using = CustomDateDeserializer.class) public Date eventDate; }Tu je vlastný deserializátor:
verejná trieda CustomDateDeserializer rozširuje StdDeserializer {private static SimpleDateFormat formatter = nový SimpleDateFormat ("dd-MM-rrrr hh: mm: ss"); public CustomDateDeserializer () {this (null); } public CustomDateDeserializer (Class vc) {super (vc); } @Override public Date deserialize (JsonParser jsonparser, DeserializationContext context) hodí IOException {String date = jsonparser.getText (); skus {vratit formatter.parse (date); } catch (ParseException e) {throw new RuntimeException (e); }}}Ďalej je tu test back-to-back:
@Test public void whenDeserializingUsingJsonDeserialize_thenCorrect () hodí IOException {String json = "{" name ":" party "," eventDate ":" 20-12-2014 02:30:00 "}"; SimpleDateFormat df = nový SimpleDateFormat ("dd-MM-rrrr hh: mm: ss"); EventWithSerializer event = nový ObjectMapper () .readerFor (EventWithSerializer.class) .readValue (json); assertEquals ("20-12-2014 02:30:00", df.format (event.eventDate)); }3.6. @JsonAlias
The @JsonAlias definuje jeden alebo viac alternatívnych mien vlastnosti počas deserializácie.
Pozrime sa, ako táto anotácia funguje, na krátkom príklade:
verejná trieda AliasBean {@JsonAlias ({"fName", "f_name"}) súkromný reťazec firstName; private String priezvisko; }Tu máme POJO a chceme deserializovať JSON s hodnotami ako napr fName, f_namea krstné meno do krstné meno premenná POJO.
Ďalej uvádzame test, ktorý zaisťuje, aby táto anotácia fungovala podľa očakávania:
@ Test public void whenDeserializingUsingJsonAlias_thenCorrect () vyvolá IOException {String json = "{\" fName \ ": \" John \ ", \" lastName \ ": \" Green \ "}"; AliasBean aliasBean = nový ObjectMapper (). ReaderFor (AliasBean.class) .readValue (json); assertEquals ("John", aliasBean.getFirstName ()); }4. Anotácie začlenenia majetku Jackson
4.1. @JsonIgnoreProperties
@JsonIgnoreProperties je anotácia na úrovni triedy, ktorá označuje vlastnosť alebo zoznam vlastností, ktoré Jackson bude ignorovať.
Pozrime sa na krátky príklad ignorovania vlastnosti id zo serializácie:
@JsonIgnoreProperties ({"id"}) verejná trieda BeanWithIgnore {public int id; verejné meno reťazca; }Teraz je tu test, ktorý zaisťuje, že dôjde k ignorovaniu:
@Test public void whenSerializingUsingJsonIgnoreProperties_thenCorrect () hodí JsonProcessingException {BeanWithIgnore bean = new BeanWithIgnore (1, "My bean"); Výsledok reťazca = nový ObjectMapper () .writeValueAsString (fazuľa); assertThat (result, containsString ("My bean")); assertThat (result, not (containsString ("id"))); }Ak chcete ignorovať všetky neznáme vlastnosti vo vstupe JSON bez výnimky, môžeme nastaviť ignoreUnknown = true z @JsonIgnoreProperties anotácia.
4.2. @JsonIgnore
Naproti tomu @JsonIgnore anotácia sa používa na označenie vlastnosti, ktorá sa má ignorovať na úrovni poľa.
Poďme použiť @JsonIgnore ignorovať vlastnosť id zo serializácie:
public class BeanWithIgnore {@JsonIgnore public int id; verejné meno reťazca; }Potom vykonáme test, aby sme sa uistili, že id bol úspešne ignorovaný:
@Test public void whenSerializingUsingJsonIgnore_thenCorrect () hodí JsonProcessingException {BeanWithIgnore bean = new BeanWithIgnore (1, "My bean"); Výsledok reťazca = nový ObjectMapper () .writeValueAsString (fazuľa); assertThat (result, containsString ("My bean")); assertThat (result, not (containsString ("id"))); }4.3. @JsonIgnoreType
@JsonIgnoreType označí všetky vlastnosti anotovaného typu, ktoré sa majú ignorovať.
Pomocou anotácie môžeme označiť všetky vlastnosti typu názov ignorovať:
public class User {public int id; verejné meno meno; @JsonIgnoreType verejná statická trieda Názov {verejný reťazec meno; verejný reťazec priezvisko; }}Môžeme tiež vyskúšať, či zaistenie funguje správne:
@ Test public void whenSerializingUsingJsonIgnoreType_thenCorrect () hodí JsonProcessingException, ParseException {User.Name name = new User.Name ("John", "Doe"); User user = new User (1, name); Výsledok reťazca = nový ObjectMapper () .writeValueAsString (užívateľ); assertThat (result, containsString ("1")); assertThat (výsledok, nie (containsString ("meno"))); assertThat (výsledok, nie (containsString ("John"))); }4.4. @JsonInclude
Môžeme použiť @JsonInclude vylúčiť vlastnosti s prázdnymi / nulovými / predvolenými hodnotami.
Pozrime sa na príklad vylučujúci hodnoty null zo serializácie:
@JsonInclude (Include.NON_NULL) verejná trieda MyBean {verejné int id; verejné meno reťazca; }Celý test:
public void whenSerializingUsingJsonInclude_thenCorrect () hodí JsonProcessingException {MyBean bean = new MyBean (1, null); Výsledok reťazca = nový ObjectMapper () .writeValueAsString (fazuľa); assertThat (result, containsString ("1")); assertThat (výsledok, nie (containsString ("meno"))); }4.5. @JsonAutoDetect
@JsonAutoDetect môže prepísať predvolenú sémantiku súboru ktoré vlastnosti sú viditeľné a ktoré nie.
Najprv sa pozrime na to, ako môže byť anotácia veľmi užitočná, na jednoduchom príklade; povolme serializáciu súkromných nehnuteľností:
@JsonAutoDetect (fieldVisibility = Visibility.ANY) verejná trieda PrivateBean {private int id; súkromné meno reťazca; }Potom test:
@Test public void whenSerializingUsingJsonAutoDetect_thenCorrect () hodí JsonProcessingException {PrivateBean bean = new PrivateBean (1, "My bean"); Výsledok reťazca = nový ObjectMapper () .writeValueAsString (fazuľa); assertThat (result, containsString ("1")); assertThat (result, containsString ("My bean")); }5. Poznámky k manipulácii s polymorfným typom Jacksona
Ďalej sa pozrime na Jacksonove polymorfné typy manipulačných anotácií:
- @JsonTypeInfo - označuje podrobnosti o tom, aké informácie o type majú byť zahrnuté do serializácie
- @JsonSubTypes - označuje podtypy anotovaného typu
- @JsonTypeName - definuje názov logického typu, ktorý sa má použiť pre anotovanú triedu
Pozrime sa na zložitejší príklad a využime všetky tri - @JsonTypeInfo, @JsonSubTypes, a @JsonTypeName - serializovať / deserializovať entitu Zoo:
verejná trieda Zoo {verejné Zvieracie zviera; @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")}) public static class Animal {public String name; } @JsonTypeName ("dog") verejná statická trieda Pes rozširuje zviera {public double barkVolume; } @JsonTypeName ("cat") verejná statická trieda Cat rozširuje Animal {boolean likesCream; verejné int životy; }}Keď urobíme serializáciu:
@ Test public void whenSerializingPolymorphic_thenCorrect () vyvolá JsonProcessingException {Zoo.Dog dog = nový Zoo.Dog ("čipkovaný"); Zoo zoo = new Zoo (dog); Výsledok reťazca = nový ObjectMapper () .writeValueAsString (zoo); assertThat (result, containsString ("type")); assertThat (result, containsString ("pes")); }Tu je pokračovanie Zoo napríklad s pes bude mať za následok:
{"animal": {"type": "dog", "name": "lacy", "barkVolume": 0}}Teraz k de-serializácii. Začnime s týmto vstupom JSON:
{"animal": {"name": "lacy", "type": "cat"}}Potom sa pozrime, ako sa to nespraví do a Zoo inštancia:
@ Test public void whenDeserializingPolymorphic_thenCorrect () vyvolá IOException {String json = "{\" animal \ ": {\" name \ ": \" lacy \ ", \" type \ ": \" mačka \ "}}" "; Zoo zoo = new ObjectMapper () .readerFor (Zoo.class) .readValue (json); assertEquals ("čipkované", zoo.animal.name); assertEquals (Zoo.Cat.class, zoo.animal.getClass ()); }6. Všeobecné poznámky Jacksona
Ďalej si povieme niečo o Jacksonových všeobecnejších anotáciách.
6.1. @JsonProperty
Môžeme pridať the @JsonProperty anotácia na označenie názvu vlastnosti v JSON.
Poďme použiť @JsonProperty serializovať / deserializovať vlastnosť názov keď máme do činenia s neštandardnými gettermi a settermi:
public class MyBean {public int id; súkromné meno reťazca; @JsonProperty ("meno") public void setTheName (názov reťazca) {this.name = meno; } @JsonProperty ("name") public String getTheName () {návratové meno; }}Ďalej nasleduje náš test:
@ Test public void whenUsingJsonProperty_thenCorrect () vyvolá IOException {MyBean bean = new MyBean (1, "My bean"); Výsledok reťazca = nový ObjectMapper (). WriteValueAsString (fazuľa); assertThat (result, containsString ("My bean")); assertThat (result, containsString ("1")); MyBean resultBean = nový ObjectMapper () .readerFor (MyBean.class) .readValue (výsledok); assertEquals ("Moja fazuľa", resultBean.getTheName ()); }6.2. @JsonFormat
The @JsonFormat anotácia určuje formát pri serializácii hodnôt dátumu a času.
V nasledujúcom príklade používame @JsonFormat na kontrolu formátu nehnuteľnosti dátum udalosti:
public class EventWithFormat {public Názov reťazca; @JsonFormat (shape = JsonFormat.Shape.STRING, pattern = "dd-MM-rrrr hh: mm: ss") public Date eventDate; }Potom je tu test:
@Test public void whenSerializingUsingJsonFormat_thenCorrect () hodí JsonProcessingException, ParseException {SimpleDateFormat df = new SimpleDateFormat ("dd-MM-rrrr hh: mm: ss"); df.setTimeZone (TimeZone.getTimeZone ("UTC")); String toParse = "20-12-2014 02:30:00"; Dátum dátum = df.parse (toParse); EventWithFormat event = nový EventWithFormat ("párty", dátum); Výsledok reťazca = nový ObjectMapper (). WriteValueAsString (udalosť); assertThat (result, containsString (toParse)); }6.3. @JsonUnwrapped
@JsonUnwrapped definuje hodnoty, ktoré by sa mali pri serializácii / deserializácii rozbaliť / zlúčiť.
Pozrime sa presne, ako to funguje; na rozbalenie vlastníctva použijeme anotáciu názov:
public class UnwrappedUser {public int id; @JsonUnwrapped public Meno meno; verejná statická trieda Názov {verejný reťazec meno; verejný reťazec priezvisko; }}Teraz poďme serializovať inštanciu tejto triedy:
@ Test public void whenSerializingUsingJsonUnwrapped_thenCorrect () vyvolá JsonProcessingException, ParseException {UnwrappedUser.Name name = new UnwrappedUser.Name ("John", "Doe"); UnwrappedUser user = nový UnwrappedUser (1, meno); Výsledok reťazca = nový ObjectMapper (). WriteValueAsString (užívateľ); assertThat (result, containsString ("John")); assertThat (výsledok, nie (containsString ("meno"))); }Nakoniec tu je výstup, ktorý vyzerá - polia statickej vnorenej triedy rozbalené spolu s druhým poľom:
{"id": 1, "firstName": "John", "lastName": "Doe"}6.4. @JsonView
@JsonView označuje Pohľad, v ktorom bude vlastnosť zahrnutá pre serializáciu / deserializáciu.
Napríklad použijeme @JsonView serializovať inštanciu Položka subjekt.
Najprv začnime s názormi:
public class Views {public static class Public {} public static class Internal extends Public {}}Ďalej je tu Položka entita používajúca zobrazenia:
public class Item {@JsonView (Views.Public.class) public int id; @JsonView (Views.Public.class) public String itemName; @JsonView (Views.Internal.class) public String ownerName; }Nakoniec celý test:
@ Test public void whenSerializingUsingJsonView_thenCorrect () hodí JsonProcessingException {Item item = new Item (2, "book", "John"); Výsledok reťazca = nový ObjectMapper () .writerWithView (Views.Public.class) .writeValueAsString (položka); assertThat (result, containsString ("kniha")); assertThat (result, containsString ("2")); assertThat (výsledok, nie (containsString ("John"))); }6.5. @JsonManagedReference, @JsonBackReference
The @JsonManagedReference a @JsonBackReference anotácie zvládnu vzťahy rodič - dieťa a obísť slučky.
V nasledujúcom príklade používame @JsonManagedReference a @JsonBackReference serializovať našu ItemWithRef subjekt:
verejná trieda ItemWithRef {public int id; public String itemName; @JsonManagedReference public UserWithRef vlastník; }Náš UserWithRef subjekt:
public class UserWithRef {public int id; verejné meno reťazca; @JsonBackReference verejný zoznam userItems; }Potom test:
@ Test public void whenSerializingUsingJacksonReferenceAnnotation_thenCorrect () hodí JsonProcessingException {UserWithRef user = new UserWithRef (1, "John"); ItemWithRef item = nový ItemWithRef (2, „kniha“, používateľ); user.addItem (položka); Výsledok reťazca = nový ObjectMapper (). WriteValueAsString (položka); assertThat (result, containsString ("kniha")); assertThat (result, containsString ("John")); assertThat (výsledok, nie (containsString ("userItems"))); }6.6. @JsonIdentityInfo
@JsonIdentityInfo naznačuje, že totožnosť objektu by sa mala použiť pri serializácii / deserializácii hodnôt, napríklad pri riešení typov problémov s nekonečnou rekurziou.
V nasledujúcom príklade máme ItemWithIdentity subjekt s obojsmerným vzťahom s UserWithIdentity subjekt:
@JsonIdentityInfo (generátor = ObjectIdGenerators.PropertyGenerator.class, property = "id") verejná trieda ItemWithIdentity {public int id; public String itemName; verejný vlastník UserWithIdentity; }The UserWithIdentity subjekt:
@JsonIdentityInfo (generátor = ObjectIdGenerators.PropertyGenerator.class, property = "id") verejná trieda UserWithIdentity {public int id; verejné meno reťazca; public List userItems; }Teraz Pozrime sa, ako je vyriešený problém s nekonečnou rekurziou:
@ Test public void whenSerializingUsingJsonIdentityInfo_thenCorrect () vyvolá JsonProcessingException {UserWithIdentity user = new UserWithIdentity (1, "John"); ItemWithIdentity item = nový ItemWithIdentity (2, „kniha“, používateľ); user.addItem (položka); Výsledok reťazca = nový ObjectMapper (). WriteValueAsString (položka); assertThat (result, containsString ("kniha")); assertThat (result, containsString ("John")); assertThat (result, containsString ("userItems")); }Tu je úplný výstup serializovanej položky a používateľa:
{"id": 2, "itemName": "book", "owner": {"id": 1, "name": "John", "userItems": [2]}}6.7. @JsonFilter
The @JsonFilter anotácia určuje filter, ktorý sa má použiť počas serializácie.
Najskôr definujeme entitu a ukážeme na filter:
@JsonFilter ("myFilter") verejná trieda BeanWithFilter {public int id; verejné meno reťazca; }Teraz v úplnom teste definujeme filter, ktorý vylučuje všetky ostatné vlastnosti okrem názov zo serializácie:
@Test public void whenSerializingUsingJsonFilter_thenCorrect () hodí JsonProcessingException {BeanWithFilter bean = new BeanWithFilter (1, "My bean"); FilterProvider filters = new SimpleFilterProvider (). AddFilter ("myFilter", SimpleBeanPropertyFilter.filterOutAllExcept ("name")); Výsledok reťazca = nový ObjectMapper () .writer (filtre) .writeValueAsString (fazuľa); assertThat (result, containsString ("My bean")); assertThat (result, not (containsString ("id"))); }7. Vlastná Jacksonova anotácia
Ďalej sa pozrime, ako vytvoriť vlastnú Jacksonovu anotáciu. Môžeme využiť @JacksonAnnotationsInside anotácia:
@Retention (RetentionPolicy.RUNTIME) @JacksonAnnotationsInside @JsonInclude (Include.NON_NULL) @JsonPropertyOrder ({"name", "id", "dateCreated"}) public @interface CustomAnnotation {}Teraz, ak použijeme novú anotáciu na entitu:
@CustomAnnotation verejná trieda BeanWithCustomAnnotation {public int id; verejné meno reťazca; verejné Dátum dátum Vytvorené; }Vidíme, ako kombinuje existujúce anotácie do jednoduchej vlastnej, ktorú môžeme použiť ako skratku:
@Test public void whenSerializingUsingCustomAnnotation_thenCorrect () hodí JsonProcessingException {BeanWithCustomAnnotation bean = new BeanWithCustomAnnotation (1, "My bean", null); Výsledok reťazca = nový ObjectMapper (). WriteValueAsString (fazuľa); assertThat (result, containsString ("My bean")); assertThat (result, containsString ("1")); assertThat (result, not (containsString ("dateCreated"))); }Výstup procesu serializácie:
{"name": "My bean", "id": 1}8. Jackson MixIn Anotácie
Ďalej sa pozrieme, ako používať anotácie Jackson MixIn.
Použijme napríklad anotácie MixIn na ignorovanie vlastností typu Používateľ:
public class Item {public int id; public String itemName; verejný vlastník používateľa; }@JsonIgnoreType verejná trieda MyMixInForIgnoreType {}Potom sa pozrime na toto:
@ Test public void whenSerializingUsingMixInAnnotation_thenCorrect () hodí JsonProcessingException {Item item = new Item (1, "book", null); Výsledok reťazca = nový ObjectMapper (). WriteValueAsString (položka); assertThat (result, containsString ("owner")); ObjectMapper mapovač = nový ObjectMapper (); mapper.addMixIn (User.class, MyMixInForIgnoreType.class); result = mapper.writeValueAsString (položka); assertThat (výsledok, nie (containsString ("vlastník"))); }9. Zakážte Jacksonovu anotáciu
Nakoniec sa pozrime, ako môžeme vypnúť všetky Jacksonove anotácie. Môžeme to urobiť deaktiváciou Funkcia Mapper.USE_ANNOTATIONS ako v nasledujúcom príklade:
@JsonInclude (Include.NON_NULL) @JsonPropertyOrder ({"name", "id"}) verejná trieda MyBean {public int id; verejné meno reťazca; }Teraz by po deaktivácii anotácií nemali mať žiadny účinok a mali by sa použiť predvolené hodnoty knižnice:
@ Test public void whenDisablingAllAnnotations_thenAllDisabled () vyvolá IOException {MyBean bean = new MyBean (1, null); ObjectMapper mapovač = nový ObjectMapper (); mapper.disable (MapperFeature.USE_ANNOTATIONS); Výsledok reťazca = mapper.writeValueAsString (fazuľa); assertThat (result, containsString ("1")); assertThat (result, containsString ("name")); }Výsledok serializácie pred zakázaním anotácií:
{"id": 1}Výsledok serializácie po vypnutí anotácií:
{"id": 1, "name": null}10. Záver
V tomto článku sme skúmali Jacksonove anotácie, len sme poškriabali povrch takej flexibility, ktorú môžeme získať ich správnym použitím.
Implementáciu všetkých týchto príkladov a útržkov kódu nájdete na GitHub.
