Serialisasyon ng data sa mobile development: esensya, format, at kung paano ito gumagana

Esensya ng serialisasyon at deserialisasyon

Serialisasyon ay ang proseso ng pag-convert ng bagay ng application sa isang format na angkop para sa pagpapadala sa network o pag-iimbak sa disk. Ang deserialisasyon ay nagsasagawa ng kabaligtaran na conversion, na nagpapanumbalik ng bagay mula sa natanggap na data. Sa mobile development, ang serialisasyon ay inilalapat sa mga kahilingan ng API, pag-save ng estado ng screen, caching, at paghahatid ng data sa pamamagitan ng Intent o Bundle.

Kailan lumitaw ang pangangailangan

Ang bawat interaksyon sa pagitan ng mga bahagi ng application o sa pagitan ng application at server ay nangangailangan ng serialisasyon. REST API ay naghahatid ng data sa JSON o XML, ang gRPC ay gumagamit ng Protocol Buffers, at ang intraprocess na komunikasyon sa Android ay gumagamit ng Parcelable. Kung walang serialisasyon, hindi maaaring magpadala ng kumplikadong bagay sa hangganan ng proseso o i-save ito sa database.

// Pangkalahatang prinsipyo ng serialisasyon
data class User(
    val id: Int,
    val name: String,
    val email: String
)

// Serialisasyon: object -> JSON
fun serializeUser(user: User): String {
    return """{"id":${user.id},"name":"${user.name}","email":"${user.email}"}"""
}

// Deserialisasyon: JSON -> object
fun deserializeUser(json: String): User? {
    // pag-parse ng JSON sa object
    return Gson().fromJson(json, User::class.java)
}

JSON — pangunahing format ng mobile development

JSON (JavaScript Object Notation) ay isang magaan na text format batay sa syntax ng mga bagay ng JavaScript. JSON ay sumusuporta sa mga string, numero, boolean value, array, at nested na bagay, na sumasaklaw sa karamihan ng mga senaryo ng paghahatid ng data sa mga mobile application. Ang format ay hindi nakadepende sa platform: bawat ecosystem ay nagbibigay ng mga built-in na tool para sa pag-parse nito.

Mga kalamangan ng JSON kumpara sa mga alternatibo

JSON ay nananalo dahil sa pagiging simple at unibersal nito. Ang developer ay hindi nangangailangan ng schema para sa pangunahing paggamit — ang istraktura ay tinutukoy nang dynamic sa panahon ng pag-parse. Ang pagkabasa ng format ay nagpapadali sa debugging at pagsubok: ang tugon ng server ay maaaring matingnan sa anumang tool ng developer. Sa parehong mobile platform, ang JSON ay pinoproseso nang native nang hindi kumokonekta sa mga third-party na library.

// Codable — native JSON serialisasyon sa Swift
struct User: Codable {
    let id: Int
    let name: String
    let email: String
}

let jsonString = """{"id":1,"name":"John","email":"john@test.com"}"""
let jsonData = Data(jsonString.utf8)
let decoder = JSONDecoder()
let user = try! decoder.decode(User.self, from: jsonData)

Protocol Buffers mula sa Google

Protocol Buffers (protobuf) ay isang binary serialisasyon format na binuo ng Google para sa mga high-performance system. Hindi tulad ng JSON, ang protobuf ay nangangailangan ng paunang pagtukoy ng schema sa .proto file, ngunit nagbibigay ng makabuluhang mas maliit na laki ng data at mas mataas na bilis ng pagproseso. Ang format ay ginagamit sa gRPC, Firebase Firestore, at mga panloob na serbisyo ng Google.

Istraktura ng .proto file

Ang schema ng protobuf ay naglalarawan ng mga mensahe na may naka-type na mga field, bawat isa ay may natatanging numero. Ang protoc compiler ay bumubuo ng mga klase sa nais na wika na awtomatikong nagsasagawa ng serialisasyon at deserialisasyon. Protobuf ay sumusuporta sa ebolusyon ng schema sa pamamagitan ng mga patakaran ng pagdaragdag at pag-alis ng mga field nang walang pagkawala ng backward compatibility.

// Pagtukoy ng schema sa user.proto
syntax = "proto3";

message User {
  int32 id = 1;
  string name = 2;
  string email = 3;
  repeated string roles = 4;
}

// Na-generate na code sa Kotlin
val user = UserProto.User.newBuilder()
    .setId(1)
    .setName("John")
    .setEmail("john@test.com")
    .build()

val bytes: ByteArray = user.toByteArray()

XML at ang aplikasyon nito

XML (eXtensible Markup Language) ay isang format na may mahigpit na istraktura, suporta sa namespace, at validation sa pamamagitan ng XSD schema. XML ay natalo sa JSON sa pagiging compact at bilis ng pag-parse, ngunit nananatiling hinihiling sa Android development para sa mga layout file, AndroidManifest, resources, at Gradle configuration. Sa iOS, ang XML ay ginagamit sa mga plist file at ilang mas lumang serbisyo.

