Gson — คืออะไร ไลบรารี JSON สำหรับ Java และ Kotlin

Gson คืออะไร

Gson คือไลบรารี Java ที่พัฒนาโดย Google สำหรับแปลงวัตถุเป็นรูปแบบ JSON และกลับมา มันใช้รีเฟลกชันเพื่อวิเคราะห์โครงสร้างคลาส ทำให้สามารถทำงานได้โดยไม่ต้องกำหนดค่าล่วงหน้า Gson รองรับวัตถุ Java ตามอำเภอใจ คอลเลกชัน อาร์เรย์ เจเนอริก และคลาสที่ซ้อนกัน ไลบรารีไม่ต้องการคำอธิบายประกอบสำหรับการใช้งานพื้นฐาน แต่มีไว้สำหรับการปรับแต่งอย่างละเอียด ข้อเสียหลักของรีเฟลกชันคือประสิทธิภาพที่ลดลงระหว่างการเริ่มต้นและการไม่สามารถปรับให้เหมาะสมในเวลาคอมไพล์ ซึ่งสังเกตได้ชัดเจนเป็นพิเศษเมื่อสตาร์ทเย็นของแอปพลิเคชัน Android เมื่อดีซีเรียลไลซ์โมเดลหลายร้อยตัว อย่างไรก็ตาม Gson ยังคงเป็นตัวเลือกที่เชื่อถือได้สำหรับโครงการส่วนใหญ่ด้วยความเสถียรและเอกสารที่ครอบคลุม

ประวัติและสถานที่ในระบบนิเวศ

Gson ถูกเผยแพร่โดย Google ในปี 2008 และกลายเป็นมาตรฐานโดยพฤตินัยสำหรับ JSON ในแอปพลิเคชัน Android อย่างรวดเร็ว ก่อนการมาถึงของ Moshi และ kotlinx.serialization Gson เป็นตัวเลือกยอดนิยมเพียงตัวเดียวสำหรับโครงการ Kotlin ความง่ายในการผสานรวม — เพิ่มการพึ่งพาเดียวใน build.gradle — และการไม่มีคำอธิบายประกอบบังคับทำให้ Gson เป็นที่นิยมในหมู่นักพัฒนาทุกระดับ

// การเพิ่ม Gson ใน build.gradle
dependencies {
    implementation 'com.google.code.gson:gson:2.10.1'
}

// การใช้งานพื้นฐาน
data class User(
    val id: Int,
    val name: String,
    val email: String
)

val gson = Gson()
val user = User(1, "John", "john@test.com")
val json = gson.toJson(user)
println(json) // {"id":1,"name":"John","email":"john@test.com"}

นอกจากการซีเรียลไลเซชันพื้นฐานแล้ว Gson ยังมี GsonBuilder สำหรับกำหนดค่าพฤติกรรม: การจัดรูปแบบวันที่ การปิดใช้งานการหนี HTML รูปแบบคีย์ และอินสแตนซ์ที่กำหนดเอง GsonBuilder ยังอนุญาตให้ลงทะเบียน JsonSerializer และ JsonDeserializer ที่กำหนดเองสำหรับชนิดที่ไลบรารีไม่สามารถจัดการได้โดยอัตโนมัติ ความยืดหยุ่นในการกำหนดค่าทำให้ GsonBuilder เป็นเครื่องมือที่ขาดไม่ได้และมีประโยชน์เมื่อปรับไลบรารีให้เข้ากับความต้องการเฉพาะของโครงการในการพัฒนา Android สมัยใหม่

การดำเนินการหลัก toJson และ fromJson

toJson แปลงวัตถุ Java เป็นสตริง JSON โดยการวิเคราะห์ฟิลด์ผ่านรีเฟลกชัน โดยค่าเริ่มต้น Gson จะรวมฟิลด์ทั้งหมดยกเว้น transient และ static เมธอดรองรับทุกชนิด: ดั้งเดิม วัตถุ คอลเลกชัน และอาร์เรย์ fromJson ดำเนินการย้อนกลับ โดยรับสตริง JSON และคลาสวัตถุเป้าหมาย และส่งคืนอินสแตนซ์ที่มีฟิลด์ที่เติมแล้ว

การแปลงวัตถุเป็น JSON

ระหว่างการซีเรียลไลเซชัน Gson จะสำรวจฟิลด์วัตถุทั้งหมดซ้ำ ๆ รวมถึงฟิลด์ที่ซ้อนกัน การอ้างอิงแบบวนซ้ำ ทำให้เกิด StackOverflowError ดังนั้นจึงต้องยกเว้นผ่านคำอธิบายประกอบ @Expose หรืออะแดปเตอร์ที่กำหนดเอง สำหรับคอลเลกชัน Gson จะรักษาชนิดขององค์ประกอบไว้ แต่เมื่อดีซีเรียลไลซ์รายการที่มีเจเนอริก จำเป็นต้องใช้ TypeToken เพื่อรักษาข้อมูลชนิด

