การซีเรียลไลซ์ข้อมูลในการพัฒนามือถือ: แก่นสาร รูปแบบ และวิธีการทำงาน

แก่นสารของการซีเรียลไลซ์และดีซีเรียลไลซ์

การซีเรียลไลซ์ คือกระบวนการแปลงออบเจกต์ของแอปพลิเคชันเป็นรูปแบบที่เหมาะสมสำหรับการส่งผ่านเครือข่ายหรือการจัดเก็บในดิสก์ การดีซีเรียลไลซ์ทำการแปลงย้อนกลับ กู้คืนออบเจกต์จากข้อมูลที่ได้รับ ในการพัฒนามือถือ การซีเรียลไลซ์ถูกใช้ในคำขอ API การบันทึกสถานะหน้าจอ การแคช และการถ่ายโอนข้อมูลผ่าน Intent หรือ Bundle

เมื่อใดที่เกิดความจำเป็น

การโต้ตอบใด ๆ ระหว่างส่วนประกอบของแอปพลิเคชันหรือระหว่างแอปพลิเคชันกับเซิร์ฟเวอร์จำเป็นต้องมีการซีเรียลไลซ์ REST API ส่งข้อมูลในรูปแบบ JSON หรือ XML, gRPC ใช้ Protocol Buffers และการสื่อสารภายในกระบวนการบน Android ใช้ Parcelable หากไม่มีการซีเรียลไลซ์ จะไม่สามารถส่งออบเจกต์ที่ซับซ้อนข้ามขอบเขตกระบวนการหรือบันทึกลงในฐานข้อมูลได้

// หลักการทั่วไปของการซีเรียลไลซ์
data class User(
    val id: Int,
    val name: String,
    val email: String
)

// การซีเรียลไลซ์: ออบเจกต์ -> JSON
fun serializeUser(user: User): String {
    return """{"id":${user.id},"name":"${user.name}","email":"${user.email}"}"""
}

// การดีซีเรียลไลซ์: JSON -> ออบเจกต์
fun deserializeUser(json: String): User? {
    // การแยกวิเคราะห์ JSON เป็นออบเจกต์
    return Gson().fromJson(json, User::class.java)
}

JSON — รูปแบบหลักของการพัฒนามือถือ

JSON (JavaScript Object Notation) เป็นรูปแบบข้อความน้ำหนักเบาที่อิงจากไวยากรณ์ออบเจกต์ของ JavaScript JSON รองรับสตริง ตัวเลข ค่าบูลีน อาร์เรย์ และออบเจกต์ที่ซ้อนกัน ครอบคลุมสถานการณ์การถ่ายโอนข้อมูลส่วนใหญ่ในแอปพลิเคชันมือถือ รูปแบบนี้ไม่ขึ้นกับแพลตฟอร์ม: ทุกระบบนิเวศมีเครื่องมือในตัวสำหรับการแยกวิเคราะห์

ข้อดีของ JSON เหนือทางเลือกอื่น

JSON ชนะด้วยความเรียบง่ายและความอเนกประสงค์ นักพัฒนาไม่จำเป็นต้องมีสคีมาสำหรับการใช้งานพื้นฐาน — โครงสร้างถูกกำหนดแบบไดนามิกระหว่างการแยกวิเคราะห์ ความสามารถในการอ่านของรูปแบบ ช่วยให้การดีบักและทดสอบง่ายขึ้น: การตอบสนองจากเซิร์ฟเวอร์สามารถดูได้ในเครื่องมือนักพัฒนาใด ๆ บนแพลตฟอร์มมือถือทั้งสอง JSON ถูกประมวลผลแบบเนทีฟโดยไม่ต้องใช้ไลบรารีของบุคคลที่สาม

// Codable — การซีเรียลไลซ์ JSON ดั้งเดิมใน 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 โดย Google

Protocol Buffers (protobuf) เป็นรูปแบบการซีเรียลไลซ์แบบไบนารีที่พัฒนาโดย Google สำหรับระบบประสิทธิภาพสูง ต่างจาก JSON ตรงที่ protobuf ต้องมีสคีมาที่กำหนดไว้ล่วงหน้าในไฟล์ .proto แต่ให้ขนาดข้อมูลที่เล็กกว่าและความเร็วในการประมวลผลที่สูงกว่าอย่างมีนัยสำคัญ รูปแบบนี้ใช้ใน gRPC, Firebase Firestore และบริการภายในของ Google

โครงสร้างของไฟล์ .proto

สคีมา protobuf อธิบายข้อความที่มีฟิลด์แบบกำหนดชนิด แต่ละฟิลด์มีหมายเลขเฉพาะ คอมไพเลอร์ protoc สร้างคลาสในภาษาเป้าหมายที่ทำการซีเรียลไลซ์และดีซีเรียลไลซ์โดยอัตโนมัติ Protobuf รองรับการพัฒนาสคีมาผ่านกฎสำหรับการเพิ่มและลบฟิลด์โดยไม่สูญเสียความเข้ากันได้ย้อนหลัง

// การกำหนดสคีมาใน user.proto
syntax = "proto3";

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

// โค้ดที่สร้างใน Kotlin
val user = UserProto.User.newBuilder()
    .setId(1)
    .setName("John")
    .setEmail("john@test.com")
    .build()

val bytes: ByteArray = user.toByteArray()

XML และการประยุกต์ใช้

XML (eXtensible Markup Language) เป็นรูปแบบที่มีโครงสร้างแข็งเกร็ง รองรับเนมสเปซ และการตรวจสอบผ่านสคีมา XSD XML เสียเปรียบ JSON ในด้านความกะทัดรัดและความเร็วในการแยกวิเคราะห์ แต่ยังคงเป็นที่ต้องการในการพัฒนา Android สำหรับไฟล์เลย์เอาต์, AndroidManifest, ทรัพยากร และการกำหนดค่า Gradle บน iOS XML ถูกใช้ในไฟล์ plist และบริการแบบเดิมบางอย่าง

