Parsing mobilalkalmazásokban: lényeg, adatformátumok és folyamat

Mi az a parsing?

Parsing (szintaktikai elemzés) — a karaktersorozat strukturált ábrázolássá alakításának folyamata, amely alkalmas programozott feldolgozásra. A mobilfejlesztés kontextusában a parsing a szerverválaszok, konfigurációs fájlok, helyi gyorsítótár és erőforrásfájlok elemzését jelenti. Minden formátum saját megközelítést igényel: JSON — könnyű és beépített az SDK-ba, XML — szigorú XSD-séma érvényesítéssel, CSV — minimalista táblázatos adatokhoz, Protobuf — bináris merev sémával.

A szintaktikai elemzés szakaszai

Minden elemző, formátumtól függetlenül, három szakaszon megy keresztül. Lexikális elemzés a nyers szöveget lexémákra bontja: kulcsok, karakterláncok, számok, elválasztók és megjegyzések. Szintaktikai elemzés ellenőrzi a nyelvtan helyességét — zárójelek egyensúlyát JSON-ban, címkék helyes egymásba ágyazását XML-ben. Kimeneti struktúra felépítése létrehozza az objektumábrázolást: JSONObject, Map vagy tokenfolyam további feldolgozáshoz. Az Apple (2026) szerint a beépített Foundation elemző iOS-en lusta elemzést használ — csak a JSON elejét érvényesíti, erőforrásokat takarítva meg.

Kézi parsing vs automatikus könyvtárak

Kézi parsing (JSONSerialization, XmlPullParser) teljes irányítást ad a folyamat felett, és hasznos nem szabványos formátumok vagy az egyes mezők egyedi érvényesítésének szükségessége esetén. Automatikus könyvtárak (JSONDecoder, Moshi, kotlinx.serialization) felgyorsítják a fejlesztést, de elrejtik a hibakezelés részleteit. A választás a követelményektől függ: ha az adatstruktúra dinamikus vagy előre nem ismert — a kézi parsing előnyösebb. Ha a séma rögzített — az automatikus deszerializáció 60–70%-kal csökkenti a kódot.

Miben különbözik a parsing a deszerializációtól

Parsing — tágabb művelet: végrehajtható streaming módon, és nem feltétlenül hoz létre tipizált objektumot. Deszerializáció — a parsing speciális esete, amelynek eredménye mindig egy előre ismert osztály példánya konkrét tulajdonságtípusokkal. A JSON elemző a dokumentumot Map vagy JsonElement elemekre bontja, míg a deszerializátor ugyanazt a JSON-t konkrét User, Order vagy Product objektummá alakítja ismert mezőkkel és típusokkal.

Streaming parsing — a parsing fő előnye a deszerializációval szemben. Az XmlPullParser Androidon az XML-t olvasás közben elemzi, anélkül, hogy a teljes dokumentumot a memóriába töltené. Ez kritikus fontosságú nagy API-válaszok, több száz elemet tartalmazó RSS-hírcsatornák elemzése vagy több ezer JSON-objektumot tartalmazó tömb feldolgozása esetén. A streaming elemző tokenről tokenre olvas, állandó mennyiségű memóriát fogyasztva a dokumentum méretétől függetlenül.

JSON parsing mobilalkalmazásokban

JSON — az uralkodó adatcsere-formátum. iOS-en a beépített JSONSerialization JSON-t Any-vé alakítja, a JSONDecoder pedig közvetlenül Codable struktúrává. Androidon a szabványos org.json JSONObject és JSONArray osztályokat biztosít kézi elemzéshez. A Gson és Moshi automatikus konverziót adnak hozzá. A választás a kézi és automatikus megközelítés között — a hálózati réteg első architektúrális döntése.

val jsonString = """{"users":[{"id":1,"name":"Alice"}]}"""
val jsonObject = JSONObject(jsonString)
val usersArray = jsonObject.getJSONArray("users")

for (i in 0 until usersArray.length()) {
    val item = usersArray.getJSONObject(i)
    val id = item.getInt("id")
    val name = item.getString("name")
    // felhasználó feldolgozása
}

Kézi parsing org.json segítségével akkor hasznos, ha a válasz struktúrája előre nem ismert vagy jelentősen változik. Ez a megközelítés teljes irányítást ad a hibakezelés és a nullable mezők felett, de több sablonkódot igényel az automatikus deszerializációhoz képest. Kis projektekhez vagy prototípusokhoz elfogadható, de éles környezetben a Moshi vagy a kotlinx.serialization ajánlott.

JSONReader streaming elemzéshez

JsonReader a Moshi könyvtárból — hatékony eszköz streaming JSON parsinghoz. Tokenről tokenre olvassa a dokumentumot a beginObject, nextName, nextString, nextInt és endObject metódusok segítségével. Ez a megközelítés lehetővé teszi bármilyen méretű dokumentum feldolgozását állandó memóriafogyasztással. A Google (2026) szerint a streaming parsing JsonReader segítségével 2–3-szor gyorsabb, mint a teljes dokumentum JsonObject-ba töltése, és akár 80%-kal kevesebb memóriát fogyaszt.