// data class ที่มีวัตถุที่ซ้อนกัน
data class Address(
    val city: String,
    val street: String
)

data class Employee(
    val id: Int,
    val name: String,
    val address: Address
)

val gson = Gson()
val employee = Employee(1, "Alice",
    Address("New York", "5th Ave"))

// การซีเรียลไลเซชันเป็น JSON
val json = gson.toJson(employee)

// การดีซีเรียลไลเซชันจาก JSON
val jsonString = """
{"id":2,"name":"Bob","address":{"city":"London","street":"Baker St"}}
"""
val parsed = gson.fromJson(jsonString, Employee::class.java)

คำอธิบายประกอบและการกำหนดค่า

Gson มีชุดคำอธิบายประกอบสำหรับจัดการกระบวนการซีเรียลไลเซชัน @SerializedName ระบุชื่อคีย์ JSON ที่แตกต่างจากชื่อฟิลด์ @Expose ควบคุมว่าฟิลด์จะรวมในการซีเรียลไลเซชันหรือไม่: Gson ที่สร้างผ่าน GsonBuilder.excludeFieldsWithoutExposeAnnotation() จะประมวลผลเฉพาะฟิลด์ที่มี @Expose @Since และ @Until ควบคุมการกำหนดเวอร์ชันฟิลด์

@SerializedName และ @Expose

คำอธิบายประกอบ @SerializedName แก้ปัญหาความไม่ตรงกันของชื่อ: เซิร์ฟเวอร์อาจใช้ snake_case ในขณะที่โค้ดใช้ camelCase คำอธิบายประกอบรับค่าและทางเลือกเสริมสำหรับความเข้ากันได้ย้อนหลัง @Expose อนุญาตให้ซ่อนฟิลด์ที่ละเอียดอ่อน (รหัสผ่าน โทเค็น) จากการซีเรียลไลเซชันโดยทำเครื่องหมายเป็น @Expose(serialize = false) นอกจากการรวมและการยกเว้นแล้ว @Expose สามารถรวมกับ GsonBuilder.excludeFieldsWithoutExposeAnnotation เพื่อสร้างรายการขาวของฟิลด์ ซึ่งช่วยควบคุมพื้นผิวการโจมตีเมื่อซีเรียลไลซ์วัตถุที่มีหลายฟิลด์

// โมเดลที่มีคำอธิบายประกอบ Gson
data class UserResponse(
    @SerializedName("user_id")
    val userId: Int,

    @SerializedName("full_name",
        alternate = [Alternative("name")])
    val fullName: String,

    @Expose(serialize = false)
    val password: String
)

// Gson ที่มีการกรอง @Expose
val gson = GsonBuilder()
    .excludeFieldsWithoutExposeAnnotation()
    .setPrettyPrinting()
    .create()

val user = UserResponse(1, "John", "secret123")
println(gson.toJson(user))
// {"user_id":1,"full_name":"John"} — ไม่รวมรหัสผ่าน

การทำงานกับเจเนอริก

ปัญหาเจเนอริก ใน Java และ Kotlin คือการลบชนิดในเวลาคอมไพล์ เมื่อ Gson ดีซีเรียลไลซ์ List<User> มันไม่ทราบชนิดขององค์ประกอบและส่งคืน List<Map<String, Any>> เพื่อรักษาข้อมูลชนิด Gson มี TypeToken — คลาสนามธรรมที่จับพารามิเตอร์ชนิดผ่านคลาสนิรนาม หากไม่มี TypeToken นักพัฒนาจะต้องแปลงแต่ละองค์ประกอบจาก Map เป็นชนิดเป้าหมายด้วยตนเอง ซึ่งนำไปสู่โค้ดที่ยุ่งยากและประสิทธิภาพลดลง

TypeToken สำหรับรายการ

TypeToken แก้ปัญหาการลบชนิด นักพัฒนาสร้างคลาสย่อยนิรนามของ TypeToken ด้วยพารามิเตอร์ชนิดที่ต้องการ และ Gson ใช้ข้อมูลจากลายเซ็นคลาสเพื่อดีซีเรียลไลซ์อย่างถูกต้อง TypeToken ยังทำงานกับ Map, Set และชนิดพารามิเตอร์อื่น ๆ รวมถึงเจเนอริกที่ซ้อนกัน โดยเฉพาะอย่างยิ่งสำหรับ Map<String, List<User>> จำเป็นต้องใช้ TypeToken ที่มีลายเซ็นชนิดซ้อนกันแบบสมบูรณ์ มิฉะนั้น Gson จะดีซีเรียลไลซ์ค่าเป็น List<Map<String, Any>> แทนที่จะเป็น List<User>

