गो

Question

में क्लाइंट यूडीपी सॉकेट को लिखें, मैं गो भाषा में यूडीपी सॉकेट के साथ क्लाइंट/सर्वर संचार के लिए एक अच्छा समाधान ढूंढ रहा हूं।

इंटरनेट पर मिले उदाहरण मुझे दिखाते हैं कि सर्वर को डेटा कैसे भेजना है, लेकिन वे उन्हें क्लाइंट को वापस भेजने के तरीके को नहीं सिखाते हैं।

प्रदर्शित करने के लिए मेरा कार्यक्रम निम्नलिखित करता है,:,

con, err := net.Dial("udp", "127.0.0.1:4444") 

मैं सर्वर के लिए एक स्ट्रिंग और स्थानीय पते भेजा:

मेरे क्लाइंट प्रोग्राम 4444 पोर्ट पर एक सॉकेट बनाता है, इस तरह तो यह स्ट्रिंग मुद्रित कर सकता है और एक ठीक संदेश भेज सकता है। मैं इसके लिए खखार उपयोग कर रहा हूँ:

enc := gob.NewEncoder(con) 
enc.Encode(Data{"test", con.LocalAddr().String()}) 

मेरे डेटा struct इस तरह दिखता है:

type Data struct{ 
    Msg string 
    Addr string 
} 

मेरे सर्वर 4444 बंदरगाह को सुनता है और सही ढंग से थूक डीकोड, लेकिन मैं कैसे ठीक संदेश वापस भेज सकते हैं ? मैं ग्राहक पते का उपयोग कर रहा ऐसा करने के लिए (सर्वर पर .go फ़ाइल):

con, err := net.Dial("udp", data.Addr) 

फिर, मैं एक त्रुटि कोड प्राप्त:

write udp 127.0.0.1:35290: connection refused 

ग्राहक सर्वर से कनेक्ट करने का प्रयास करता है पोर्ट 4444, क्लाइंट एक यादृच्छिक संख्या वाला एक बंदरगाह बनाता है (इस मामले में, 352 9 0) ताकि वे संवाद कर सकें। मुझे पता है कि मुझे सर्वर पर क्लाइंट का पता नहीं पारित करना चाहिए, लेकिन conn.RemoteAddress() काम नहीं करता है। एक समाधान जो ग्राहक के पते की खोज करता है उसकी सराहना की जाएगी।

Obs .: मुझे पता है कि ReadFromUDP है, इसलिए मैं पैकेज पढ़ सकता हूं। क्या मुझे इसे पढ़ना चाहिए, ग्राहक का पता खोजना चाहिए, और डेटा को गोब को भेजना चाहिए ताकि यह इसे डीकोड कर सके?

Answer 1

यूडीपी पर ग्राहक/सर्वर संचार के लिए नीचे दिए गए नमूने देखें। SendResponse routine क्लाइंट को प्रतिक्रिया भेजने के लिए है। का उपयोग करते हुए [ReadFromUDP] (http://godoc.org/net#UDPConn.ReadFromUDP)

udpclient.go

package main 
import (
    "fmt" 
    "net" 
    "bufio" 
) 

func main() { 
    p := make([]byte, 2048) 
    conn, err := net.Dial("udp", "127.0.0.1:1234") 
    if err != nil { 
     fmt.Printf("Some error %v", err) 
     return 
    } 
    fmt.Fprintf(conn, "Hi UDP Server, How are you doing?") 
    _, err = bufio.NewReader(conn).Read(p) 
    if err == nil { 
     fmt.Printf("%s\n", p) 
    } else { 
     fmt.Printf("Some error %v\n", err) 
    } 
    conn.Close() 
} 

udpserver.go

package main 
import (
    "fmt" 
    "net" 
) 


func sendResponse(conn *net.UDPConn, addr *net.UDPAddr) { 
    _,err := conn.WriteToUDP([]byte("From server: Hello I got your mesage "), addr) 
    if err != nil { 
     fmt.Printf("Couldn't send response %v", err) 
    } 
} 


func main() { 
    p := make([]byte, 2048) 
    addr := net.UDPAddr{ 
     Port: 1234, 
     IP: net.ParseIP("127.0.0.1"), 
    } 
    ser, err := net.ListenUDP("udp", &addr) 
    if err != nil { 
     fmt.Printf("Some error %v\n", err) 
     return 
    } 
    for { 
     _,remoteaddr,err := ser.ReadFromUDP(p) 
     fmt.Printf("Read a message from %v %s \n", remoteaddr, p) 
     if err != nil { 
      fmt.Printf("Some error %v", err) 
      continue 
     } 
     go sendResponse(ser, remoteaddr) 
    } 
}