Kotlin में Long Polling बनाम WebSocket: रियल-टाइम के लिए क्या चुनें

Kotlin में Long Polling बनाम WebSocket: रियल-टाइम के लिए क्या चुनें

कल्पना करें: आप Kotlin में एक चैट, शेयर बाजार टर्मिनल या सर्वर मॉनिटरिंग सिस्टम लिख रहे हैं। क्लाइंट को तुरंत बदलाव देखने की आवश्यकता है। पारंपरिक HTTP अनुरोध "गया-जवाब दिया" यहाँ काम नहीं करेगा — डेटा अपने आप आना चाहिए, बिना उपयोगकर्ता द्वारा बार-बार पिंग किए।

Kotlin की दुनिया में दो लोकप्रिय दृष्टिकोण हैं: Long Polling और WebSocket। दोनों रियल-टाइम इंटरैक्शन को व्यवस्थित करने की अनुमति देते हैं, लेकिन वे इसे मौलिक रूप से अलग तरीके से करते हैं। कौन सा चुनें? आइए वास्तविक उदाहरणों के साथ समझते हैं, बिना अनावश्यक जानकारी और शैक्षणिक व्याख्यानों के।

Long Polling क्या है (और यह अभी भी प्रासंगिक क्यों है)

Long Polling एक तकनीक है जिसमें क्लाइंट एक HTTP अनुरोध भेजता है, और सर्वर तुरंत जवाब नहीं देता, बल्कि नए डेटा आने तक खुला रहता है। जैसे ही डेटा आता है — सर्वर जवाब भेजता है, क्लाइंट उसे प्रोसेस करता है और तुरंत एक नया अनुरोध खोलता है। चक्र दोहराया जाता है।

यह सामान्य HTTP जैसा दिखता है, लेकिन लंबे टाइमआउट के साथ। कोई अतिरिक्त प्रोटोकॉल नहीं, कोई हैंडशेक नहीं — सब कुछ मानक HTTP/1.1 या HTTP/2 पर काम करता है।

Kotlin पर Long Polling का उदाहरण (Ktor सर्वर + OkHttp क्लाइंट)

Ktor पर सर्वर साइड (सर्वर तब तक प्रतीक्षा करेगा जब तक कोई संदेश न आए):

import io.ktor.server.engine.*\nimport io.ktor.server.netty.*\nimport io.ktor.server.routing.*\nimport io.ktor.server.response.*\nimport io.ktor.http.*\nimport kotlinx.coroutines.*\n\nfun main() {\n    embeddedServer(Netty, port = 8080) {\n        routing {\n            get("/long-poll") {\n                // नए संदेश की प्रतीक्षा का अनुकरण\n                val message = withContext(Dispatchers.Default) {\n                    delay(5000) // 5 सेकंड प्रतीक्षा करें (या नई घटना)\n                    "नया संदेश: ${System.currentTimeMillis()}"\n                }\n                call.respondText(message, ContentType.Text.Plain)\n            }\n        }\n    }.start(wait = true)\n}\n

OkHttp पर क्लाइंट:

import okhttp3.*\n\nval client = OkHttpClient.Builder()\n    .readTimeout(30, TimeUnit.SECONDS) // महत्वपूर्ण बिंदु!\n    .build()\n\nfun startLongPolling() {\n    val request = Request.Builder()\n        .url("http://localhost:8080/long-poll")\n        .build()\n\n    client.newCall(request).enqueue(object : Callback {\n        override fun onFailure(call: Call, e: IOException) {\n            e.printStackTrace()\n            // त्रुटि होने पर polling को पुनः प्रारंभ करना अनिवार्य है\n            startLongPolling()\n        }\n\n        override fun onResponse(call: Call, response: Response) {\n            response.use {\n                if (response.isSuccessful) {\n                    println("प्राप्त: ${response.body?.string()}")\n                    // तुरंत अगला अनुरोध प्रारंभ करें\n                    startLongPolling()\n                }\n            }\n        }\n    })\n}\n

Long Polling के लाभ:

\n
• हर जगह काम करता है, यहां तक कि कॉर्पोरेट प्रॉक्सी और पुराने ब्राउज़रों में भी
\n
• सरल डिबगिंग — आप लॉग में सामान्य HTTP अनुरोध देखते हैं
\n
• मौजूदा बुनियादी ढांचे (लोड बैलेंसर, कैश, CDN) में आसानी से एकीकृत होता है
\n

नुकसान:

\n
• उच्च विलंबता — अनुरोध भेजने और प्रतिक्रिया प्राप्त करने के बीच RTT (Round Trip Time) तक का समय लग सकता है
\n
• सर्वर कई खुले कनेक्शन रखता है (प्रत्येक अनुरोध एक अलग थ्रेड/कोरूटीन है)
\n
• पुनः कनेक्ट करने पर संदेश खो सकते हैं (यदि आइडेम्पोटेंसी लागू नहीं की गई है)
\n

WebSocket: पूर्ण डुप्लेक्स

WebSocket एक अलग प्रोटोकॉल (ws://) है जो HTTP हैंडशेक के बाद एक स्थायी द्विदिश कनेक्शन स्थापित करता है। सर्वर और क्लाइंट किसी भी समय संदेश भेज सकते हैं, बिना हेडर के ओवरहेड के।

Kotlin पर WebSocket का उदाहरण (Ktor सर्वर + Ktor क्लाइंट)<