Gson — apa itu, library JSON untuk Java dan Kotlin

Apa itu Gson

Gson — adalah library Java yang dikembangkan oleh Google untuk mengonversi objek ke representasi JSON dan sebaliknya. Ini menggunakan refleksi untuk menganalisis struktur kelas, memungkinkan bekerja tanpa konfigurasi awal. Gson mendukung objek Java arbitrer, koleksi, array, generik, dan kelas bersarang. Library tidak memerlukan anotasi untuk penggunaan dasar, tetapi menyediakannya untuk penyesuaian yang presisi. Kerugian utama refleksi adalah penurunan kinerja saat inisialisasi dan ketidakmampuan untuk mengoptimalkan pada tahap kompilasi, yang terutama terlihat pada cold start aplikasi Android saat mendeserialisasi ratusan model. Meskipun demikian, Gson tetap menjadi pilihan yang andal untuk sebagian besar proyek berkat stabilitas dan dokumentasi yang luas.

Sejarah dan tempat dalam ekosistem

Gson dirilis oleh Google pada tahun 2008 dan dengan cepat menjadi standar de facto untuk JSON di aplikasi Android. Sebelum munculnya Moshi dan kotlinx.serialization, Gson tetap menjadi satu-satunya pilihan populer untuk proyek Kotlin. Kesederhanaan koneksi — menambahkan satu dependensi di build.gradle — dan tidak adanya anotasi wajib membuat Gson populer di kalangan pengembang dari semua tingkatan.

// Menambahkan Gson di build.gradle
dependencies {
    implementation 'com.google.code.gson:gson:2.10.1'
}

// Penggunaan dasar
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"}

Selain serialisasi dasar, Gson menyediakan GsonBuilder untuk mengonfigurasi perilaku: pemformatan tanggal, menonaktifkan escape HTML, registri kunci, dan instance kustom. GsonBuilder juga memungkinkan pendaftaran JsonSerializer dan JsonDeserializer kustom untuk tipe yang tidak dapat diproses secara otomatis oleh library. Fleksibilitas konfigurasi menjadikan GsonBuilder alat yang sangat diperlukan dan berguna saat menyesuaikan library dengan kebutuhan spesifik proyek dalam pengembangan Android modern.

Operasi dasar toJson dan fromJson

toJson mengonversi objek Java menjadi string JSON, menganalisis bidangnya melalui refleksi. Secara default, Gson menyertakan semua bidang kecuali transient dan static. Metode ini mendukung semua tipe: primitif, objek, koleksi, dan array. fromJson melakukan konversi terbalik, menerima string JSON dan kelas objek target, dan mengembalikan instance dengan bidang yang terisi.

Mengonversi objek ke JSON

Saat serialisasi, Gson menelusuri secara rekursif semua bidang objek, termasuk yang bersarang. Referensi siklik menyebabkan StackOverflowError, jadi harus dikecualikan melalui anotasi @Expose atau adapter kustom. Untuk koleksi, Gson mempertahankan tipe elemen, tetapi saat mendeserialisasi daftar dengan generik, TypeToken diperlukan untuk mempertahankan informasi tentang tipe.

// data class dengan objek bersarang
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"))

// Serialisasi ke JSON
val json = gson.toJson(employee)

// Deserialisasi dari JSON
val jsonString = """
{"id":2,"name":"Bob","address":{"city":"London","street":"Baker St"}}
"""
val parsed = gson.fromJson(jsonString, Employee::class.java)

Anotasi dan konfigurasi

Gson menyediakan serangkaian anotasi untuk mengelola proses serialisasi. @SerializedName menentukan nama kunci JSON yang berbeda dari nama bidang. @Expose mengelola penyertaan bidang dalam serialisasi: Gson yang dibuat melalui GsonBuilder.excludeFieldsWithoutExposeAnnotation() hanya akan memproses bidang dengan @Expose. @Since dan @Until mengontrol versi bidang.

@SerializedName dan @Expose

Anotasi @SerializedName memecahkan masalah ketidakcocokan nama: server mungkin menggunakan snake_case, sementara dalam kode digunakan camelCase. Anotasi menerima nilai dan alternatif opsional untuk kompatibilitas mundur. @Expose memungkinkan menyembunyikan bidang sensitif (kata sandi, token) dari serialisasi dengan menandainya sebagai @Expose(serialize = false). Selain menyertakan dan mengecualikan, @Expose dapat dikombinasikan dengan GsonBuilder.excludeFieldsWithoutExposeAnnotation untuk membuat daftar putih bidang, yang membantu mengontrol permukaan serangan saat menserialisasi objek dengan jumlah bidang yang banyak.

