Go中的双向连接

huangapple
go评论112阅读模式
英文:

Two way connections in Go

问题

我正在尝试使用Go语言制作一个简单的控制台聊天程序，只是为了练习。然而，我不知道如何从服务器发送消息回来。服务器只接收消息然后关闭连接。我该如何发送响应呢？

我已经搜索到了关于WebSockets的信息，但我认为它们是用于与浏览器进行交互的。

这是服务器的两个函数：

  1. func runServer() {
  2.     // 监听端口
  3.     listen, error := net.Listen("tcp", ":8272")
  5.     // 处理可能的错误
  6.     if error != nil {
  7.         fmt.Println(error)
  8.         return
  9.     }
  11.     fmt.Println("正在监听端口 8272.")
  13.     for {
  14.         // 接受连接
  15.         con, error := listen.Accept()
  17.         // 处理可能的错误
  18.         if error != nil {
  19.             fmt.Println(error)
  20.             continue
  21.         }
  23.         fmt.Println("连接已接受.")
  25.         // 处理连接
  26.         go handleConnection(con)
  27.     }
  28. }
  30. func handleConnection(con net.Conn) {
  31.     fmt.Println("处理连接.")
  33.     var message string
  35.     // 解码接收到的消息
  36.     decoder := gob.NewDecoder(con)
  37.     error := decoder.Decode(&message)
  39.     // 检查错误
  40.     if error != nil {
  41.         fmt.Println(error)
  42.     } else {
  43.         fmt.Println("接收到消息：", message)
  44.     }
  46.     // 关闭连接
  47.     con.Close()
  48.     fmt.Println("连接已关闭.")
  49. }

这是客户端的函数：

  1. func runClient() {
  2.     // 连接服务器
  3.     con, error := net.Dial("tcp", "127.0.0.1:8272")
  5.     // 处理可能的错误
  6.     if error != nil {
  7.         fmt.Println(error)
  8.         return
  9.     }
  11.     fmt.Println("已连接到 127.0.0.1:8272.")
  13.     // 发送消息
  14.     message := "Hello world"
  15.     encoder := gob.NewEncoder(con)
  16.     error = encoder.Encode(message)
  18.     // 检查错误
  19.     if error != nil {
  20.         fmt.Println(error)
  21.     }
  23.     con.Close()
  25.     fmt.Println("消息已发送。连接已关闭.")
  26. }

希望能对你有所帮助。

英文:

I am trying to make a simple console chat in Go, just to practice. However, I don't know how to send messages back from the server. The server just receives a message and then closes the connection. How could I send a response?

I have been searching and found information about websockets, but I think that they are used to interact with browsers.

This are the two functions of the server:

  1. func runServer() {
  2. 	// Listen on a port
  3. 	listen, error := net.Listen("tcp", ":8272")
  5. 	// Handles eventual errors
  6. 	if error != nil {
  7. 		fmt.Println(error)
  8. 		return
  9. 	}
  11. 	fmt.Println("Listening in port 8272.")
  13. 	for {
  14. 		// Accepts connections
  15. 		con, error := listen.Accept()
  17. 		// Handles eventual errors
  18. 		if error != nil {
  19. 			fmt.Println(error)
  20. 			continue
  21. 		}
  23. 		fmt.Println("Connection accepted.")
  25. 		// Handles the connection
  26. 		go handleConnection(con)
  27. 	}
  28. }
  30. func handleConnection(con net.Conn) {
  31. 	fmt.Println("Handling connection.")
  33. 	var message string
  35. 	// Decodes the received message
  36. 	decoder := gob.NewDecoder(con)
  37. 	error := decoder.Decode(&message)
  39. 	// Checks for errors
  40. 	if error != nil {
  41. 		fmt.Println(error)
  42. 	} else {
  43. 		fmt.Println("Received", message)
  44. 	}
  46. 	// Closes the connection
  47. 	con.Close()
  48. 	fmt.Println("Connection closed.")
  49. }

This is the function of the client:

  1. func runClient() {
  2. 	// Connects to server
  3. 	con, error := net.Dial("tcp", "127.0.0.1:8272")
  5. 	// Handles eventual errors
  6. 	if error != nil {
  7. 		fmt.Println(error)
  8. 		return
  9. 	}
  11. 	fmt.Println("Connected to 127.0.0.1:8272.")
  13. 	// Sends a message
  14. 	message := "Hello world"
  15. 	encoder := gob.NewEncoder(con)
  16. 	error = encoder.Encode(message)
  18. 	// Checks for errors
  19. 	if error != nil {
  20. 		fmt.Println(error)
  21. 	}
  23. 	con.Close()
  25. 	fmt.Println("Message sent. Connection closed.")
  26. }

Thanks in advance.

答案1

得分: 4

