Moshi: मुख्य अवधारणाएँ, Kotlin के लिए JSON लाइब्रेरी और यह कैसे काम करती है

Moshi क्या है

Moshi JVM, Android और Kotlin Multiplatform के लिए एक JSON लाइब्रेरी है, जिसे Square (OkHttp और Retrofit के निर्माता) ने बनाया है। Gson के विपरीत, Moshi रिफ्लेक्शन पर निर्भर नहीं करती — एडेप्टर @JsonClass(generateAdapter = true) एनोटेशन के माध्यम से कंपाइल समय पर जेनरेट होते हैं। यह Moshi को Kotlin-विशिष्ट संरचनाओं के साथ काम करने में तेज़, सुरक्षित और अधिक पूर्वानुमेय बनाता है।

दर्शन और लाभ

Moshi और इसके पूर्ववर्तियों के बीच मुख्य अंतर रिफ्लेक्शन को त्यागना है। रिफ्लेक्शन Gson को बिना तैयारी के किसी भी क्लास के साथ काम करने की अनुमति देता है, लेकिन इसकी कीमत धीमी इनिशियलाइज़ेशन, कंपाइलर द्वारा ऑप्टिमाइज़ेशन की असंभवता और रनटाइम त्रुटियों का जोखिम है। Moshi को कोड जनरेशन के लिए क्लास की स्पष्ट घोषणा की आवश्यकता होती है, लेकिन बदले में यह हाथ से लिखे कोड की गति और कंपाइल समय पर पूर्ण टाइप सुरक्षा प्रदान करती है।

// Moshi को build.gradle में जोड़ें
dependencies {
    implementation "com.squareup.moshi:moshi:1.15.0"
    implementation "com.squareup.moshi:moshi-kotlin:1.15.0"
    kapt "com.squareup.moshi:moshi-kotlin-codegen:1.15.0"
}

// कोड जनरेशन के साथ सरल मॉडल
@JsonClass(generateAdapter = true)
data class User(
    @Json(name = "user_id")
    val id: Int,
    val name: String,
    val email: String,
    val avatar: String? = null
)

// उपयोग
val moshi = Moshi.Builder()
    .build()
val jsonAdapter = moshi.adapter(User::class.java)

इंस्टॉलेशन और कॉन्फ़िगरेशन

Moshi के साथ काम शुरू करने के लिए, build.gradle में डिपेंडेंसी जोड़ना और मॉडल को एनोटेट करना आवश्यक है। Moshi.Builder प्रवेश बिंदु के रूप में कार्य करता है: इसके माध्यम से मानक प्रकारों के लिए अंतर्निहित एडेप्टर, कस्टम एडेप्टर जोड़े जाते हैं और लाइब्रेरी का व्यवहार कॉन्फ़िगर किया जाता है। Moshi Date, Enum, Collection और Map के लिए एडेप्टर को बिना किसी अतिरिक्त कॉन्फ़िगरेशन के सपोर्ट करती है, लेकिन Kotlin क्लास के लिए moshi-kotlin मॉड्यूल की आवश्यकता होती है। Gson के विपरीत, Moshi डिफ़ॉल्ट रूप से Kotlin क्लास के लिए रिफ्लेक्शन का उपयोग नहीं करती — इसके लिए KotlinJsonAdapterFactory जोड़ा जाता है, जो बैकअप विकल्प के रूप में कार्य करता है जब कोड जनरेशन का उपयोग नहीं किया जाता है या क्लास @JsonClass से एनोटेट नहीं है। यह दृष्टिकोण सुनिश्चित करता है कि डेवलपर प्रत्येक विशिष्ट क्लास के लिए कोड जनरेशन के प्रदर्शन और रिफ्लेक्शन की लचीलेपन के बीच स्पष्ट रूप से चयन करता है।

Moshi बनाना और एडेप्टर जोड़ना

