A JSON feldolgozása Kotlin és Klaxson mellett

1. Áttekintés

A Klaxon az egyik nyílt forráskódú könyvtár, amelyet felhasználhatunk a JSON elemzésére Kotlinban.

Ebben az oktatóanyagban megvizsgáljuk annak jellemzőit.

2. Maven-függőség

Először hozzá kell adnunk a könyvtárfüggőséget a Maven projektünkhöz:

 com.beust klaxon 3.0.4 

A legújabb verzió megtalálható a jcenter webhelyen vagy a Spring Plugins Repository-ban.

3. API jellemzők

A Klaxon négy API-val rendelkezik a JSON dokumentumok kezeléséhez. Ezeket a következő szakaszokban vizsgáljuk meg.

4. Object Binding API

Ezzel az API-val a JSON dokumentumokat köthetjük Kotlin objektumokhoz és fordítva.

Kezdésként definiáljuk a következő JSON-dokumentumot:

{"name": "HDD"}

Ezután létrehozzuk a Termék osztály a kötéshez:

osztály Termék (név: String)

Most tesztelhetjük a sorosítást:

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

És tesztelhetjük a deserializációt:

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

Ez az API támogatja az adatosztályokkal, valamint a változtatható és megváltoztathatatlan osztályokkal való munkát is.

Klaxon megengedi nekünk testreszabhatja a leképezési folyamatot a @Json annotáció. Ennek a kommentárnak két tulajdonsága van:

  • név - a mezők másik nevének beállításához
  • figyelmen kívül hagyta - a leképezési folyamat mezõinek figyelmen kívül hagyása

Hozzunk létre egy CustomProduct osztályban, hogy lássa, hogyan működnek ezek:

class CustomProduct (@Json (name = "productName") val név: String, @Json (ignore = true) val id: Int)

Most ellenőrizzük egy próbával:

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

Mint láthatjuk, a név tulajdonság sorosítva van termék név, és a id tulajdonság figyelmen kívül marad.

5. Streaming API

A Streaming API segítségével hatalmas JSON dokumentumokat tudunk kezelni egy adatfolyamról olvasva. Ez a funkció lehetővé teszi a kódunk számára a JSON-értékek feldolgozását, még olvasás közben.

Használnunk kell a JsonReader osztály az API-ból egy JSON-adatfolyam beolvasásához. Ennek az osztálynak két speciális funkciója van a streaming kezelésére:

  • beginObject () - gondoskodik arról, hogy a következő token egy objektum kezdete legyen
  • beginArray () - gondoskodik arról, hogy a következő token egy tömb kezdete legyen

Ezekkel a funkciókkal biztosak lehetünk abban, hogy az adatfolyam helyesen van elhelyezve és az objektum vagy tömb elfogyasztása után bezárt.

Teszteljük a streaming API-t az alábbiak tömbjével ProductData osztály:

ProductData adatosztály (val név: karakterlánc, val kapacitásInGb: Int)
@Tesztelt mókaJsonArray_whenStreaming_thenGetProductArray () {val jsonArray = "" "[{" name ":" HDD "," capacityInGb ": 512}, {" name ":" RAM "," capacityInGb ": 16}]" "" val Várható Array = arrayListOf (ProductData ("HDD", 512), ProductData ("RAM", 16)) val klaxon = Klaxon () val productArray = arrayListOf () JsonReader (StringReader (jsonArray)). használja az {olvasót -> olvasót.beginArray {while (olvasó.hasNext ()) {val termék = klaxon.parse (olvasó) productArray.add (termék !!)}}} assertThat (productArray) .hasSize (2) .isEqualTo (várhatóArray)}

6. JSON Path Query API

A Klaxon a JSON Path specifikációból támogatja az elemek elhelyezését. Ezzel az API-val tudjuk definiálja az útvonal-egyeztetőket a dokumentumok bizonyos bejegyzéseinek megkereséséhez.

Ne feledje, hogy ez az API is folyik, és értesítést kapunk egy elem megtalálása és elemzése után.

Használnunk kell a PathMatcher felület. Ezt a felületet akkor hívják meg, amikor a JSON elérési útja megtalálta a szabályos kifejezés egyezését.

Ennek használatához meg kell valósítanunk a módszereit:

  • pathMatches () - térjen vissza igazra, ha meg akarjuk figyelni ezt az utat
  • onMatch () - lőttek, amikor megtalálták az utat; vegye figyelembe, hogy az érték csak alaptípus lehet (pl. int, Húr) és soha JsonObject vagy JsonArray

Tegyünk egy tesztet, hogy lássuk működés közben.

Először határozzunk meg egy készlet JSON-dokumentumot adatforrásként:

{"készlet": {"lemezek": [{"type": "HDD", "sizeInGb": 1000}, {"type": "SDD", "sizeInGb": 512}]}}

Most megvalósítjuk a PathMatcher interfész az alábbiak szerint:

val pathMatcher = objektum: PathMatcher {felülbírálja a fun pathMatches (elérési út: String) = Pattern.matches (". * készlet. * lemezek. * típus. *", elérési út) felülírja a fun onMatch (elérési út: String, érték: Bármely) {mikor (elérési út) {"$ .inventory.disks [0] .type" -> assertThat (érték) .isEqualTo ("HDD") "$ .inventory.disks [1] .type" -> assertThat (érték) .isEqualTo ( "SD D") } } }

Megjegyezzük, hogy a regexet úgy definiáltuk, hogy megfeleljen a készletdokumentumunk lemeztípusának.

Most készen állunk a tesztünk meghatározására:

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

7. Alacsony szintű API

A Klaxonnal olyan JSON dokumentumokat dolgozhatunk fel, mint a Térkép vagy a Lista. Ehhez használhatjuk az osztályokat JsonObject és JsonArray az API-ból.

Tegyünk egy tesztet a JsonObject működés közben:

@Test fun givenJsonString_whenParser_thenGetJsonObject () {val jsonString = StringBuilder ("" "" {"name": "HDD", "capacityInGb": 512, "sizeInInch": 2.5} "" ") val parser = Parser () val json = parser .parse (jsonString) mint JsonObject assertThat (json) .hasSize (3) .containsEntry ("név", "HDD") .containsEntry ("capacityInGb", 512) .containsEntry ("sizeInInch", 2.5)}

Most tegyünk egy tesztet a JsonArray funkcionalitás:

@Tesztelt móka adottJsonStringArray_whenParser_thenGetJsonArray () {val jsonString = StringBuilder ("" "[[{" name ":" SDD "}, {" madeIn ":" Taiwan "}, {" garanciaInYears ": 5}]" "" ") val elemző = Parser () val json = parser.parse (jsonString), ahogy a JsonArray állítjaSoftly ({lágyan -> lágyan.assertThat (json) .hasSize (3) lágyan.assertThat (json [0] ["név"]). IsEqualTo (" SDD ") halkan.assertThat (json [1] [" madeIn "]). IsEqualTo (" Tajvan ") halkan.assertThat (json [2] [" szavatossági év "). IsEqualTo (5)})}

Mint mindkét esetben láthatjuk, az átalakításokat konkrét osztályok meghatározása nélkül hajtottuk végre.

8. Következtetés

Ebben a cikkben a Klaxon könyvtárat és annak API-kat tártuk fel a JSON-dokumentumok kezelésére.

Mint mindig, a forráskód is elérhető a Githubon.