// TypeToken สำหรับการดีซีเรียลไลเซชันรายการ
data class Product(
    val id: Int,
    val title: String,
    val price: Double
)

val jsonArray = """
[
    {"id":1,"title":"Phone","price":599.0},
    {"id":2,"title":"Laptop","price":1299.0}
]
"""

val gson = Gson()
val listType = object : TypeToken<List<Product>>() {}
val products: List<Product> =
    gson.fromJson(jsonArray, listType.type)

// ตัวดีซีเรียลไลเซอร์ที่กำหนดเอง
class LocalDateAdapter :
    JsonDeserializer<LocalDate> {

    override fun deserialize(
        json: JsonElement,
        typeOfT: java.lang.reflect.Type,
        context: JsonDeserializationContext
    ): LocalDate {
        return LocalDate.parse(json.asString)
    }
}

สำหรับลอจิกการซีเรียลไลเซชันที่กำหนดเอง Gson รองรับอินเทอร์เฟส JsonSerializer และ JsonDeserializer อินเทอร์เฟสเหล่านี้ลงทะเบียนผ่าน GsonBuilder.registerTypeAdapter() และอนุญาตให้จัดการชนิดที่ไลบรารีไม่สามารถซีเรียลไลซ์ได้โดยอัตโนมัติ: วันที่ Java 8, Enum ที่มีค่าที่ไม่ได้มาตรฐาน หรือคลาสของบุคคลที่สามโดยไม่สามารถเข้าถึงซอร์สโค้ดได้ เมื่อใช้อะแดปเตอร์ สิ่งสำคัญคือต้องตรวจสอบประสิทธิภาพ: การเรียกรีเฟลกชันภายในอะแดปเตอร์ที่กำหนดเองจะลบล้างข้อดีของการควบคุมด้วยตนเอง ดังนั้นควรใช้การเรียกเมธอดและฟิลด์โดยตรง ในระบบนิเวศ Gson ยังมีโมดูล gson-extras ที่ให้อะแดปเตอร์สำหรับชนิดทั่วไปเช่น UUID, Optional และวงล้อวันที่ Joda-Time

การกำหนดค่าผ่าน GsonBuilder

GsonBuilder มีเมธอดหลายสิบเมธอดสำหรับปรับแต่งการซีเรียลไลเซชันอย่างละเอียด setPrettyPrinting เพิ่มการเยื้องและขึ้นบรรทัดใหม่ใน JSON เอาต์พุตเพื่อให้อ่านง่าย disableHtmlEscaping ปิดใช้งานการหนีอักขระ HTML ในสตริง setDateFormat กำหนดรูปแบบวันที่ ซึ่งสำคัญเมื่อทำงานกับเซิร์ฟเวอร์ที่ใช้การแสดงเวลาที่ไม่ได้มาตรฐาน setLenient เปิดใช้งานโหมดการแยกวิเคราะห์แบบผ่อนปรน ซึ่งละเว้นข้อผิดพลาดการจัดรูปแบบ JSON บางอย่าง addDeserializationExclusionStrategy อนุญาตให้ยกเว้นฟิลด์จากการดีซีเรียลไลเซชันโดยทางโปรแกรมตามกลยุทธ์ที่กำหนดเอง สำหรับการดีบัก setPrettyPrinting ร่วมกับการบันทึกมีประโยชน์ — ทำให้การตอบสนอง JSON อ่านได้ในบันทึกและทำให้การค้นหาความไม่ตรงกันง่ายขึ้น

คุณสมบัติที่สำคัญของ GsonBuilder คือการจัดการเวอร์ชันฟิลด์ผ่านคำอธิบายประกอบ @Since และ @Until นักพัฒนาระบุเวอร์ชันวัตถุผ่าน setVersion และ Gson จะรวมหรือยกเว้นฟิลด์โดยอัตโนมัติตามคำอธิบายประกอบเวอร์ชันของฟิลด์ ซึ่งมีประโยชน์เมื่อ API พัฒนาขึ้นเมื่อโมเดลเดียวกันถูกใช้สำหรับเวอร์ชันต่าง ๆ ของโปรโตคอลเซิร์ฟเวอร์ GsonBuilder ยังรองรับการลงทะเบียน TypeAdapterFactory สำหรับการจัดการชนิดตระกูลทั่วโลกและ complexMapKeySerialization สำหรับการทำงานที่ถูกต้องกับคีย์ Map ที่ซับซ้อน