Builder के माध्यम से Moshi बनाने के बाद, डेवलपर को Moshi का एक इंस्टेंस मिलता है और वह आवश्यक क्लास के लिए एडेप्टर का अनुरोध करता है। JsonAdapter केंद्रीय ऑब्जेक्ट है जो toJson() के माध्यम से सीरियलाइज़ेशन और fromJson() के माध्यम से डीसीरियलाइज़ेशन करता है। Moshi स्वचालित रूप से जेनरेटेड एडेप्टर का उपयोग करती है यदि क्लास @JsonClass(generateAdapter = true) से एनोटेट है, अन्यथा बैकअप के रूप में रिफ्लेक्टिव KotlinJsonAdapterFactory लागू करती है। यह दृष्टिकोण किसी भी पैमाने और जटिलता के प्रोजेक्ट के लिए कोड जनरेशन की गति को रिफ्लेक्टिव तंत्र की लचीलेपन के साथ जोड़ता है। Moshi छोटे अनुप्रयोगों के साथ-साथ सैकड़ों डेटा मॉडल वाले बड़े कॉर्पोरेट प्रोजेक्ट के लिए भी उपयुक्त है।

// KotlinJsonAdapterFactory के साथ Moshi कॉन्फ़िगर करें
val moshi = Moshi.Builder()
    .add(KotlinJsonAdapterFactory())
    .add(LocalDateAdapter())
    .build()

// एडेप्टर का उपयोग
val adapter = moshi.adapter(User::class.java)

// सीरियलाइज़ेशन
val user = User(1, "Alice", "alice@test.com")
val json = adapter.toJson(user)

// डीसीरियलाइज़ेशन
val jsonString = """{"user_id":2,"name":"Bob","email":"bob@test.com"}"""
val parsedUser = adapter.fromJson(jsonString)

// सूची के साथ काम करना
val listAdapter = moshi.adapter(
    Types.newParameterizedType(
        List::class.java,
        User::class.java
    )
)

एनोटेशन और एडेप्टर

Moshi सीरियलाइज़ेशन को कॉन्फ़िगर करने और कस्टम प्रकारों का समर्थन करने के लिए एनोटेशन का उपयोग करती है। @Json(name = "...") फ़ील्ड के लिए JSON कुंजी सेट करता है। @Transient फ़ील्ड को सीरियलाइज़ेशन से बाहर कर देता है। @JsonClass(generateAdapter = true) कोड जनरेशन को सक्षम करता है। कस्टम लॉजिक के लिए, Moshi @ToJson और @FromJson एनोटेशन प्रदान करती है, जिन्हें एक अलग एडेप्टर क्लास में रखा जा सकता है।

@Json और कस्टम एडेप्टर

@Json एनोटेशन Gson के @SerializedName को बदलता है और समान रूप से काम करता है: kotlinName फ़ील्ड JSON कुंजी "kotlin_name" से जुड़ता है। उन प्रकारों के लिए जिन्हें Moshi डिफ़ॉल्ट रूप से सीरियलाइज़ नहीं कर सकती (जैसे LocalDate), डेवलपर @ToJson और @FromJson विधियों वाली एक क्लास बनाता है। एडेप्टर Moshi.Builder.add() के माध्यम से पंजीकृत होते हैं और वैश्विक रूप से या किसी विशिष्ट प्रकार पर लागू होते हैं। Moshi सील क्लास और @JsonClass के माध्यम से स्पष्ट डिस्क्रिमिनेटर के साथ पॉलीमॉर्फिक सीरियलाइज़ेशन का समर्थन करती है, जो मैन्युअल फ़ील्ड जाँच के बिना JSON में प्रकार पदानुक्रम के साथ काम करने की अनुमति देता है। डीसीरियलाइज़ेशन के दौरान, Moshi डिफ़ॉल्ट रूप से JSON में अज्ञात कुंजियों को अनदेखा करती है, जो क्लाइंट कोड को बदले बिना सर्वर साइड पर नए फ़ील्ड जोड़ने पर बैकवर्ड संगतता सुनिश्चित करती है। डिबगिंग के लिए, failOnUnknown के माध्यम से सख्त मोड सक्षम किया जा सकता है, जो अज्ञात कुंजियाँ मिलने पर अपवाद फेंकता है।

// LocalDate के लिए कस्टम एडेप्टर
class LocalDateAdapter {

    @ToJson
    fun toJson(date: LocalDate): String {
        return date.format(DateTimeFormatter.ISO_LOCAL_DATE)
    }

    @FromJson
    fun fromJson(dateString: String): LocalDate {
        return LocalDate.parse(dateString)
    }
}

// Moshi एनोटेशन वाला मॉडल
@JsonClass(generateAdapter = true)
data class Event(
    @Json(name = "event_id")
    val id: Int,

    @Json(name = "event_date")
    val date: LocalDate,

    @Transient
    val localCache: String? = null
)

// एडेप्टर पंजीकृत करें
val moshi = Moshi.Builder()
    .add(LocalDateAdapter())
    .add(KotlinJsonAdapterFactory())
    .build()