การแยกวิเคราะห์ XML บน Android

Android มีสามวิธีในการแยกวิเคราะห์ XML: DOM (โหลดเอกสารทั้งหมดในหน่วยความจำ), SAX (การแยกวิเคราะห์สตรีมแบบเหตุการณ์) และ XmlPullParser (วิธีแบบผสม) XmlPullParser เป็นตัวเลือกที่แนะนำสำหรับอุปกรณ์มือถือ เนื่องจากทำงานได้อย่างมีประสิทธิภาพกับหน่วยความจำจำกัดและช่วยให้ประมวลผลเอกสารไปพร้อมกับการอ่าน

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

การซีเรียลไลซ์บน iOS และ Android

แต่ละแพลตฟอร์มมีเครื่องมือการซีเรียลไลซ์ของตัวเอง บน iOS กลไกหลักคือโปรโตคอล Codable กับ JSONEncoder และ JSONDecoder ในขณะที่ Objective-C ใช้ NSJSONSerialization Android ใช้ไลบรารี Gson, Moshi และ kotlinx.serialization สำหรับการถ่ายโอนข้อมูลระหว่างกระบวนการ Android ใช้ Parcelable ในขณะที่ iOS ใช้ NSKeyedArchiver โปรเจกต์ Kotlin กำลังเลือก kotlinx.serialization มากขึ้น — โซลูชันจาก JetBrains ที่รองรับหลายแพลตฟอร์มและไม่พึ่งพาการสะท้อน (reflection) สร้างซีเรียลไลเซอร์ในเวลาคอมไพล์ผ่านปลั๊กอินคอมไพเลอร์ Kotlin

Parcelable vs บน Android

Android รองรับกลไกการซีเรียลไลซ์สองแบบสำหรับ Intent และ Bundle Serializable เป็นกลไก Java มาตรฐานที่ใช้การสะท้อน ซึ่งทำให้ประสิทธิภาพต่ำ Parcelable เป็นโปรโตคอลเฉพาะของ Android ที่ต้องการการimplement เมธอด writeToParcel และ createFromParcel ด้วยตนเอง แต่ทำงานเร็วกว่าหลายสิบเท่าด้วยการจัดการไบต์โดยตรง

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

// การถ่ายโอนผ่าน Intent
val intent = Intent(this, DetailActivity::class.java)
intent.putExtra("user", userParcel)
startActivity(intent)

บน iOS Codable กับการซีเรียลไลซ์เบื้องต้นเป็น Data ใช้สำหรับการถ่ายโอนข้อมูลระหว่างคอนโทรลเลอร์ ในขณะที่ NSKeyedArchiver ใช้สำหรับการสื่อสารระหว่างกระบวนการ แปลงออบเจกต์เป็นรูปแบบ Property List แบบไบนารี โปรเจกต์ SwiftUI สมัยใหม่นิยมเข้ารหัสข้อมูลผ่าน JSONEncoder สำหรับการถ่ายโอนระหว่างโมดูลของแอปพลิเคชัน

ความปลอดภัยในการซีเรียลไลซ์

การดีซีเรียลไลซ์ข้อมูลที่ไม่น่าเชื่อถืออย่างไม่ถูกต้องอาจนำไปสู่ช่องโหว่ การโจมตีผ่านการซีเรียลไลซ์ ใช้ประโยชน์จากเมธอด readObject ที่ถูกโอเวอร์ไรด์ใน Java หรือดีซีเรียลไลเซอร์ที่ไม่ปลอดภัยของไลบรารีบุคคลที่สาม บน Android ควรหลีกเลี่ยง Serializable สำหรับข้อมูลจากแหล่งที่ไม่น่าเชื่อถือ โดยใช้ Parcelable หรือการตรวจสอบฟิลด์ทั้งหมดด้วยตนเองหลังการดีซีเรียลไลซ์แทน บน iOS JSONDecoder เข้มงวดกับชนิดโดยค่าเริ่มต้น แต่เมื่อทำงานกับ JSONSerialization นักพัฒนาต้องตรวจสอบชนิดผ่านการแปลงแบบมีเงื่อนไข

การเลือกรูปแบบสำหรับโปรเจกต์

เมื่อเลือกรูปแบบการซีเรียลไลซ์ จะพิจารณาความต้องการด้านประสิทธิภาพ ขนาดข้อมูล และความเข้ากันได้ สำหรับ REST API และสถาปัตยกรรมไมโครเซอร์วิส JSON ยังคงเป็นตัวเลือกที่เหมาะสมที่สุด — รองรับโดยทุกแพลตฟอร์มและภาษา สำหรับระบบที่มีโหลดสูงและแอปพลิเคชันมือถือที่มีแบนด์วิธจำกัด Protocol Buffers เหมาะสมกว่า ซึ่งให้ขนาดที่เล็กกว่าและการดีซีเรียลไลซ์ที่เร็วกว่า XML เหมาะสมในสถานการณ์การกำหนดค่าและการรวมกับระบบแบบเดิมเท่านั้น ในโปรเจกต์สมัยใหม่ FlatBuffers กำลังได้รับความนิยม — รูปแบบไบนารีที่ไม่มีขั้นตอนการดีซีเรียลไลซ์ ใช้ในเกมเอนจินและแอปพลิเคชันที่ต้องการความหน่วงต่ำ แต่ละรูปแบบมีกลุ่มเฉพาะของตัวเอง และการเลือกที่ถูกต้องส่งผลโดยตรงต่อความเร็วของแอปพลิเคชันและปริมาณการรับส่งข้อมูลที่ใช้