val reader = JsonReader(StringReader(json))
reader.beginObject()
while (reader.hasNext()) {
    val name = reader.nextName()
    when (name) {
        "id" -> val id = reader.nextInt()
        "name" -> val name = reader.nextString()
        "email" -> val email = reader.nextString()
        else -> reader.skipValue()
    }
}
reader.endObject()

A példa bemutatja a JsonReader-t, amely streaming módon elemzi a JSON-t. Minden nextName() és nextInt() hívás a kurzort a következo tokenre mozgatja. A skipValue() kihagyja a szükségtelen mezőket elemzés nélkül — ez különösen akkor hasznos, ha a JSON 50 mezőt tartalmaz, de csak 3-ra van szükség. Eredmény — minimális memóriafogyasztás és maximális sebesség.

XML és CSV parsing

XML továbbra is használatos Android projektekben erőforrásokhoz és vállalati alkalmazások SOAP szolgáltatásaihoz. Androidon a beépített XmlPullParser minimális memóriafogyasztással biztosít streaming elemzést — nem tölti be a DOM-fát, hanem START_TAG, TEXT, END_TAG eseményeket generál. iOS az XMLParser-t használja delegált megközelítéssel: a parser(didStartElement:) és parser(foundCharacters:) metódusok egymás után dolgozzák fel az elemeket.

CSV a mobilfejlesztésben

CSV — a legegyszerűbb formátum táblázatos adatok exportálásához és importálásához. Mobilalkalmazásokban a CSV-t jelentések exportálására, címjegyzékek betöltésére (országok, pénznemek, kódok listái) és offline adatok szinkronizálására használják. CSV parsinghoz a streaming könyvtárak alkalmasak: az Apache Commons CSV és az OpenCSV soronként dolgozzák fel a fájlokat, escape-elve az idézőjeleket és vesszőket az értékeken belül. iOS-en a CSV parsing megvalósítható az NSString.components(separatedBy:) elválasztóval, a szélsőséges esetek kezelésével.

class CSVParser: NSObject, XMLParserDelegate {
    private var currentItem: [String: String] = [:]
    private var currentElement: String = ""

    func parser(
        _ parser: XMLParser,
        didStartElement elementName: String,
        namespaceURI: String?,
        qualifiedName qName: String?,
        attributes attributeDict: [String: String]
    ) {
        currentElement = elementName
        if elementName == "item" {
            currentItem = [:]
        }
    }

    func parser(_ parser: XMLParser,
                foundCharacters string: String) {
        currentItem[currentElement] = string
    }
}

Példa XMLParser delegáltra iOS-en RSS-hírcsatorna elemzéséhez. A didStartElement metódus minden nyitó címkénél meghívásra kerül, a foundCharacters visszaadja a címkék közötti szöveges tartalmat, a didEndElement befejezi az elemet. Az ilyen eseményvezérelt architektúra lehetővé teszi bármilyen méretű XML feldolgozását a DOM-fának a memóriába töltése nélkül — kritikus a mobileszközök korlátozott erőforrásai miatt.

CSV könyvtárak összehasonlítása Androidhoz

Androidon a CSV elemző választása az adatok mennyiségétől függ. Az OpenCSV támogatja a fluent API-t, annotációkat a POJO-ra képezéshez és egyedi elválasztókat. Az Apache Commons CSV alacsonyabb szintű, de gyorsabb nagy fájlokon. Egyszerű esetekben (1–2 oszlop) elegendő a kézi elemzés String.split(",") segítségével, az escape kezelésével. Production projektekhez nagy CSV-fájlokkal az OpenCSV ajánlott.

Protobuf és streaming parsing

Protocol Buffers a Google-től — bináris szerializációs formátum, amely sebességben és tömörségben felülmúlja a JSON-t. A Protobuf üzenet 3–6-szor kevesebb helyet foglal, mint a megfelelő JSON, és 4–10-szer gyorsabban elemezhető a bináris formátumnak és a merev sémának köszönhetően. Fő hátrányok: az emberi olvashatóság hiánya és a .proto fájlokból történő kódgenerálás szükségessége a protoc fordító segítségével.

Protobuf streaming parsingja a CodedInputStream segítségével valósul meg — az ügyfél a mezőket érkezésükkor olvassa, anélkül, hogy a teljes üzenetet betöltené. Minden mező rendelkezik egy címkével (szám + típus), és az elemző kihagyhatja az ismeretlen mezőket. A Google (2026) szerint a Protobuf streaming elemzése akár 90%-kal kevesebb memóriát fogyaszt az 1 MB-tól származó üzenetek feldolgozásakor, ami kritikus fontosságú a korlátozott RAM-mal rendelkező mobileszközök számára. A Protobuf-lite egy speciális változat Androidhoz, amely a generált kód mérete alapján van optimalizálva.