streamalism.org

1. Oversigt

Klaxon er et af open source-bibliotekerne, som vi kan bruge til at analysere JSON i Kotlin.

I denne vejledning skal vi se på dens funktioner.

2. Maven-afhængighed

Først skal vi tilføje biblioteksafhængigheden til vores Maven-projekt:

 com.beust klaxon 3.0.4 

Den seneste version kan findes på jcenter eller i Spring Plugins Repository.

3. API-funktioner

Klaxon har fire API'er til at arbejde med JSON-dokumenter. Vi undersøger disse i de følgende afsnit.

4. Objektbindende API

Med denne API, vi kan binde JSON-dokumenter til Kotlin-objekter og omvendt.

For at starte, lad os definere følgende JSON-dokument:

{"name": "HDD"}

Derefter opretter vi Produkt klasse til binding:

klasse Produkt (val navn: streng)

Nu kan vi teste serialisering:

@Test sjov givenProduct_whenSerialize_thenGetJsonString () {val product = Product ("HDD") val result = Klaxon (). ToJsonString (product) assertThat (result) .isEqualTo ("" "{" name ":" HDD "}" "") }

Og vi kan teste deserialisering:

@Test fun givenJsonString_whenDeserialize_thenGetProduct () {val result = Klaxon (). Parse ("" "{" name ":" RAM "}" "") assertThat (result? .Name) .isEqualTo ("RAM")}

Denne API understøtter også arbejde med dataklasser såvel som ændrede og uforanderlige klasser.

Klaxon tillader os at Tilpas kortlægningsprocessen med @Json kommentar. Denne kommentar har to egenskaber:

• navn - til indstilling af et andet navn for felterne
• ignoreret - til at ignorere felter i kortlægningsprocessen

Lad os oprette en CustomProduct klasse for at se, hvordan disse fungerer:

klasse CustomProduct (@Json (name = "productName") val navn: String, @Json (ignoreret = true) val id: Int)

Lad os nu kontrollere det med en test:

@Test sjov givenCustomProduct_whenSerialize_thenGetJsonString () {val product = CustomProduct ("HDD", 1) val result = Klaxon (). ToJsonString (product) assertThat (result) .isEqualTo ("" "{" productName ":" HDD "}" " ")}

Som vi kan se, er navn ejendom serialiseres som produktnavn, og id ejendom ignoreres.

5. Streaming API

Med Streaming API kan vi håndtere store JSON-dokumenter ved at læse fra en stream. Denne funktion tillader vores kode at behandle JSON-værdier, mens den stadig læser.

Vi er nødt til at bruge JsonLæser klasse fra API for at læse en JSON-stream. Denne klasse har to specielle funktioner til håndtering af streaming:

• beginObject () - sørger for, at det næste token er begyndelsen på et objekt
• beginArray () - sørger for, at det næste token er begyndelsen på et array

Med disse funktioner kan vi være sikre på, at strømmen er korrekt placeret, og at den er lukket efter forbrug af objektet eller arrayet.

Lad os teste streaming-API'en mod en række af følgende Produktdata klasse:

dataklasse ProductData (val navn: String, val capacityInGb: Int)

@Test sjov givetJsonArray_whenStreaming_thenGetProductArray () {val jsonArray = "" "[{" name ":" HDD "," capacityInGb ": 512}, {" name ":" RAM "," capacityInGb ": 16}]" "" val expectArray = arrayListOf (ProductData ("HDD", 512), ProductData ("RAM", 16)) val klaxon = Klaxon () val productArray = arrayListOf () JsonReader (StringReader (jsonArray)). brug {reader -> reader.beginArray {while (reader.hasNext ()) {val product = klaxon.parse (reader) productArray.add (product !!)}}} assertThat (productArray) .hasSize (2) .isEqualTo (expectedArray)}

6. JSON Path Query API

Klaxon understøtter elementplaceringsfunktionen fra JSON Path-specifikationen. Med denne API kan vi definere stemmatchere for at finde specifikke poster i vores dokumenter.

Bemærk, at denne API også streamer, og vi får besked, når et element er fundet og parset.

Vi er nødt til at bruge PathMatcher interface. Denne grænseflade kaldes, når JSON-stien fandt match med det regulære udtryk.

For at bruge dette er vi nødt til at implementere dens metoder:

• pathMatches () - returner sandt, hvis vi ønsker at følge denne vej
• onMatch () - fyret, når stien er fundet bemærk, at værdien kun kan være en basistype (f.eks. int, Snor) og aldrig JsonObject eller JsonArray

Lad os lave en test for at se det i aktion.

Lad os først definere et JSON-beholdningsdokument som en datakilde:

{"inventar": {"disks": [{"type": "HDD", "sizeInGb": 1000}, {"type": "SDD", "sizeInGb": 512}]}}

Nu implementerer vi PathMatcher interface som følger:

val pathMatcher = object: PathMatcher {tilsidesætte fun pathMatches (sti: String) = Pattern.matches (". * beholdning. * diske. * type. *", sti) tilsidesætte fun onMatch (sti: String, værdi: Enhver) {når (sti) {"$ .inventory.disks [0] .type" -> assertThat (værdi) .isEqualTo ("HDD") "$ .inventory.disks [1] .type" -> assertThat (værdi) .isEqualTo ( "SDD")}}}

Bemærk, at vi definerede regex til at matche typen af ​​disk i vores lagerdokument.

Nu er vi klar til at definere vores test:

@Test sjov givenDiskInventory_whenRegexMatches_thenGetTypes () {val jsonString = "" "..." "" val pathMatcher = // ... Klaxon (). PathMatcher (pathMatcher) .parseJsonObject (StringReader (jsonString))}

7. API på lavt niveau

Med Klaxon kan vi behandle JSON-dokumenter som en Kort eller a Liste. For at gøre dette kan vi bruge klasser JsonObject og JsonArray fra API.

Lad os lave en test for at se JsonObject i aktion:

@ Test sjov givenJsonString_whenParser_thenGetJsonObject () {val jsonString = StringBuilder ("" "{" name ":" HDD "," capacityInGb ": 512," sizeInInch ": 2.5}" "") val parser = Parser () val json = parser .parse (jsonString) som JsonObject hævder, at (json) .hasSize (3) .containsEntry ("navn", "HDD") .containsEntry ("capacityInGb", 512) .containsEntry ("sizeInInch", 2,5)}

Lad os nu lave en test for at se JsonArray funktionalitet:

@Test sjov givenJsonStringArray_whenParser_thenGetJsonArray () {val jsonString = StringBuilder ("" "[{" name ":" SDD "}, {" madeIn ":" Taiwan "}, {" warrantyInYears ": 5}]" "") val parser = Parser () val json = parser.parse (jsonString) som JsonArray hævder let ({softly -> softly.assertThat (json) .hasSize (3) softly.assertThat (json [0] ["name"]). IsEqualTo (" SDD ") softly.assertThat (json [1] [" madeIn "]). IsEqualTo (" Taiwan ") soft.assertThat (json [2] [" warrantyInYears "]). IsEqualTo (5)})}

Som vi kan se i begge tilfælde, foretog vi konverteringerne uden definition af specifikke klasser.

8. Konklusion

I denne artikel udforskede vi Klaxon-biblioteket og dets API'er til at håndtere JSON-dokumenter.

Som altid er kildekoden tilgængelig på Github.