Eksempler på Jackson-merknader

1. Oversikt

I denne opplæringen vil vi gjøre et dypt dykk inn i Jackson-merknader.

Vi får se hvordan du bruker de eksisterende kommentarene, hvordan du lager tilpassede, og til slutt hvordan du deaktiverer dem.

2. Jackson Serialization Annotations

Først tar vi en titt på serialiseringsnotatene.

2.1. @JsonAnyGetter

De @JsonAnyGetter kommentar muliggjør fleksibiliteten ved å bruke en Kart felt som standardegenskaper.

For eksempel ExtendableBean enhet har Navn eiendom og et sett med utvidbare attributter i form av nøkkel / verdipar:

offentlig klasse ExtendableBean {offentlig strengnavn; private Kart-eiendommer; @JsonAnyGetter offentlig kart getProperties () {return egenskaper; }}

Når vi serierer en forekomst av denne enheten, får vi alle nøkkelverdiene i Kart som standard, enkle egenskaper:

{"name": "Min bønne", "attr2": "val2", "attr1": "val1"}

Slik ser serialiseringen av denne enheten ut i praksis:

@Test offentlig ugyldig nårSerializingUsingJsonAnyGetter_thenCorrect () kaster JsonProcessingException {ExtendableBean bean = new ExtendableBean ("My bean"); bean.add ("attr1", "val1"); bean.add ("attr2", "val2"); String result = new ObjectMapper (). WriteValueAsString (bean); assertThat (resultat, inneholderString ("attr1")); assertThat (resultat, inneholderString ("val1")); }

Vi kan også bruke det valgfrie argumentet aktivert som falsk å deaktivere @JsonAnyGetter (). I dette tilfellet Kart vil bli konvertert som JSON og vises under eiendommer variabel etter serialisering.

2.2. @JsonGetter

De @JsonGetter kommentar er et alternativ til @JsonProperty kommentar, som markerer en metode som en getter-metode.

I det følgende eksemplet spesifiserer vi metoden getTheName () som getter-metoden til Navn eiendommen til en MyBean enhet:

offentlig klasse MyBean {public int id; privat strengnavn; @JsonGetter ("navn") offentlig streng getTheName () {returnavn; }}

Slik fungerer dette i praksis:

@Test offentlig annullert nårSerializingUsingJsonGetter_thenCorrect () kaster JsonProcessingException {MyBean bean = new MyBean (1, "My bean"); String result = new ObjectMapper (). WriteValueAsString (bean); assertThat (resultat, inneholderString ("Min bønne")); assertThat (resultat, inneholderString ("1")); }

2.3. @JsonPropertyOrder

Vi kan bruke @JsonPropertyOrder kommentar å spesifisere rekkefølgen på egenskaper ved serialisering.

La oss angi en tilpasset rekkefølge for egenskapene til a MyBean enhet:

@JsonPropertyOrder ({"name", "id"}) offentlig klasse MyBean {public int id; offentlig streng navn; }

Her er resultatet av serialisering:

{"name": "Min bønne", "id": 1}

Så kan vi gjøre en enkel test:

@Test offentlig ugyldig nårSerializingUsingJsonPropertyOrder_thenCorrect () kaster JsonProcessingException {MyBean bean = new MyBean (1, "My bean"); String result = new ObjectMapper (). WriteValueAsString (bean); assertThat (resultat, inneholderString ("Min bønne")); assertThat (resultat, inneholderString ("1")); }

Vi kan også bruke @JsonPropertyOrder (alfabetisk = sann) for å bestille egenskapene alfabetisk. I så fall vil produksjonen av serialisering være:

{"id": 1, "name": "Min bønne"}

2.4. @JsonRawValue

De @JsonRawValue kommentar kan instruere Jackson om å serieisere en eiendom akkurat som den er.

I det følgende eksemplet bruker vi @JsonRawValue å legge inn noen tilpassede JSON som en verdi av en enhet:

offentlig klasse RawBean {offentlig strengnavn; @JsonRawValue public String json; }

Resultatet av serialisering av enheten er:

{"name": "My bean", "json": {"attr": false}}

Neste her er en enkel test:

