Serialisasi data dalam pengembangan seluler: esensi, format, dan cara kerjanya

Esensi serialisasi dan deserialisasi

Serialisasi adalah proses mengubah objek aplikasi menjadi format yang cocok untuk transmisi melalui jaringan atau penyimpanan di disk. Deserialisasi melakukan konversi sebaliknya, memulihkan objek dari data yang diterima. Dalam pengembangan seluler, serialisasi diterapkan dalam permintaan API, penyimpanan status layar, caching, dan transmisi data melalui Intent atau Bundle.

Kapan kebutuhan muncul

Setiap interaksi antara komponen aplikasi atau antara aplikasi dan server memerlukan serialisasi. REST API mengirimkan data dalam JSON atau XML, gRPC menggunakan Protocol Buffers, dan komunikasi intraproses di Android menggunakan Parcelable. Tanpa serialisasi, tidak mungkin mengirim objek kompleks melintasi batas proses atau menyimpannya di database.

// Prinsip umum serialisasi
data class User(
    val id: Int,
    val name: String,
    val email: String
)

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

// Deserialisasi: JSON -> objek
fun deserializeUser(json: String): User? {
    // parsing JSON ke objek
    return Gson().fromJson(json, User::class.java)
}

JSON — format utama pengembangan seluler

JSON (JavaScript Object Notation) adalah format teks ringan berdasarkan sintaks objek JavaScript. JSON mendukung string, angka, nilai boolean, array, dan objek bersarang, yang mencakup sebagian besar skenario transmisi data dalam aplikasi seluler. Format ini tidak bergantung pada platform: setiap ekosistem menyediakan alat bawaan untuk parsingnya.

Keunggulan JSON dibandingkan alternatif

JSON unggul karena kesederhanaan dan universalitasnya. Pengembang tidak memerlukan skema untuk penggunaan dasar — struktur ditentukan secara dinamis selama parsing. Keterbacaan format menyederhanakan debugging dan pengujian: respons server dapat dilihat di alat pengembang mana pun. Di kedua platform seluler, JSON diproses secara native tanpa menghubungkan pustaka pihak ketiga.

// Codable — serialisasi JSON native di 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 dari Google

Protocol Buffers (protobuf) adalah format serialisasi biner yang dikembangkan oleh Google untuk sistem berkinerja tinggi. Tidak seperti JSON, protobuf memerlukan definisi skema sebelumnya dalam file .proto, tetapi memberikan ukuran data yang jauh lebih kecil dan kecepatan pemrosesan yang lebih tinggi. Format ini digunakan dalam gRPC, Firebase Firestore, dan layanan internal Google.

Struktur file .proto

Skema protobuf mendeskripsikan pesan dengan bidang yang diketik, masing-masing memiliki nomor unik. Kompilator protoc menghasilkan kelas dalam bahasa yang diinginkan yang secara otomatis melakukan serialisasi dan deserialisasi. Protobuf mendukung evolusi skema melalui aturan penambahan dan penghapusan bidang tanpa kehilangan kompatibilitas mundur.

// Mendefinisikan skema di user.proto
syntax = "proto3";

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

// Kode yang dihasilkan di Kotlin
val user = UserProto.User.newBuilder()
    .setId(1)
    .setName("John")
    .setEmail("john@test.com")
    .build()

val bytes: ByteArray = user.toByteArray()

XML dan penerapannya

XML (eXtensible Markup Language) adalah format dengan struktur ketat, dukungan ruang nama, dan validasi melalui skema XSD. XML kalah dari JSON dalam hal kekompakan dan kecepatan parsing, tetapi tetap diminati dalam pengembangan Android untuk file layout, AndroidManifest, sumber daya, dan konfigurasi Gradle. Di iOS, XML digunakan dalam file plist dan beberapa layanan lama.

Parsing XML di Android

Android menawarkan tiga cara untuk memparse XML: DOM (memuat seluruh dokumen ke memori), SAX (parsing streaming berorientasi peristiwa), dan XmlPullParser (pendekatan hibrida). XmlPullParser adalah opsi yang direkomendasikan untuk perangkat seluler, karena bekerja secara efisien dengan memori terbatas dan memungkinkan pemrosesan dokumen saat dibaca.

// XmlPullParser di 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!!)
}

Serialisasi di iOS dan Android

Setiap platform menawarkan alatnya sendiri untuk serialisasi. Di iOS, mekanisme utamanya adalah protokol Codable dengan JSONEncoder dan JSONDecoder, dan untuk Objective-C — NSJSONSerialization. Android menggunakan pustaka Gson, Moshi, dan kotlinx.serialization. Untuk transmisi data antarproses, Android menggunakan Parcelable, dan iOS menggunakan NSKeyedArchiver. Proyek Kotlin semakin sering memilih kotlinx.serialization — solusi dari JetBrains yang mendukung multi-platform dan tidak bergantung pada refleksi, menghasilkan serializer pada tahap kompilasi melalui plugin kompilator Kotlin.

Parcelable vs Serializable di Android

Android mendukung dua mekanisme serialisasi untuk Intent dan Bundle. Serializable adalah mekanisme Java standar yang menggunakan refleksi, yang menyebabkan kinerja rendah. Parcelable adalah protokol khusus Android yang memerlukan implementasi manual metode writeToParcel dan createFromParcel, tetapi bekerja puluhan kali lebih cepat berkat manipulasi byte secara langsung.

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

// Transmisi melalui Intent
val intent = Intent(this, DetailActivity::class.java)
intent.putExtra("user", userParcel)
startActivity(intent)

Di iOS untuk transmisi data antar pengontrol, digunakan Codable dengan serialisasi sebelumnya ke Data, dan untuk komunikasi antarproses — NSKeyedArchiver, yang mengubah objek menjadi format biner Property List. Proyek modern di SwiftUI lebih suka mengenkode data melalui JSONEncoder untuk transmisi antar modul aplikasi.

Keamanan dalam serialisasi

Deserialisasi data tidak tepercaya yang salah dapat menyebabkan kerentanan. Serangan melalui serialisasi mengeksploitasi metode readObject yang diganti di Java atau deserializer tidak aman dari pustaka pihak ketiga. Di Android, Serializable harus dihindari untuk data dari sumber tidak tepercaya, menggunakan Parcelable atau validasi manual semua bidang setelah deserialisasi. Di iOS, JSONDecoder secara default ketat terhadap tipe, tetapi saat bekerja dengan JSONSerialization, pengembang harus memeriksa tipe melalui konversi bersyarat.

Pemilihan format untuk proyek

Saat memilih format serialisasi, pertimbangan mencakup persyaratan kinerja, ukuran data, dan kompatibilitas. Untuk REST API dan arsitektur mikroservis, pilihan optimal tetap JSON — didukung oleh semua platform dan bahasa. Untuk sistem dengan beban tinggi dan aplikasi seluler dengan lalu lintas terbatas, Protocol Buffers lebih disukai yang memberikan ukuran lebih kecil dan deserialisasi lebih cepat. XML hanya dibenarkan dalam skenario konfigurasi dan integrasi dengan sistem lama. Dalam proyek modern, FlatBuffers juga semakin populer — format biner tanpa tahap deserialisasi, digunakan di mesin game dan aplikasi dengan latensi minimal. Setiap format memiliki ceruknya sendiri, dan pilihan yang tepat secara langsung memengaruhi kecepatan aplikasi dan volume lalu lintas yang dikonsumsi.