// Model dengan anotasi 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 dengan filter @Expose
val gson = GsonBuilder()
    .excludeFieldsWithoutExposeAnnotation()
    .setPrettyPrinting()
    .create()

val user = UserResponse(1, "John", "secret123")
println(gson.toJson(user))
// {"user_id":1,"full_name":"John"} — password excluded

Bekerja dengan generik

Masalah generik di Java dan Kotlin terletak pada penghapusan tipe selama kompilasi. Ketika Gson mendeserialisasi List<User>, ia tidak mengetahui tipe elemen dan mengembalikan List<Map<String, Any>>. Untuk mempertahankan informasi tentang tipe, Gson menyediakan TypeToken — kelas abstrak yang menangkap parameter tipe melalui kelas anonim. Tanpa TypeToken, pengembang harus mengonversi secara manual setiap elemen dari Map ke tipe target, yang menyebabkan kode yang rumit dan hilangnya kinerja.

TypeToken untuk daftar

TypeToken memecahkan masalah penghapusan tipe. Pengembang membuat turunan anonim dari TypeToken dengan parameter tipe yang diperlukan, dan Gson menggunakan informasi dari tanda tangan kelas untuk deserialisasi yang benar. TypeToken juga berfungsi dengan Map, Set, dan tipe terparameterisasi lainnya, termasuk generik bersarang. Khususnya, untuk Map<String, List<User>>, diperlukan TypeToken dengan tanda tangan lengkap dari tipe bersarang, jika tidak Gson akan mendeserialisasi nilai sebagai List<Map<String, Any>> alih-alih List<User>.

// TypeToken untuk deserialisasi daftar
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)

// Deserialisator kustom
class LocalDateAdapter :
    JsonDeserializer<LocalDate> {

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

Untuk logika serialisasi kustom, Gson mendukung antarmuka JsonSerializer dan JsonDeserializer. Mereka didaftarkan melalui GsonBuilder.registerTypeAdapter() dan memungkinkan pemrosesan tipe yang tidak dapat diserialisasi secara otomatis oleh library: tanggal Java 8, Enum dengan nilai non-standar, atau kelas pihak ketiga tanpa akses ke kode sumber. Saat mengimplementasikan adapter, penting untuk memantau kinerja: pemanggilan refleksi di dalam adapter kustom meniadakan keuntungan manajemen manual, jadi panggilan langsung metode dan bidang lebih diutamakan. Di ekosistem Gson juga terdapat modul gson-extras yang menyediakan adapter untuk tipe umum seperti UUID, Optional, dan tipe tanggal Joda-Time.

Konfigurasi melalui GsonBuilder

GsonBuilder menyediakan puluhan metode untuk penyesuaian serialisasi yang presisi. setPrettyPrinting menambahkan indentasi dan baris baru ke JSON keluaran untuk keterbacaan. disableHtmlEscaping menonaktifkan escape karakter HTML dalam string. setDateFormat menetapkan format tanggal, yang sangat penting saat bekerja dengan server yang menggunakan representasi waktu non-standar. setLenient mengaktifkan mode parsing longgar yang mengabaikan beberapa kesalahan pemformatan JSON. addDeserializationExclusionStrategy memungkinkan pengecualian bidang secara terprogram dari deserialisasi berdasarkan strategi kustom. Untuk debugging, metode setPrettyPrinting berguna dikombinasikan dengan logging — membuat respons JSON dapat dibaca di log dan menyederhanakan pencarian ketidaksesuaian.

Kemampuan penting GsonBuilder adalah mengelola versi bidang melalui anotasi @Since dan @Until. Pengembang menentukan versi objek melalui setVersion, dan Gson secara otomatis menyertakan atau mengecualikan bidang tergantung pada anotasi versi mereka. Ini berguna dalam evolusi API, ketika model yang sama digunakan untuk versi protokol server yang berbeda. GsonBuilder juga mendukung pendaftaran TypeAdapterFactory untuk pemrosesan global keluarga tipe dan complexMapKeySerialization untuk bekerja dengan benar dengan kunci Map yang kompleks.