Go में Long Polling vs WebSocket: रियल-टाइम एप्लीकेशन के लिए सही तकनीक

परिचय: डेवलपर की दुविधा

कल्पना कीजिए: आप Go में एक चैट एप्लीकेशन, शेयर बाजार का टर्मिनल या ऑनलाइन गेम बना रहे हैं। क्लाइंट को तुरंत अपडेट चाहिए। पुराना AJAX पोलिंग (बार-बार रिक्वेस्ट भेजना) काम नहीं करेगा — इससे सर्वर और यूजर की बैटरी दोनों पर बुरा असर पड़ता है। दो विकल्प बचते हैं: Long Polling (लंबा पोल) और WebSocket।

दोनों ही 'रियल-टाइम' की समस्या हल करते हैं, लेकिन तरीका बिल्कुल अलग है। आपके Go एप्लीकेशन के लिए कौन सा सही है? आइए, बिना घुमाए, कोड उदाहरणों और ईमानदार फायदे-नुकसान के साथ समझते हैं। यह लेख Go में रियल-टाइम कम्युनिकेशन की दुनिया में आपका मार्गदर्शक है।

Go में Long Polling क्या है?

Long Polling, सामान्य polling का उन्नत रूप है। क्लाइंट सर्वर को HTTP रिक्वेस्ट भेजता है, लेकिन अगर डेटा नहीं है तो सर्वर तुरंत जवाब नहीं देता। वह कनेक्शन को खुला रखता है और नई घटना (event) का इंतज़ार करता है। जैसे ही कोई घटना होती है, सर्वर जवाब भेजता है और क्लाइंट तुरंत नया Long Polling रिक्वेस्ट शुरू कर देता है। यह चक्र दोहराया जाता है।

Go में, गोरूटीन (goroutines) और चैनल (channels) की मदद से इसे बहुत ही सुंदर तरीके से लागू किया जा सकता है। सर्वर डेटा आने तक रिक्वेस्ट हैंडलर को 'सुला' सकता है।

Go में Long Polling सर्वर का उदाहरण

package main\n\nimport (\n    "fmt"\n    "net/http"\n    "time"\n)\n\n// चैनल जिसमें नए संदेश आते हैं\nvar messages = make(chan string, 10)\n\nfunc longPollHandler(w http.ResponseWriter, r *http.Request) {\n    select {\n    case msg := <-messages:\n        fmt.Fprintf(w, "नया संदेश: %s", msg)\n    case <-time.After(30 * time.Second):\n        // टाइमआउट — अगर 30 सेकंड में कोई संदेश नहीं आया\n        http.Error(w, "Timeout", http.StatusGatewayTimeout)\n    }\n}\n\nfunc main() {\n    // गोरूटीन जो नए संदेशों का अनुकरण करती है\n    go func() {\n        for {\n            time.Sleep(5 * time.Second)\n            messages <- fmt.Sprintf("समय: %s", time.Now().String())\n        }\n    }()\n\n    http.HandleFunc("/poll", longPollHandler)\n    http.ListenAndServe(":8080", nil)\n}\n

JavaScript में क्लाइंट कुछ इस तरह दिखेगा: जवाब (या टाइमआउट) मिलने के बाद वह तुरंत /poll को फिर से कॉल करता है। सरल, विश्वसनीय, और किसी भी प्रॉक्सी या फायरवॉल के साथ काम करता है।

Go में WebSocket: पूर्ण द्विदिश संचार

WebSocket एक प्रोटोकॉल है जो हैंडशेक (HTTP Upgrade) के बाद कनेक्शन को एक स्थायी द्विदिश चैनल में बदल देता है। सर्वर किसी भी समय क्लाइंट को डेटा भेज सकता है, और क्लाइंट भी सर्वर को। बार-बार रिक्वेस्ट या टाइमआउट की कोई ज़रूरत नहीं।

Go की मानक लाइब्रेरी में WebSocket के लिए अंतर्निहित समर्थन नहीं है, लेकिन एक सुनहरा मानक है — gorilla/websocket पैकेज। यह स्थिर, अच्छी तरह से प्रलेखित है और हज़ारों प्रोजेक्ट्स में प्रोडक्शन में उपयोग होता है।

Go में WebSocket सर्वर का उदाहरण

package main\n\nimport (\n    "log"\n    "net/http"\n    "time"\n\n    "github.com/gorilla/websocket"\n)\n\nvar upgrader = websocket.Upgrader{\n    CheckOrigin: func(r *http.Request) bool {\n        return true // डेवलपमेंट के लिए। प्रोडक्शन में जाँच करें!\n    },\n}\n\nfunc wsHandler(w http.ResponseWriter, r *http.Request) {\n    conn, err := upgrader.Upgrade(w, r, nil)\n    if err != nil {\n        log.Print("Upgrade failed:", err)\n        return\n    }\n    defer conn.Close()\n\n    // पढ़ने और लिखने का अनंत लूप\n    for {\n        // क्लाइंट से संदेश पढ़ें\n        _, message, err := conn.ReadMessage()\n        if err != nil {\n            log.Println("Read error:", err)\n            break\n        }\n        log.Printf("प्राप्त: %s", message)\n\n        // जवाब (या पुश नोटिफिकेशन) भेजें\n        err = conn.WriteMessage(websocket.TextMessage, []byte("सर्वर: "+time.Now().String()))\n        if err != nil {\n            log.Println("Write error:", err)\n            break\n        }\n    }\n}\n\nfunc main() {\n    http.HandleFunc("/ws", wsHandler)\n    log.Pr