Eksempler på Jackson Annotation
1. Oversigt
I denne vejledning foretager vi et dybt dyk ind i Jackson-kommentarer.
Vi ser, hvordan man bruger de eksisterende kommentarer, hvordan man opretter tilpassede, og endelig, hvordan man deaktiverer dem.
2. Kommentarer om Jackson-serialisering
Først skal vi se på serialiseringsanmærkningerne.
2.1. @JsonAnyGetter
Det @JsonAnyGetter annotering muliggør fleksibiliteten ved at bruge en Kort felt som standardegenskaber.
F.eks ExtendableBean enhed har navn egenskab og et sæt udvidelige attributter i form af nøgle / værdipar:
offentlig klasse ExtendableBean {public String name; private kortegenskaber; @JsonAnyGetter offentligt kort getProperties () {return egenskaber; }}Når vi serieliserer en forekomst af denne enhed, får vi alle nøgleværdierne i Kort som standard, almindelige egenskaber:
{"name": "Min bønne", "attr2": "val2", "attr1": "val1"}Sådan ser serialiseringen af denne enhed ud 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, indeholderString ("attr1")); assertThat (resultat, indeholderString ("val1")); }Vi kan også bruge det valgfri argument aktiveret som falsk at deaktivere @JsonAnyGetter (). I dette tilfælde er Kort vil blive konverteret som JSON og vises under ejendomme variabel efter serialisering.
2.2. @JsonGetter
Det @JsonGetter kommentar er et alternativ til @JsonProperty annotation, som markerer en metode som en getter-metode.
I det følgende eksempel specificerer vi metoden getTheName () som getter-metoden til navn ejendom af en MyBean enhed:
offentlig klasse MyBean {public int id; privat strengnavn; @JsonGetter ("navn") offentlig streng getTheName () {return navn; }}Sådan fungerer dette i praksis:
@Test offentlig ugyldig nårSerializingUsingJsonGetter_thenCorrect () kaster JsonProcessingException {MyBean bean = new MyBean (1, "My bean"); String result = new ObjectMapper (). WriteValueAsString (bean); assertThat (resultat, containString ("Min bønne")); assertThat (resultat, indeholderString ("1")); }2.3. @JsonPropertyOrder
Vi kan bruge @JsonPropertyOrder kommentar til at specificere rækkefølgen af egenskaber ved serialisering.
Lad os indstille en brugerdefineret rækkefølge for egenskaberne for en MyBean enhed:
@JsonPropertyOrder ({"name", "id"}) offentlig klasse MyBean {public int id; offentligt strengnavn; }Her er output af serialisering:
{"name": "Min bønne", "id": 1}Så kan vi lave en simpel test:
@Test offentlig ugyldig nårSerializingUsingJsonPropertyOrder_thenCorrect () kaster JsonProcessingException {MyBean bean = new MyBean (1, "My bean"); String result = new ObjectMapper (). WriteValueAsString (bean); assertThat (resultat, containString ("Min bønne")); assertThat (resultat, indeholderString ("1")); }Vi kan også bruge @JsonPropertyOrder (alfabetisk = sand) at ordne egenskaberne alfabetisk. I så fald vil output af serieisering være:
{"id": 1, "name": "Min bønne"}2.4. @JsonRawValue
Det @JsonRawValue kommentar kan bede Jackson om at serieisere en ejendom nøjagtigt som den er.
I det følgende eksempel bruger vi @JsonRawValue at integrere nogle brugerdefinerede JSON som en værdi af en enhed:
offentlig klasse RawBean {offentligt strengnavn; @JsonRawValue offentlig String json; }Outputtet for at serialisere enheden er:
{"name": "My bean", "json": {"attr": false}}Næste her er en simpel test:
@Test offentligt ugyldigt nårSerializingUsingJsonRawValue_thenCorrect () kaster JsonProcessingException {RawBean bean = new RawBean ("My bean", "{\" attr \ ": false}"); String result = new ObjectMapper (). WriteValueAsString (bean); assertThat (resultat, containString ("Min bønne")); assertThat (resultat, containString ("{\" attr \ ": false}")); }Vi kan også bruge det valgfri boolske argument værdi der definerer, om denne kommentar er aktiv eller ej.
2.5. @JsonValue
@JsonValue angiver en enkelt metode, som biblioteket vil bruge til at serieisere hele forekomsten.
For eksempel kommenterer vi i en enum getName med @JsonValue således at en sådan enhed serialiseres via sit navn:
offentlig enum TypeEnumWithValue {TYPE1 (1, "Type A"), TYPE2 (2, "Type 2"); privat heltal id; privat strengnavn; // standardkonstruktører @JsonValue public String getName () {return name; }}Her er vores test:
@Test offentlig ugyldig nårSerializingUsingJsonValue_thenCorrect () kaster JsonParseException, IOException {String enumAsString = ny ObjectMapper () .writeValueAsString (TypeEnumWithValue.TYPE1); assertThat (enumAsString, er ("" Type A "")); }2.6. @JsonRootName
Det @JsonRootName kommentar bruges, hvis indpakning er aktiveret, til at angive navnet på rodindpakningen, der skal bruges.
Indpakning betyder, at i stedet for at serialisere en Bruger til noget som:
{"id": 1, "name": "John"}Det vil blive pakket ind således:
{"Bruger": {"id": 1, "name": "John"}}Så lad os se på et eksempel. We skal bruge @JsonRootName kommentar for at angive navnet på denne potentielle indpakningsenhed:
@JsonRootName (værdi = "bruger") offentlig klasse UserWithRoot {public int id; offentligt strengnavn; }Som standard vil navnet på indpakningen være navnet på klassen - UserWithRoot. Ved at bruge kommentaren får vi renere ud bruger:
@Test offentlig ugyldig nårSerializingUsingJsonRootName_thenCorrect () kaster JsonProcessingException {UserWithRoot bruger = ny bruger (1, "John"); ObjectMapper-kortlægger = ny ObjectMapper (); mapper.enable (SerializationFeature.WRAP_ROOT_VALUE); Strengresultat = mapper.writeValueAsString (bruger); assertThat (resultat, indeholderString ("John")); assertThat (resultat, indeholderString ("bruger")); }Her er output af serialisering:
{"user": {"id": 1, "name": "John"}}Siden Jackson 2.4, et nyt valgfrit argument navneområde er tilgængelig til brug med dataformater såsom XML. Hvis vi tilføjer det, bliver det en del af det fuldt kvalificerede navn:
@JsonRootName (værdi = "bruger", namespace = "brugere") offentlig klasse UserWithRootNamespace {public int id; offentligt strengnavn // ...}Hvis vi serierer det med XmlMapper, output vil være:
1 Johannes 2.7. @JsonSerialize
@JsonSerialize angiver en brugerdefineret serialisering, der skal bruges, når marshalling enheden.
Lad os se på et hurtigt eksempel. Vi skal bruge @JsonSerialize at serieisere eventDate ejendom med en CustomDateSerializer:
public class EventWithSerializer {public String name; @JsonSerialize (ved hjælp af = CustomDateSerializer.class) offentlig dato eventDate; }Her er den enkle brugerdefinerede Jackson serializer:
offentlig klasse CustomDateSerializer udvider 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 (Datoværdi, JsonGenerator gen, SerializerProvider arg2) kaster IOException, JsonProcessingException {gen.writeString (formatter.format (værdi)); }}Lad os nu bruge disse i en test:
@Test offentlig ugyldigt nårSerializingUsingJsonSerialize_thenCorrect () kaster JsonProcessingException, ParseException {SimpleDateFormat df = ny 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, indeholderString (toParse)); }3. Jackson Deserialization Annotations
Lad os derefter udforske Jackson-deserialiseringsanmærkningerne.
3.1. @JsonCreator
Vi kan bruge @JsonCreator kommentar for at indstille konstruktøren / fabrikken, der bruges til deserialisering.
Det er meget nyttigt, når vi har brug for at deserialisere noget JSON, der ikke nøjagtigt matcher den målenhed, vi har brug for.
Lad os se på et eksempel. Sig, at vi skal deserialisere følgende JSON:
{"id": 1, "theName": "Min bønne"}Der er dog ingen navnet felt i vores målenhed, er der kun en navn Mark. Nu vil vi ikke ændre selve enheden, vi har bare brug for lidt mere kontrol over unmarshalling-processen ved at kommentere konstruktøren med @JsonCreator, og bruge @JsonProperty kommentar også:
offentlig klasse BeanWithCreator {public int id; offentligt strengnavn; @JsonCreator public BeanWithCreator (@JsonProperty ("id") int id, @JsonProperty ("theName") Navn på streng) {this.id = id; dette.navn = navn; }}Lad os se dette i aktion:
@Test offentligt ugyldigt nårDeserializingUsingJsonCreator_thenCorrect () kaster IOException {String json = "{\" id \ ": 1, \" theName \ ": \" Min bønne \ "}"; BeanWithCreator bean = ny ObjectMapper () .readerFor (BeanWithCreator.class) .readValue (json); assertEquals ("My bean", bean.name); }3.2. @JacksonInject
@JacksonInject angiver, at en ejendom får sin værdi fra indsprøjtningen og ikke fra JSON-dataene.
I det følgende eksempel bruger vi @JacksonInject at indsprøjte ejendommen id:
offentlig klasse BeanWithInject {@JacksonInject public int id; offentligt strengnavn; }Sådan fungerer det:
@Test offentlig ugyldig nårDeserializingUsingJsonInject_thenCorrect () kaster IOException {String json = "{\" name \ ": \" Min bønne \ "}"; InjectableValues inject = new InjectableValues.Std () .addValue (int.class, 1); BeanWithInject bean = ny ObjectMapper (). Læser (indsprøjtning). ForType (BeanWithInject.class) .readValue (json); assertEquals ("My bean", bean.name); assertEquals (1, bean.id); }3.3. @JsonAnySetter
@JsonAnySetter giver os fleksibiliteten ved at bruge en Kort som standardegenskaber. Ved deserialisering føjes egenskaberne fra JSON simpelthen til kortet.
Først bruger vi @JsonAnySetter at deserialisere enheden ExtendableBean:
offentlig klasse ExtendableBean {public String name; private kortegenskaber; @JsonAnySetter offentlig ugyldig tilføjelse (strengnøgle, strengværdi) {egenskaber.put (nøgle, værdi); }}Dette er den JSON, vi skal deserialisere:
{"name": "Min bønne", "attr2": "val2", "attr1": "val1"}Så her er, hvordan det hele hænger sammen:
@Test offentligt ugyldigt 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 der markerer metoden som en settermetode.
Dette er utroligt nyttigt, når vi har brug for at læse nogle JSON-data, men målenhedsklassen matcher ikke nøjagtigt disse data, og derfor er vi nødt til at indstille processen, så den passer.
I det følgende eksempel specificerer vi metoden setTheName () som setter af navn ejendom i vores MyBean enhed:
offentlig klasse MyBean {public int id; privat strengnavn; @JsonSetter ("navn") public void setTheName (String name) {this.name = name; }}Nu når vi har brug for at fjerne markeringen af nogle JSON-data, fungerer dette perfekt:
@Test offentligt ugyldigt nårDeserializingUsingJsonSetter_thenCorrect () kaster IOException {String json = "{\" id \ ": 1, \" name \ ": \" Min bønne \ "}"; MyBean bean = ny ObjectMapper () .readerFor (MyBean.class) .readValue (json); assertEquals ("Min bønne", bean.getTheName ()); }3.5. @JsonDeserialize
@JsonDeserialize angiver brugen af en brugerdefineret deserializer.
Først bruger vi @JsonDeserialize at deserialisere eventDate ejendom med CustomDateDeserializer:
public class EventWithSerializer {public String name; @JsonDeserialize (ved hjælp af = CustomDateDeserializer.class) offentlig dato eventDate; }Her er den tilpassede deserializer:
offentlig klasse CustomDateDeserializer udvider StdDeserializer {privat statisk SimpleDateFormat formatter = ny SimpleDateFormat ("dd-MM-åååå hh: mm: ss"); offentlig CustomDateDeserializer () {dette (null); } offentlig CustomDateDeserializer (klasse vc) {super (vc); } @ Override public Dato deserialize (JsonParser jsonparser, DeserializationContext context) kaster IOException {String date = jsonparser.getText (); prøv {return formatter.parse (dato); } fange (ParseException e) {kast ny RuntimeException (e); }}}Næste her er back-to-back test:
@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
Det @JsonAlias definerer et eller flere alternative navne på en ejendom under deserialisering.
Lad os se, hvordan denne kommentar fungerer med et hurtigt eksempel:
offentlig klasse AliasBean {@JsonAlias ({"fName", "f_name"}) privat streng fornavn; privat streng efternavn; }Her har vi en POJO, og vi vil deserialisere JSON med værdier som f.eks fnavn, f_nameog fornavn ind i fornavn variabel af POJO.
Nedenfor er en test, der sikrer, at denne kommentar fungerer som forventet:
@Test offentligt ugyldigt 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. Annoncer om inkludering af Jackson-ejendom
4.1. @JsonIgnoreProperties
@JsonIgnoreProperties er en klassebemærkning, der markerer en ejendom eller en liste over egenskaber, som Jackson vil ignorere.
Lad os se på et hurtigt eksempel, hvor vi ignorerer ejendommen id fra serialisering:
@JsonIgnoreProperties ({"id"}) offentlig klasse BeanWithIgnore {public int id; offentligt strengnavn; }Her er testen, der sørger for, at ignorering sker:
@Test offentlig ugyldig nårSerializingUsingJsonIgnoreProperties_thenCorrect () kaster JsonProcessingException {BeanWithIgnore bean = new BeanWithIgnore (1, "My bean"); String result = new ObjectMapper () .writeValueAsString (bean); assertThat (resultat, containString ("Min bønne")); assertThat (resultat, ikke (indeholderString ("id"))); }For at ignorere ukendte egenskaber i JSON-input uden undtagelse kan vi indstille ignoreUnknown = sandt af @JsonIgnoreProperties kommentar.
4.2. @JsonIgnorer
I modsætning hertil er @JsonIgnorer annotering bruges til at markere en egenskab, der skal ignoreres på feltniveau.
Lad os bruge @JsonIgnorer at ignorere ejendommen id fra serialisering:
offentlig klasse BeanWithIgnore {@JsonIgnore public int id; offentligt strengnavn; }Så tester vi for at sikre os, at det id blev med succes ignoreret:
@Test offentlig ugyldig nårSerializingUsingJsonIgnore_thenCorrect () kaster JsonProcessingException {BeanWithIgnore bean = new BeanWithIgnore (1, "My bean"); String result = new ObjectMapper () .writeValueAsString (bean); assertThat (resultat, containString ("Min bønne")); assertThat (resultat, ikke (indeholderString ("id"))); }4.3. @JsonIgnoreType
@JsonIgnoreType markerer alle egenskaber af en kommenteret type, der skal ignoreres.
Vi kan bruge kommentaren til at markere alle egenskaber af typen Navn der skal ignoreres:
public class User {public int id; offentligt navn @JsonIgnoreType offentlig statisk klasse Navn {public String firstName; offentlig streng efternavn; }}Vi kan også teste for at sikre, at ignorering fungerer korrekt:
@Test offentlig ugyldig nårSerializingUsingJsonIgnoreType_thenCorrect () kaster JsonProcessingException, ParseException {User.Name name = new User.Name ("John", "Doe"); Brugerbruger = ny bruger (1, navn); Strengresultat = ny ObjectMapper () .writeValueAsString (bruger); assertThat (resultat, indeholderString ("1")); assertThat (resultat, ikke (indeholderString ("navn"))); assertThat (resultat, ikke (indeholderString ("John"))); }4.4. @JsonInclude
Vi kan bruge @JsonInclude for at udelukke egenskaber med tomme / null / standardværdier.
Lad os se på et eksempel, der ekskluderer nuller fra serialisering:
@JsonInclude (Include.NON_NULL) offentlig klasse MyBean {public int id; offentligt strengnavn; }Her er den fulde test:
offentlig ugyldighed nårSerializingUsingJsonInclude_thenCorrect () kaster JsonProcessingException {MyBean bean = new MyBean (1, null); String result = new ObjectMapper () .writeValueAsString (bean); assertThat (resultat, indeholderString ("1")); assertThat (resultat, ikke (indeholderString ("navn"))); }4.5. @JsonAutoDetect
@JsonAutoDetect kan tilsidesætte standard semantikken for hvilke egenskaber der er synlige og hvilke der ikke er.
Lad os først se på, hvordan kommentaren kan være meget nyttig med et simpelt eksempel; lad os aktivere serialisering af private egenskaber:
@JsonAutoDetect (fieldVisibility = Visibility.ANY) offentlig klasse PrivateBean {privat int id; privat strengnavn; }Derefter testen:
@Test offentlig ugyldig nårSerializingUsingJsonAutoDetect_thenCorrect () kaster JsonProcessingException {PrivateBean bean = new PrivateBean (1, "My bean"); String result = new ObjectMapper () .writeValueAsString (bean); assertThat (resultat, indeholderString ("1")); assertThat (resultat, containString ("Min bønne")); }5. Jackson polymorfe typehåndteringskommentarer
Lad os derefter kigge på Jackson polymorfe håndteringsnotater:
- @JsonTypeInfo - angiver detaljer om, hvilken type information der skal medtages i serialisering
- @JsonSubTypes - angiver undertyper af den kommenterede type
- @JsonTypeName - definerer et logisk typenavn, der skal bruges til kommenteret klasse
Lad os undersøge et mere komplekst eksempel og bruge alle tre - @JsonTypeInfo, @JsonSubTypes, og @JsonTypeName - at serialisere / deserialisere enheden Zoo:
offentlig klasse Zoo {offentligt dyr; @JsonTypeInfo (use = JsonTypeInfo.Id.NAME, include = As.PROPERTY, property = "type") @JsonSubTypes ({@ JsonSubTypes.Type (value = Dog.class, name = "dog"), @ JsonSubTypes.Type ( værdi = Cat.class, name = "cat")}) offentlig statisk klasse Animal {public String name; } @JsonTypeName ("hund") offentlig statisk klasse Hund udvider Animal {offentlig dobbelt barkVolume; } @JsonTypeName ("cat") offentlig statisk klasse Kat udvider Animal {boolean likesCream; offentlige int liv }}Når vi foretager serialisering:
@Test offentligt ugyldigt 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, indeholderString ("type")); assertThat (resultat, indeholderString ("hund")); }Her er hvad serialisering af Zoo eksempel med Hund vil medføre:
{"animal": {"type": "dog", "name": "lacy", "barkVolume": 0}}Nu til de-serialisering. Lad os starte med følgende JSON-input:
{"animal": {"name": "lacy", "type": "cat"}}Lad os så se, hvordan det bliver unmarshalled til en Zoo eksempel:
@Test offentligt ugyldigt nårDeserializingPolymorphic_thenCorrect () kaster IOException {String json = "{\" animal \ ": {\" name \ ": \" lacy \ ", \" type \ ": \" cat \ "}}"; Zoo zoo = ny ObjectMapper () .readerFor (Zoo.class) .readValue (json); assertEquals ("lacy", zoo.animal.name); assertEquals (Zoo.Cat.class, zoo.animal.getClass ()); }6. Jackson generelle kommentarer
Lad os derefter diskutere nogle af Jacksons mere generelle kommentarer.
6.1. @JsonProperty
Vi kan tilføje det @JsonProperty kommentar for at angive ejendomsnavnet i JSON.
Lad os bruge @JsonProperty at serialisere / deserialisere ejendommen navn når vi har at gøre med ikke-standardiserede getters og settere:
offentlig klasse MyBean {public int id; privat strengnavn; @JsonProperty ("navn") public void setTheName (String name) {this.name = name; } @JsonProperty ("navn") offentlig streng getTheName () {returnavn; }}Næste er vores test:
@Test offentligt ugyldigt nårUsingJsonProperty_thenCorrect () kaster IOException {MyBean bean = new MyBean (1, "My bean"); String result = new ObjectMapper (). WriteValueAsString (bean); assertThat (resultat, containString ("Min bønne")); assertThat (resultat, indeholderString ("1")); MyBean resultBean = ny ObjectMapper () .readerFor (MyBean.class) .readValue (resultat); assertEquals ("Min bønne", resultBean.getTheName ()); }6.2. @JsonFormat
Det @JsonFormat annotation angiver et format, når dato- / tidsværdier serialiseres.
I det følgende eksempel bruger vi @JsonFormat for at kontrollere formatet på ejendommen eventDate:
public class EventWithFormat {public String name; @JsonFormat (form = JsonFormat.Shape.STRING, mønster = "dd-MM-åååå tt: mm: ss") offentlig Dato eventDate; }Så her er testen:
@Test offentlig ugyldigt 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 ("fest", dato); String result = new ObjectMapper (). WriteValueAsString (event); assertThat (resultat, indeholderString (toParse)); }6.3. @JsonUnpakkede
@JsonUnpakkede definerer værdier, der skal pakkes ud / udflades, når de serialiseres / deserialiseres.
Lad os se nøjagtigt, hvordan dette fungerer; vi bruger kommentaren til at pakke ejendommen ud navn:
offentlig klasse UnwrappedUser {public int id; @JsonUnpakkede offentlige navn navn; offentlig statisk klasse Navn {offentlig streng fornavn; offentlig streng efternavn; }}Lad os nu serieisere en forekomst af denne klasse:
@Test offentlig ugyldig nårSerializingUsingJsonUnwrapped_thenCorrect () kaster JsonProcessingException, ParseException {UnwrappedUser.Name name = new UnwrappedUser.Name ("John", "Doe"); UnwrappedUser user = new UnwrappedUser (1, name); String result = new ObjectMapper (). WriteValueAsString (user); assertThat (resultat, indeholderString ("John")); assertThat (resultat, ikke (indeholderString ("navn"))); }Endelig er her, hvordan output ser ud - felterne i den statiske indlejrede klasse udpakket sammen med det andet felt:
{"id": 1, "firstName": "John", "lastName": "Doe"}6.4. @JsonView
@JsonView angiver den visning, hvor ejendommen skal medtages til serialisering / deserialisering.
For eksempel bruger vi @JsonView at serieisere en forekomst af Vare enhed.
Lad os først starte med synspunkterne:
offentlig klasse Visninger {offentlig statisk klasse Offentlig {} offentlig statisk klasse Intern udvider Offentlig {}}Næste her er Vare enhed, der bruger visningerne:
public class Item {@JsonView (Views.Public.class) public int id; @JsonView (Views.Public.class) public String itemName; @JsonView (Views.Internal.class) public String ownerName; }Endelig den fulde 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, containString ("bog")); assertThat (resultat, indeholderString ("2")); assertThat (resultat, ikke (indeholderString ("John"))); }6.5. @JsonManagedReference, @JsonBackReference
Det @JsonManagedReference og @JsonBackReference annoteringer kan håndtere forældre / barn-forhold og arbejd rundt om sløjfer.
I det følgende eksempel bruger vi @JsonManagedReference og @JsonBackReference at serieisere vores VareMedRef enhed:
public class ItemWithRef {public int id; public String itemName; @JsonManagedReference offentlig UserWithRef ejer; }Vores UserWithRef enhed:
offentlig klasse UserWithRef {public int id; offentligt strengnavn; @JsonBackReference offentlig liste userItems; }Derefter testen:
@Test offentlig ugyldig, nårSerializingUsingJacksonReferenceAnnotation_thenCorrect () kaster JsonProcessingException {UserWithRef-bruger = ny UserWithRef (1, "John"); ItemWithRef element = ny ItemWithRef (2, "bog", bruger); user.addItem (vare); String result = new ObjectMapper (). WriteValueAsString (item); assertThat (resultat, containString ("bog")); assertThat (resultat, indeholderString ("John")); assertThat (resultat, ikke (indeholderString ("userItems"))); }6.6. @JsonIdentityInfo
@JsonIdentityInfo angiver, at objektidentitet skal bruges til serialisering / deserialisering af værdier, f.eks. når der beskæftiges med uendelige rekursionstyper af problemer.
I det følgende eksempel har vi en ItemWithIdentity enhed med et tovejsforhold med UserWithIdentity enhed:
@JsonIdentityInfo (generator = ObjectIdGenerators.PropertyGenerator.class, property = "id") offentlig klasse ItemWithIdentity {public int id; public String itemName; offentlig UserWithIdentity ejer; }Det UserWithIdentity enhed:
@JsonIdentityInfo (generator = ObjectIdGenerators.PropertyGenerator.class, property = "id") offentlig klasse UserWithIdentity {public int id; offentligt strengnavn; offentlig liste userItems; }Nu lad os se, hvordan det uendelige rekursionsproblem håndteres:
@Test offentlig ugyldig nårSerializingUsingJsonIdentityInfo_thenCorrect () kaster JsonProcessingException {UserWithIdentity bruger = ny UserWithIdentity (1, "John"); ItemWithIdentity item = new ItemWithIdentity (2, "bog", bruger); user.addItem (vare); String result = new ObjectMapper (). WriteValueAsString (item); assertThat (resultat, containString ("bog")); assertThat (resultat, indeholderString ("John")); assertThat (resultat, containString ("userItems")); }Her er den fulde output af den serielle vare og bruger:
{"id": 2, "itemName": "book", "owner": {"id": 1, "name": "John", "userItems": [2]}}6.7. @JsonFilter
Det @JsonFilter annotation angiver et filter, der skal bruges under serialisering.
Først definerer vi enheden, og vi peger på filteret:
@JsonFilter ("myFilter") offentlig klasse BeanWithFilter {public int id; offentligt strengnavn; }Nu i den fulde test definerer vi filteret, som udelukker alle andre egenskaber undtagen navn fra serialisering:
@Test offentlig ugyldigt nårSerializingUsingJsonFilter_thenCorrect () kaster JsonProcessingException {BeanWithFilter bean = new BeanWithFilter (1, "My bean"); FilterProvider filtre = ny SimpleFilterProvider (). AddFilter ("myFilter", SimpleBeanPropertyFilter.filterOutAllExcept ("navn")); String result = new ObjectMapper () .writer (filters) .writeValueAsString (bean); assertThat (resultat, containString ("Min bønne")); assertThat (resultat, ikke (indeholderString ("id"))); }7. Brugerdefineret Jackson-kommentar
Lad os derefter se, hvordan du opretter en brugerdefineret Jackson-kommentar. Vi kan gøre brug af @JacksonAnnotationsInside kommentar:
@Retention (RetentionPolicy.RUNTIME) @JacksonAnnotationsInside @JsonInclude (Include.NON_NULL) @JsonPropertyOrder ({"name", "id", "dateCreated"}) public @interface CustomAnnotation {}Nu hvis vi bruger den nye kommentar på en enhed:
@CustomAnnotation offentlig klasse BeanWithCustomAnnotation {public int id; offentligt strengnavn; offentlig Dato dato Oprettet; }Vi kan se, hvordan det kombinerer de eksisterende kommentarer til en simpel brugerdefineret, som vi kan bruge 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, containString ("Min bønne")); assertThat (resultat, indeholderString ("1")); assertThat (resultat, ikke (indeholderString ("dateCreated"))); }Outputtet fra serieiseringsprocessen:
{"name": "Min bønne", "id": 1}8. Jackson MixIn-kommentarer
Lad os derefter se, hvordan du bruger Jackson MixIn-kommentarer.
Lad os for eksempel bruge MixIn-kommentarerne til at ignorere egenskaber af typen Bruger:
public class Item {public int id; public String itemName; offentlig Bruger ejer; }@JsonIgnoreType offentlig klasse MyMixInForIgnoreType {}Lad os så se dette i aktion:
@Test offentligt ugyldigt nårSerializingUsingMixInAnnotation_thenCorrect () kaster JsonProcessingException {Item item = new Item (1, "book", null); String result = new ObjectMapper (). WriteValueAsString (item); assertThat (resultat, containString ("ejer")); ObjectMapper-kortlægger = ny ObjectMapper (); mapper.addMixIn (User.class, MyMixInForIgnoreType.class); resultat = mapper.writeValueAsString (vare); assertThat (resultat, ikke (indeholderString ("ejer"))); }9. Deaktiver Jackson-kommentar
Lad os endelig se, hvordan vi kan deaktiver alle Jackson-kommentarer. Vi kan gøre dette ved at deaktivere MapperFeature.USE_ANNOTATIONS som i følgende eksempel:
@JsonInclude (Include.NON_NULL) @JsonPropertyOrder ({"name", "id"}) offentlig klasse MyBean {public int id; offentligt strengnavn; }Efter deaktivering af annoteringer skal disse nu ikke have nogen effekt, og standardindstillingerne for biblioteket skal gælde:
@Test offentlig ugyldig nårDisablingAllAnnotations_thenAllDisabled () kaster IOException {MyBean bean = new MyBean (1, null); ObjectMapper-kortlægger = ny ObjectMapper (); mapper.disable (MapperFeature.USE_ANNOTATIONS); Strengresultat = mapper.writeValueAsString (bønne); assertThat (resultat, indeholderString ("1")); assertThat (resultat, indeholderString ("navn")); }Resultatet af serialisering, før annoteringer deaktiveres:
{"id": 1}Resultatet af serialisering efter deaktivering af kommentarer:
{"id": 1, "name": null}10. Konklusion
I denne artikel undersøgte vi Jackson-kommentarer, bare skrabe overfladen af den slags fleksibilitet, vi kan få ved at bruge dem korrekt.
Implementeringen af alle disse eksempler og kodestykker findes på GitHub.