@Test offentlig ugyldig nårSerializingUsingJsonRawValue_thenCorrect () kaster JsonProcessingException {RawBean bean = new RawBean ("My bean", "{\" attr \ ": false}"); String result = new ObjectMapper (). WriteValueAsString (bean); assertThat (resultat, inneholderString ("Min bønne")); assertThat (resultat, inneholderString ("{\" attr \ ": false}")); }

Vi kan også bruke det valgfrie boolske argumentet verdi som definerer om denne kommentaren er aktiv eller ikke.

2.5. @JsonValue

@JsonValue indikerer en enkelt metode som biblioteket vil bruke til å serieisere hele forekomsten.

For eksempel, i en enum, kommenterer vi getName med @JsonValue slik at en slik enhet blir seriellisert via navnet:

offentlig enum TypeEnumWithValue {TYPE1 (1, "Type A"), TYPE2 (2, "Type 2"); privat Heltall-id; privat strengnavn; // standardkonstruktører @JsonValue public String getName () {return name; }}

Her er testen vår:

@Test offentlig ugyldig nårSerializingUsingJsonValue_thenCorrect () kaster JsonParseException, IOException {String enumAsString = ny ObjectMapper () .writeValueAsString (TypeEnumWithValue.TYPE1); assertThat (enumAsString, er ("" Type A "")); }

2.6. @JsonRootName

De @JsonRootName merknad brukes, hvis innpakning er aktivert, for å spesifisere navnet på rotinnpakningen som skal brukes.

Innpakning betyr at i stedet for å serieisere en Bruker til noe sånt som:

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

Det kommer til å bli pakket inn slik:

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

Så la oss se på et eksempel. WJeg skal bruke @JsonRootName kommentar for å indikere navnet på denne potensielle innpakningsenheten:

@JsonRootName (value = "user") offentlig klasse UserWithRoot {public int id; offentlig streng navn; }

Som standard vil navnet på innpakningen være navnet på klassen - UserWithRoot. Ved å bruke kommentaren får vi renere ut bruker:

@Test offentlig ugyldig nårSerializingUsingJsonRootName_thenCorrect () kaster JsonProcessingException {UserWithRoot bruker = ny bruker (1, "John"); ObjectMapper mapper = ny ObjectMapper (); mapper.enable (SerializationFeature.WRAP_ROOT_VALUE); Strengresultat = mapper.writeValueAsString (bruker); assertThat (resultat, inneholderString ("John")); assertThat (resultat, inneholderString ("bruker")); }

Her er resultatet av serialisering:

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

Siden Jackson 2.4, et nytt valgfritt argument navneområdet er tilgjengelig for bruk med dataformater som XML. Hvis vi legger til det, blir det en del av det fullstendige navnet:

@JsonRootName (verdi = "bruker", namespace = "brukere") offentlig klasse UserWithRootNamespace {public int id; offentlig streng navn; // ...}

Hvis vi serierer det med XmlMapper, utgangen vil være:

 1. Johannes 

2.7. @JsonSerialize

@JsonSerialize angir en egendefinert serialisering som skal brukes når marshalling enheten.

La oss se på et raskt eksempel. Vi skal bruke @JsonSerialize å serieisere hendelsesdato eiendom med en CustomDateSerializer:

offentlig klasse EventWithSerializer {offentlig navn på streng; @JsonSerialize (bruker = CustomDateSerializer.class) offentlig dato eventDate; }

Her er den enkle tilpassede Jackson-serien:

offentlig klasse CustomDateSerializer utvider StdSerializer {privat statisk SimpleDateFormat formatter = ny SimpleDateFormat ("dd-MM-åååå hh: mm: ss"); offentlig CustomDateSerializer () {dette (null); } offentlig CustomDateSerializer (klasse t) {super (t); } @Override public void serialize (Date value, JsonGenerator gen, SerializerProvider arg2) kaster IOException, JsonProcessingException {gen.writeString (formatter.format (verdi)); }}

La oss nå bruke disse i en test:

@Test offentlig ugyldig nårSerializingUsingJsonSerialize_thenCorrect () kaster JsonProcessingException, ParseException {SimpleDateFormat df = new SimpleDateFormat ("dd-MM-åååå hh: mm: ss"); String toParse = "20-12-2014 02:30:00"; Dato dato = df.parse (toParse); EventWithSerializer event = new EventWithSerializer ("fest", dato); String result = new ObjectMapper (). WriteValueAsString (event); assertThat (resultat, inneholderString (toParse)); }

3. Kommentarer fra Jackson Deserialization

La oss deretter utforske Jackson-deserialiseringsanmerkelsene.

3.1. @JsonCreator

Vi kan bruke @JsonCreator kommentar for å stille inn konstruktøren / fabrikken som brukes i deserialisering.

Det er veldig nyttig når vi trenger å deserialisere noen JSON som ikke stemmer overens med målenheten vi trenger å få.

La oss se på et eksempel. Si at vi må deserialisere følgende JSON:

{"id": 1, "theName": "Min bønne"}

Det er imidlertid ingen navnet felt i vår målenhet, er det bare et Navn felt. Nå ønsker vi ikke å endre selve enheten, vi trenger bare litt mer kontroll over unmarshalling-prosessen ved å kommentere konstruktøren med @JsonCreator, og bruke @JsonProperty kommentar også:

offentlig klasse BeanWithCreator {offentlig int id; offentlig streng navn; @JsonCreator public BeanWithCreator (@JsonProperty ("id") int id, @JsonProperty ("theName") Strengnavn) {this.id = id; this.name = navn; }}

La oss se dette i aksjon:

@Test offentlig ugyldig nårDeserializingUsingJsonCreator_thenCorrect () kaster IOException {String json = "{\" id \ ": 1, \" theName \ ": \" My bean \ "}"; BeanWithCreator bean = new ObjectMapper () .readerFor (BeanWithCreator.class) .readValue (json); assertEquals ("My bean", bean.name); }

3.2. @JacksonInject

@JacksonInject indikerer at en eiendom får verdien fra injeksjonen og ikke fra JSON-dataene.

I det følgende eksemplet bruker vi @JacksonInject å injisere eiendommen id:

offentlig klasse BeanWithInject {@JacksonInject offentlig int id; offentlig streng navn; }

Slik fungerer det:

@Test offentlig ugyldig nårDeserializingUsingJsonInject_thenCorrect () kaster IOException {String json = "{\" name \ ": \" My bean \ "}"; InjectableValues ​​inject = new InjectableValues.Std () .addValue (int.class, 1); BeanWithInject bean = ny ObjectMapper (). Leser (injiser). ForType (BeanWithInject.class) .readValue (json); assertEquals ("My bean", bean.name); assertEquals (1, bean.id); }

3.3. @JsonAnySetter

@JsonAnySetter gir oss fleksibiliteten til å bruke en Kart som standardegenskaper. Ved deserialisering vil egenskapene fra JSON ganske enkelt legges til på kartet.

Først skal vi bruke @JsonAnySetter å deserialisere enheten ExtendableBean:

offentlig klasse ExtendableBean {offentlig strengnavn; private Kart-eiendommer; @JsonAnySetter public void add (strengnøkkel, strengverdi) {egenskaper.put (nøkkel, verdi); }}

Dette er JSON vi trenger å deserialisere:

{"name": "Min bønne", "attr2": "val2", "attr1": "val1"}

Så her er hvordan det hele henger sammen:

@Test offentlig ugyldig nårDeserializingUsingJsonAnySetter_thenCorrect () kaster IOException {String json = "{\" name \ ": \" Min bønne \ ", \" attr2 \ ": \" val2 \ ", \" attr1 \ ": \" val1 \ "}"; ExtendableBean bean = ny ObjectMapper () .readerFor (ExtendableBean.class) .readValue (json); assertEquals ("My bean", bean.name); assertEquals ("val2", bean.getProperties (). get ("attr2")); }

3.4. @JsonSetter

@JsonSetter er et alternativ til @JsonProperty som markerer metoden som en settermetode.

Dette er utrolig nyttig når vi trenger å lese noen JSON-data, men målenhetsklassen samsvarer ikke akkurat med dataene, og derfor må vi justere prosessen slik at den passer.

I det følgende eksemplet spesifiserer vi metoden setTheName () som setter av Navn eiendom i vår MyBean enhet:

offentlig klasse MyBean {public int id; privat strengnavn; @JsonSetter ("name") public void setTheName (String name) {this.name = name; }}

Nå når vi trenger å fjerne markeringen på noen JSON-data, fungerer dette perfekt:

@Test offentlig ugyldig nårDeserializingUsingJsonSetter_thenCorrect () kaster IOException {String json = "{\" id \ ": 1, \" name \ ": \" My bean \ "}"; MyBean bønne = ny ObjectMapper () .readerFor (MyBean.class) .readValue (json); assertEquals ("My bean", bean.getTheName ()); }

3.5. @JsonDeserialize

@JsonDeserialize angir bruken av en tilpasset deserializer.

Først skal vi bruke @JsonDeserialize å deserialisere hendelsesdato eiendom med CustomDateDeserializer:

public class EventWithSerializer {public String name; @JsonDeserialize (ved hjelp av = CustomDateDeserializer.class) offentlig dato eventDate; }

Her er den tilpassede deserializer:

offentlig klasse CustomDateDeserializer utvider StdDeserializer {privat statisk SimpleDateFormat formatter = ny SimpleDateFormat ("dd-MM-åååå hh: mm: ss"); offentlig CustomDateDeserializer () {dette (null); } offentlig CustomDateDeserializer (klasse vc) {super (vc); } @ Override public Date deserialize (JsonParser jsonparser, DeserializationContext context) kaster IOException {String date = jsonparser.getText (); prøv {return formatter.parse (dato); } fange (ParseException e) {kaste ny RuntimeException (e); }}}

Neste her er rygg-til-rygg-testen:

@Test offentlig ugyldig nårDeserializingUsingJsonDeserialize_thenCorrect () kaster IOException {String json = "{" name ":" party "," eventDate ":" 20-12-2014 02:30:00 "}"; SimpleDateFormat df = ny SimpleDateFormat ("dd-MM-åååå hh: mm: ss"); EventWithSerializer event = new ObjectMapper () .readerFor (EventWithSerializer.class) .readValue (json); assertEquals ("20-12-2014 02:30:00", df.format (event.eventDate)); }

3.6. @JsonAlias

De @JsonAlias definerer ett eller flere alternative navn for en eiendom under deserialisering.

La oss se hvordan denne kommentaren fungerer med et raskt eksempel:

offentlig klasse AliasBean {@JsonAlias ​​({"fName", "f_name"}) privat streng fornavn; privat streng etternavn; }

Her har vi en POJO, og vi ønsker å deserialisere JSON med verdier som fnavn, f_name, og fornavn inn i det fornavn variabel av POJO.

Nedenfor er en test som sørger for at denne kommentaren fungerer som forventet:

@Test offentlig ugyldig nårDeserializingUsingJsonAlias_thenCorrect () kaster IOException {String json = "{\" fName \ ": \" John \ ", \" lastName \ ": \" Green \ "}"; AliasBean aliasBean = ny ObjectMapper (). ReaderFor (AliasBean.class) .readValue (json); assertEquals ("John", aliasBean.getFirstName ()); }

4. Merknader om inkludering av Jackson Property

4.1. @JsonIgnoreProperties

@JsonIgnoreProperties er en merknad på klassenivå som markerer en eiendom eller en liste over egenskaper som Jackson vil ignorere.

La oss se på et raskt eksempel som ignorerer eiendommen id fra serialisering:

@JsonIgnoreProperties ({"id"}) offentlig klasse BeanWithIgnore {public int id; offentlig streng navn; }

Nå er testen som gjør at ignorering skjer:

@Test offentlig ugyldig nårSerializingUsingJsonIgnoreProperties_thenCorrect () kaster JsonProcessingException {BeanWithIgnore bean = new BeanWithIgnore (1, "My bean"); String result = new ObjectMapper () .writeValueAsString (bean); assertThat (resultat, inneholderString ("Min bønne")); assertThat (resultat, ikke (inneholderString ("id"))); }

For å ignorere ukjente egenskaper i JSON-inngang uten unntak, kan vi angi ignoreUnknown = sant av @JsonIgnoreProperties kommentar.

4.2. @JsonIgnore

I kontrast, den @JsonIgnore merknader brukes til å markere en egenskap som skal ignoreres på feltnivå.

La oss bruke @JsonIgnore å ignorere eiendommen id fra serialisering:

offentlig klasse BeanWithIgnore {@JsonIgnorer offentlig int id; offentlig streng navn; }

Så skal vi teste for å sikre at det id ble ignorert:

@Test offentlig ugyldig nårSerializingUsingJsonIgnore_thenCorrect () kaster JsonProcessingException {BeanWithIgnore bean = new BeanWithIgnore (1, "My bean"); String result = new ObjectMapper () .writeValueAsString (bean); assertThat (resultat, inneholderString ("Min bønne")); assertThat (resultat, ikke (inneholderString ("id"))); }

4.3. @JsonIgnoreType

@JsonIgnoreType markerer alle egenskapene til en kommentert type som skal ignoreres.

Vi kan bruke merknaden til å merke alle egenskapene av typen Navn å bli ignorert:

public class User {public int id; offentlig navn navn; @JsonIgnoreType offentlig statisk klasse Navn {offentlig streng fornavn; offentlig strengnavn; }}

Vi kan også teste for å sikre at ignorering fungerer riktig:

@Test offentlig ugyldig når SerializingUsingJsonIgnoreType_thenCorrect () kaster JsonProcessingException, ParseException {User.Name name = new User.Name ("John", "Doe"); Brukerbruker = ny bruker (1, navn); Strengresultat = ny ObjectMapper () .writeValueAsString (bruker); assertThat (resultat, inneholderString ("1")); assertThat (resultat, ikke (inneholderString ("navn"))); assertThat (resultat, ikke (inneholderString ("John"))); }

4.4. @JsonInclude

Vi kan bruke @JsonInclude for å ekskludere egenskaper med tomme / null / standardverdier.

La oss se på et eksempel som ekskluderer null fra serialisering:

@JsonInclude (Include.NON_NULL) offentlig klasse MyBean {public int id; offentlig streng navn; }

Her er hele testen:

offentlig ugyldig nårSerializingUsingJsonInclude_thenCorrect () kaster JsonProcessingException {MyBean bean = new MyBean (1, null); String result = new ObjectMapper () .writeValueAsString (bean); assertThat (resultat, inneholderString ("1")); assertThat (resultat, ikke (inneholderString ("navn"))); }

4.5. @JsonAutoDetect

@JsonAutoDetect kan overstyre standard semantikken til hvilke egenskaper som er synlige og hvilke som ikke er.

La oss først se på hvordan merknaden kan være veldig nyttig med et enkelt eksempel; la oss aktivere serialisering av private egenskaper:

@JsonAutoDetect (fieldVisibility = Visibility.ANY) offentlig klasse PrivateBean {privat int id; privat strengnavn; }

Så testen:

@Test offentlig ugyldig nårSerializingUsingJsonAutoDetect_thenCorrect () kaster JsonProcessingException {PrivateBean bean = new PrivateBean (1, "My bean"); String result = new ObjectMapper () .writeValueAsString (bean); assertThat (resultat, inneholderString ("1")); assertThat (resultat, inneholderString ("Min bønne")); }

5. Kommentarer om Jackson Polymorf Type Handling

La oss deretter ta en titt på Jackson polymorfe typebehandlingskommentarer:

  • @JsonTypeInfo - angir detaljer om hvilken type informasjon som skal inkluderes i serialisering
  • @JsonSubTypes - indikerer undertyper av den merkede typen
  • @JsonTypeName - definerer et logisk typenavn som skal brukes til merket klasse

La oss undersøke et mer komplekst eksempel, og bruke alle tre - @JsonTypeInfo, @JsonSubTypes, og @JsonTypeName - å serieisere / deserialisere enheten dyrehage:

offentlig klasse Zoo {offentlig Dyredyr; @JsonTypeInfo (use = JsonTypeInfo.Id.NAME, include = As.PROPERTY, property = "type") @JsonSubTypes ({@ JsonSubTypes.Type (value = Dog.class, name = "dog"), @ JsonSubTypes.Type ( verdi = Cat.class, name = "cat")}) offentlig statisk klasse Animal {public String name; } @JsonTypeName ("dog") offentlig statisk klasse Dog utvider Animal {public double barkVolume; } @JsonTypeName ("cat") offentlig statisk klasse Cat extends Animal {boolean likesCream; offentlige liv; }}

Når vi gjør serialisering:

@Test offentlig ugyldig nårSerializingPolymorphic_thenCorrect () kaster JsonProcessingException {Zoo.Dog dog = new Zoo.Dog ("lacy"); Zoo zoo = ny Zoo (hund); String result = new ObjectMapper () .writeValueAsString (zoo); assertThat (resultat, inneholderString ("type")); assertThat (resultat, inneholderString ("hund")); }

Her er hva serialisering av dyrehage eksempel med Hund vil resultere i:

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

Nå for avserialisering. La oss starte med følgende JSON-inngang:

{"animal": {"name": "lacy", "type": "cat"}}

Så la oss se hvordan det blir unmarshalled til en dyrehage forekomst:

@Test offentlig ugyldig nårDeserializingPolymorphic_thenCorrect () kaster IOException {String json = "{\" animal \ ": {\" name \ ": \" lacy \ ", \" type \ ": \" cat \ "}}"; Zoo zoo = new ObjectMapper () .readerFor (Zoo.class) .readValue (json); assertEquals ("lacy", zoo.animal.name); assertEquals (Zoo.Cat.class, zoo.animal.getClass ()); }

6. Jackson generelle merknader

La oss nå diskutere noen av Jacksons mer generelle kommentarer.

6.1. @JsonProperty

Vi kan legge til de @JsonProperty kommentar for å indikere eiendomsnavnet i JSON.

La oss bruke @JsonProperty å serieisere / deserialisere eiendommen Navn når vi har med ikke-standardiserte getters og settere å gjøre:

offentlig klasse MyBean {public int id; privat strengnavn; @JsonProperty ("name") public void setTheName (String name) {this.name = name; } @JsonProperty ("navn") offentlig streng getTheName () {returnavn; }}

Neste er testen vår:

@Test offentlig ugyldig nårUsingJsonProperty_thenCorrect () kaster IOException {MyBean bean = new MyBean (1, "My bean"); String result = new ObjectMapper (). WriteValueAsString (bean); assertThat (resultat, inneholderString ("Min bønne")); assertThat (resultat, inneholderString ("1")); MyBean resultBean = ny ObjectMapper () .readerFor (MyBean.class) .readValue (resultat); assertEquals ("My bean", resultBean.getTheName ()); }

6.2. @JsonFormat

De @JsonFormat kommentar spesifiserer et format når du serierer dato- / tidsverdier.

I det følgende eksemplet bruker vi @JsonFormat for å kontrollere formatet på eiendommen hendelsesdato:

offentlig klasse EventWithFormat {offentlig strengnavn; @JsonFormat (form = JsonFormat.Shape.STRING, mønster = "dd-MM-åååå tt: mm: ss") offentlig Dato eventDate; }

Så her er testen:

@Test offentlig ugyldig nårSerializingUsingJsonFormat_thenCorrect () kaster JsonProcessingException, ParseException {SimpleDateFormat df = ny SimpleDateFormat ("dd-MM-åååå hh: mm: ss"); df.setTimeZone (TimeZone.getTimeZone ("UTC")); String toParse = "20-12-2014 02:30:00"; Dato dato = df.parse (toParse); EventWithFormat event = new EventWithFormat ("party", date); String result = new ObjectMapper (). WriteValueAsString (event); assertThat (resultat, inneholderString (toParse)); }

6.3. @JsonUnwrapped

@JsonUnpakkede definerer verdier som skal pakkes ut / flates når de er serialisert / deserialisert.

La oss se nøyaktig hvordan dette fungerer; vi bruker merknaden for å pakke ut eiendommen Navn:

offentlig klasse UnwrappedUser {public int id; @JsonUnpakkede offentlige navn navn; offentlig statisk klasse Navn {offentlig streng fornavn; offentlig strengnavn; }}

La oss nå serieisere en forekomst av denne klassen:

@Test offentlig ugyldig nårSerializingUsingJsonUnwrapped_thenCorrect () kaster JsonProcessingException, ParseException {UnwrappedUser.Name name = new UnwrappedUser.Name ("John", "Doe"); UnwrappedUser user = new UnwrappedUser (1, name); Strengresultat = ny ObjectMapper (). WriteValueAsString (bruker); assertThat (resultat, inneholderString ("John")); assertThat (resultat, ikke (inneholderString ("navn"))); }

Til slutt, her er hvordan utgangen ser ut - feltene i den statiske nestede klassen pakket sammen med det andre feltet:

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

6.4. @JsonView

@JsonView indikerer visningen der eiendommen skal inkluderes for serialisering / deserialisering.

For eksempel vil vi bruke @JsonView å serieisere en forekomst av Punkt enhet.

Først, la oss starte med visningene:

offentlig klasse Visninger {offentlig statisk klasse Offentlig {} offentlig statisk klasse Internt utvider Offentlig {}}

Neste her er Punkt enhet som bruker utsikten:

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

Til slutt full test:

@Test offentlig ugyldig nårSerializingUsingJsonView_thenCorrect () kaster JsonProcessingException {Item item = new Item (2, "book", "John"); String result = new ObjectMapper () .writerWithView (Views.Public.class) .writeValueAsString (item); assertThat (resultat, inneholderString ("bok")); assertThat (resultat, inneholderString ("2")); assertThat (resultat, ikke (inneholderString ("John"))); }

6.5. @JsonManagedReference, @JsonBackReference

De @JsonManagedReference og @JsonBackReference merknader kan håndtere foreldre / barn-forhold og arbeid rundt løkker.

I det følgende eksemplet bruker vi @JsonManagedReference og @JsonBackReference å serieisere vår VareMedRef enhet:

offentlig klasse ItemWithRef {public int id; offentlig streng elementnavn; @JsonManagedReference offentlig UserWithRef-eier; }

Våre UserWithRef enhet:

offentlig klasse UserWithRef {public int id; offentlig streng navn; @JsonBackReference offentlig Liste userItems; }

Så testen:

@Test offentlig ugyldig nårSerializingUsingJacksonReferenceAnnotation_thenCorrect () kaster JsonProcessingException {UserWithRef bruker = ny UserWithRef (1, "John"); ItemWithRef item = new ItemWithRef (2, "book", user); user.addItem (element); String result = new ObjectMapper (). WriteValueAsString (item); assertThat (resultat, inneholderString ("bok")); assertThat (resultat, inneholderString ("John")); assertThat (resultat, ikke (inneholderString ("userItems"))); }

6.6. @JsonIdentityInfo

@JsonIdentityInfo indikerer at Object Identity skal brukes når du serialiserer / deserialiserer verdier, for eksempel når du arbeider med uendelige rekursjonstyper av problemer.

I det følgende eksemplet har vi en ItemWithIdentity enhet med toveis forhold til UserWithIdentity enhet:

@JsonIdentityInfo (generator = ObjectIdGenerators.PropertyGenerator.class, property = "id") offentlig klasse ItemWithIdentity {public int id; offentlig streng elementnavn; offentlig UserWithIdentity-eier; }

De UserWithIdentity enhet:

@JsonIdentityInfo (generator = ObjectIdGenerators.PropertyGenerator.class, property = "id") offentlig klasse UserWithIdentity {public int id; offentlig streng navn; public List userItems; }

la oss se hvordan det uendelige rekursjonsproblemet blir håndtert:

@Test offentlig ugyldig når SerializingUsingJsonIdentityInfo_thenCorrect () kaster JsonProcessingException {UserWithIdentity bruker = ny UserWithIdentity (1, "John"); ItemWithIdentity item = new ItemWithIdentity (2, "bok", bruker); user.addItem (vare); String result = new ObjectMapper (). WriteValueAsString (item); assertThat (resultat, inneholderString ("bok")); assertThat (resultat, inneholderString ("John")); assertThat (resultat, containString ("userItems")); }

Her er den fullstendige utgangen av det serielle elementet og brukeren:

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

6.7. @JsonFilter

De @JsonFilter kommentar angir et filter som skal brukes under serialisering.

Først definerer vi enheten, og vi peker på filteret:

@JsonFilter ("myFilter") offentlig klasse BeanWithFilter {public int id; offentlig streng navn; }

Nå i full test definerer vi filteret, som ekskluderer alle andre egenskaper unntatt Navn fra serialisering:

@Test offentlig ugyldig nårSerializingUsingJsonFilter_thenCorrect () kaster JsonProcessingException {BeanWithFilter bean = new BeanWithFilter (1, "My bean"); FilterProvider filters = new SimpleFilterProvider (). AddFilter ("myFilter", SimpleBeanPropertyFilter.filterOutAllExcept ("name")); String result = new ObjectMapper () .writer (filters) .writeValueAsString (bean); assertThat (resultat, inneholderString ("Min bønne")); assertThat (resultat, ikke (inneholderString ("id"))); }

7. Egendefinert Jackson-merknad

La oss deretter se hvordan du lager en tilpasset Jackson-kommentar. Vi kan benytte oss av @JacksonAnnotationsInside kommentar:

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

Nå hvis vi bruker den nye kommentaren på en enhet:

@CustomAnnotation offentlig klasse BeanWithCustomAnnotation {public int id; offentlig streng navn; offentlig Dato dato Opprettet; }

Vi kan se hvordan den kombinerer eksisterende merknader til en enkel tilpasset en som vi kan bruke som en stenografi:

@Test offentlig ugyldig nårSerializingUsingCustomAnnotation_thenCorrect () kaster JsonProcessingException {BeanWithCustomAnnotation bean = new BeanWithCustomAnnotation (1, "My bean", null); String result = new ObjectMapper (). WriteValueAsString (bean); assertThat (resultat, inneholderString ("Min bønne")); assertThat (resultat, inneholderString ("1")); assertThat (resultat, ikke (inneholderString ("dateCreated"))); }

Produksjonen av serieiseringsprosessen

{"name": "Min bønne", "id": 1}

8. Jackson MixIn-merknader

La oss deretter se hvordan du bruker Jackson MixIn-merknader.

La oss for eksempel bruke MixIn-merknadene for å ignorere egenskapene av typen Bruker:

public class Item {public int id; offentlig streng elementnavn; offentlig bruker eier; }
@JsonIgnoreType offentlig klasse MyMixInForIgnoreType {}

La oss så se dette i aksjon:

@Test offentlig ugyldig nårSerializingUsingMixInAnnotation_thenCorrect () kaster JsonProcessingException {Item item = new Item (1, "book", null); String result = new ObjectMapper (). WriteValueAsString (item); assertThat (resultat, inneholderString ("eier")); ObjectMapper mapper = ny ObjectMapper (); mapper.addMixIn (User.class, MyMixInForIgnoreType.class); resultat = mapper.writeValueAsString (element); assertThat (resultat, ikke (inneholderString ("eier"))); }

9. Deaktiver Jackson-merknader

Til slutt, la oss se hvordan vi kan deaktiver alle Jackson-merknader. Vi kan gjøre dette ved å deaktivere MapperFunksjon.USE_ANNOTATIONS som i følgende eksempel:

@JsonInclude (Include.NON_NULL) @JsonPropertyOrder ({"name", "id"}) offentlig klasse MyBean {public int id; offentlig streng navn; }

Nå, etter å ha deaktivert merknader, skal disse ikke ha noen effekt, og standardinnstillingene for biblioteket skal gjelde:

@Test offentlig ugyldig nårDisablingAllAnnotations_thenAllDisabled () kaster IOException {MyBean bean = new MyBean (1, null); ObjectMapper mapper = ny ObjectMapper (); mapper.disable (MapperFeature.USE_ANNOTATIONS); Strengresultat = mapper.writeValueAsString (bønne); assertThat (resultat, inneholderString ("1")); assertThat (resultat, inneholderString ("navn")); }

Resultatet av serialisering før annoteringer deaktiveres:

{"id": 1}

Resultatet av serialisering etter deaktivering av merknader:

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

10. Konklusjon

I denne artikkelen undersøkte vi Jackson-merknader, bare skrape overflaten av den typen fleksibilitet vi kan få ved å bruke dem riktig.

Implementeringen av alle disse eksemplene og kodebiter finner du på GitHub.


$config[zx-auto] not found$config[zx-overlay] not found