Pag-parse ng XML sa Android

Android ay nag-aalok ng tatlong paraan upang i-parse ang XML: DOM (pag-load ng buong dokumento sa memorya), SAX (event-oriented streaming parse), at XmlPullParser (hybrid approach). XmlPullParser ay ang inirerekomendang opsyon para sa mga mobile device, dahil mahusay itong gumagana sa limitadong memorya at pinapayagan ang pagproseso ng dokumento habang ito ay binabasa.

// Parcelable sa Android
fun parseUserXml(inputStream: InputStream): User? {
    val parser = Xml.newPullParser()
    parser.setInput(inputStream, Xml.Encoding.UTF_8.name)

    var id: Int? = null
    var name: String? = null
    var email: String? = null

    while (parser.next() != XmlPullParser.END_DOCUMENT) {
        if (parser.eventType == XmlPullParser.START_TAG
            && parser.name == "email") {
            email = parser.nextText()
        }
    }
    return User(id!!, name!!, email!!)
}

Serialisasyon sa iOS at Android

Bawat platform ay nag-aalok ng sarili nitong mga tool para sa serialisasyon. Sa iOS, ang pangunahing mekanismo ay ang Codable protocol na may JSONEncoder at JSONDecoder, at para sa Objective-C — NSJSONSerialization. Android ay gumagamit ng mga library na Gson, Moshi, at kotlinx.serialization. Para sa paghahatid ng data sa pagitan ng mga proseso, Android ay gumagamit ng Parcelable, at iOS ay gumagamit ng NSKeyedArchiver. Ang mga proyekto ng Kotlin ay lalong pumipili ng kotlinx.serialization — solusyon mula sa JetBrains na sumusuporta sa multi-platform at hindi umaasa sa reflection, na bumubuo ng mga serializer sa yugto ng compilation sa pamamagitan ng Kotlin compiler plugin.

Parcelable vs Serializable sa Android

Android ay sumusuporta sa dalawang mekanismo ng serialisasyon para sa Intent at Bundle. Serializable ay ang standard na Java mechanism na gumagamit ng reflection, na nagreresulta sa mababang performance. Parcelable ay isang protocol na tiyak sa Android na nangangailangan ng manu-manong pagpapatupad ng mga pamamaraan na writeToParcel at createFromParcel, ngunit gumagana ng sampung beses na mas mabilis dahil sa direktang manipulasyon ng mga byte.

// XmlPullParser sa Android
@Parcelize
data class UserParcel(
    val id: Int,
    val name: String,
    val email: String
) : Parcelable

// Pagpapasa sa pamamagitan ng Intent
val intent = Intent(this, DetailActivity::class.java)
intent.putExtra("user", userParcel)
startActivity(intent)

Sa iOS para sa paghahatid ng data sa pagitan ng mga controller, ginagamit ang Codable na may paunang serialisasyon sa Data, at para sa interprocess communication — NSKeyedArchiver, na nagko-convert ng mga bagay sa binary Property List format. Ang mga modernong proyekto sa SwiftUI ay mas gusto ang pag-encode ng data sa pamamagitan ng JSONEncoder para sa paghahatid sa pagitan ng mga module ng application.

Seguridad sa serialisasyon

Ang maling deserialisasyon ng hindi mapagkakatiwalaang data ay maaaring humantong sa mga kahinaan. Mga pag-atake sa pamamagitan ng serialisasyon ay nagsasamantala sa mga override na readObject method sa Java o hindi ligtas na deserializer ng mga third-party na library. Sa Android, dapat iwasan ang Serializable para sa data mula sa hindi mapagkakatiwalaang source, gamit sa halip ang Parcelable o manu-manong validation ng lahat ng field pagkatapos ng deserialisasyon. Sa iOS, ang JSONDecoder ay mahigpit bilang default sa mga uri, ngunit kapag nagtatrabaho sa JSONSerialization, dapat suriin ng developer ang mga uri sa pamamagitan ng conditional conversion.

Pagpili ng format para sa proyekto

Kapag pumipili ng format ng serialisasyon, isinasaalang-alang ang mga kinakailangan sa pagganap, laki ng data, at compatibility. Para sa REST API at microservice architecture, ang pinakamainam na pagpipilian ay nananatiling JSON — ito ay sinusuportahan ng lahat ng platform at wika. Para sa mga high-load na system at mobile application na may limitadong trapiko, mas gusto ang Protocol Buffers na nagbibigay ng mas maliit na laki at mas mabilis na deserialisasyon. XML ay makatwiran lamang sa mga senaryo ng configuration at pagsasama sa mga legacy system. Sa mga modernong proyekto, ang FlatBuffers ay nagkakaroon din ng kasikatan — binary format na walang yugto ng deserialisasyon, ginagamit sa mga game engine at application na may minimal na latency. Bawat format ay may sariling angkop na lugar, at ang tamang pagpili ay direktang nakakaapekto sa bilis ng paggana ng application at dami ng natupok na trapiko.