Moshi बनाम Gson

Moshi और Gson की तुलना Android प्रोजेक्ट के लिए JSON लाइब्रेरी चुनते समय एक सामान्य प्रश्न है। Moshi कोड जनरेशन, null सुरक्षा और गति के कारण आधुनिक Kotlin विकास में बेहतर है। Gson Java प्रोजेक्ट, लीगेसी कोड और उन परिदृश्यों के लिए प्रासंगिक बनी हुई है जहाँ न्यूनतम कॉन्फ़िगरेशन महत्वपूर्ण है। अंतर बड़े डेटा वॉल्यूम और जटिल मॉडल पर ध्यान देने योग्य हो जाता है।

प्रदर्शन और सुरक्षा

प्रदर्शन परीक्षण दिखाते हैं कि कोड जनरेशन के साथ Moshi, सीरियलाइज़ेशन और डीसीरियलाइज़ेशन संचालन पर Gson से 2–5 गुना तेज़ है। Moshi का मुख्य लाभ Kotlin की null सुरक्षा का सही संचालन है: यदि JSON में कोई फ़ील्ड गायब है और मॉडल इसे बिना डिफ़ॉल्ट मान के non-null घोषित करता है, तो Moshi डीसीरियलाइज़ेशन के समय एक अपवाद फेंकती है, जिससे छिपी त्रुटियों को रोका जा सकता है।

Moshi और Gson के बीच चुनाव प्रोजेक्ट के संदर्भ पर निर्भर करता है। Kotlin पर नए प्रोजेक्ट टाइप सुरक्षा और प्रदर्शन के कारण Moshi से लाभान्वित होते हैं। Gson Java कोड, गतिशील JSON संरचनाओं का समर्थन करने के लिए या जब कॉन्फ़िगरेशन की सरलता गति से अधिक महत्वपूर्ण हो, एक उचित विकल्प बना हुआ है। Kotlin Multiplatform के लिए, Moshi दो विकल्पों में से एकमात्र है जो इस प्लेटफ़ॉर्म का समर्थन करता है।

Gson से Moshi में माइग्रेट करते समय, मुख्य परिवर्तन एनोटेशन और एडेप्टर से संबंधित हैं। Gson के @SerializedName को @Json(name = "...") से बदल दिया जाता है, और कस्टम JsonSerializer/JsonDeserializer को @ToJson/@FromJson जोड़ी से बदल दिया जाता है। डिफ़ॉल्ट मान और nullable फ़ील्ड वाले मॉडल के लिए, Moshi अधिक पूर्वानुमेय व्यवहार करती है: यदि JSON में बिना डिफ़ॉल्ट के non-null फ़ील्ड गायब है, तो Moshi JsonDataException फेंकती है, जिससे छिपे NPE को रोका जा सकता है। MoshiConverterFactory के माध्यम से Retrofit के साथ एकीकरण एक डिपेंडेंसी के साथ जोड़ा जाता है और नेटवर्क परत की आर्किटेक्चर को बदलने की आवश्यकता नहीं होती है। ProGuard या R8 के माध्यम से ऑबफ़स्केशन के लिए, @JsonClass-एनोटेटेड क्लास और जेनरेटेड एडेप्टर को संरक्षित करने के नियम जोड़ने आवश्यक हैं, अन्यथा रिलीज़ बिल्ड में सीरियलाइज़ेशन टूट जाएगा। कुल मिलाकर, Gson से Moshi में माइग्रेशन नए Kotlin प्रोजेक्ट में उचित है जहाँ प्रदर्शन और टाइप सुरक्षा महत्वपूर्ण हैं।

// सीरियलाइज़ेशन तुलना: Gson बनाम Moshi
data class Sample(
    val name: String,
    val count: Int,
    val tags: List<String> = listOf()
)

// Gson: रिफ्लेक्शन के माध्यम से काम करता है
val gson = Gson()
val fromGson = gson.fromJson("""{"name":"test"}""",
    Sample::class.java)
// count = 0 (डिफ़ॉल्ट), लेकिन null सुरक्षा की जाँच नहीं की जाती

// Moshi: एडेप्टर की आवश्यकता है, null सुरक्षा स्पष्ट है
@JsonClass(generateAdapter = true)
data class SampleMoshi(
    val name: String,
    val count: Int,
    val tags: List<String> = listOf()
)