您的con对象是一个连接，其中包含了Read和Write方法，可以在这里找到详细描述：这里。您应该在连接上循环，尝试Read传入的数据，然后处理它并（可能）Write回服务器的响应。（在这里，bufferio包等可以帮助您以更方便的方式处理数据，这只是底层的ReadWriter接口）

文档中展示了一个简单的示例：

  1. go func(c net.Conn) {
  2.     // 回显所有传入的数据。
  3.     io.Copy(c, c)
  4.     // 关闭连接。
  5.     c.Close()
  6. }(conn)

该示例只处理第一条消息，然后关闭连接。您可以像这样处理每条传入的消息：

  1. go func(c net.Conn) {
  2.     // 无限循环：获取数据，复制它们，然后重新开始
  3.     for {
  4.         // 回显所有传入的数据。
  5.         io.Copy(c, c)
  6.     }
  7.     // 关闭连接。
  8.     c.Close()
  9. }(conn)

当然，您可以根据您的服务器将io.Copy替换为相应的处理逻辑，所以您的示例可能是这样的：

  1. func handleConnection(con net.Conn) {
  2.     fmt.Println("处理连接。")
  3.     
  4.     defer func() {
  5.         // 关闭连接
  6.         con.Close()
  7.         fmt.Println("连接已关闭。")
  8.     }()
  9.     
  10.     var message string
  11.     
  12.     // 解码接收到的消息
  13.     decoder := gob.NewDecoder(con)
  14.     encoder := gob.NewEncoder(con)
  15.     for {
  16.         error := decoder.Decode(&message)
  17.         
  18.         // 检查错误
  19.         if error != nil {
  20.             fmt.Println(error)
  21.             // 退出循环
  22.             return
  23.         } else {
  24.             fmt.Println("接收到：", message)
  25.             // 发送回复
  26.             if error = encoder.Encode(message); error != nil {
  27.                 fmt.Println(error)
  28.                 return
  29.             } else {
  30.                 fmt.Println("回显成功！等待下一条消息...")
  31.             }
  32.         }
  33.     }
  34. }

此外，您可能应该在日志消息中使用log包而不是fmt包（但这在这里并不重要）。

了解它是如何工作的一个好方法是浏览默认的http服务器的实现代码这里。

类似地，您的客户端应该使用相同的模式进行循环：

  1. LOOP:
  2.     发送数据（例如 encoder.Encode）
  3.     接收数据（例如 decoder.Decode）
  4.     如果有问题或终止 -> 退出循环
  5. END
  6. 关闭连接
英文:

Your con object is a connection, which has Read and Write methods described here: here. You should loop on the connection, trying to Read incoming data, then process it and (possibly) Write back the server response. (Here, bufferiopackage and the like can help you process it in a more convenient way, this is just the low-level ReadWriter interface)

The documentation shows a tiny example:

  1. go func(c net.Conn) {
  2.     // Echo all incoming data.
  3.     io.Copy(c, c)
  4.     // Shut down the connection.
  5.     c.Close()
  6. }(conn)

Which processes only the first message and then closes. You can process each incoming message like this:

  1. go func(c net.Conn) {
  2.     // Infinite loop: Get data, copy them and start over
  3.     for {
  4.         // Echo all incoming data.
  5.         io.Copy(c, c)
  6.     }
  7.     // Shut down the connection.
  8.     c.Close()
  9. }(conn)

Replacing io.Copy with whatever is relevant to your server of course, so your example would be something like this:

  1. func handleConnection(con net.Conn) {
  2.     fmt.Println("Handling connection.")
  3.     
  4.     defer func() {
  5.         // Closes the connection
  6.         con.Close()
  7.         fmt.Println("Connection closed.")
  8.     }()
  10.     var message string
  11.     
  12.     // Decodes the received message
  13.     decoder := gob.NewDecoder(con)
  14.     encoder := gob.NewEncoder(con)
  15.     for {
  16.         error := decoder.Decode(&message)
  18.         // Checks for errors
  19.         if error != nil {
  20.             fmt.Println(error)
  21.             // Exit the loop
  22.             return
  23.         } else {
  24.             fmt.Println("Received", message)
  25.             // Sending back
  26.             if error = encoder.Encode(message); error != nil {
  27.                  fmt.Println(error)
  28.                  return
  29.             } else {
  30.                 fmt.Println("Echo'd successfuly ! Waiting for next message...")
  31.             }
  32.         }
  33.     }
  34. }

Also, you should probably use package log instead of fmt for your logging messages (but this is irrelevant here).

A good place to understand how it all works is to browse the implementation of the default http server here.

Similarly, your client should loop using the same pattern:

  1. LOOP:
  2.     Send data (e.g. encoder.Encode)
  3.     Receive data (e.g. decoder.Decode)
  4.     if problem or termination -> break out of loop
  5. END
  6. close connection

huangapple
  • 本文由 发表于 2013年8月14日 19:57:56
  • 转载请务必保留本文链接：https://go.coder-hub.com/18231129.html
  • go
匿名

发表评论

匿名网友

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

确定