Go语言Socket：TCP 和 UDP 示例详解

mrkong

在网络编程中，Socket（套接字）是一个非常重要的概念。它是一个抽象的数据结构，用于表示网络中的一个端点，包含了 IP 地址、端口号以及协议类型等信息。Go 语言提供了强大的 net 包，使得 Socket 编程变得更加简便。本文将详细介绍 Go 语言如何实现 TCP 和 UDP Socket 编程。

1. Socket 编程基本原理

Socket 编程基于客户端-服务器模型，其中：

• 客户端：发起请求的一方。
• 服务器：提供服务的一方。
  
  

通过 Socket，客户端可以向服务器发送请求，服务器接收到请求后进行处理并返回响应。

常见的协议类型

• TCP（传输控制协议）：面向连接的协议，可靠、保证数据有序传输，适用于对数据传输有严格要求的场景。
• UDP（用户数据报协议）：无连接的协议，不保证数据可靠传输，适用于对实时性要求较高的场景。
  
  

Go 语言通过 net 包提供了对这两种协议的支持，使得开发者能够轻松实现网络通信。

2. TCP Socket 编程2.1 服务器端实现

TCP 是一种面向连接的协议，适合需要可靠数据传输的场景。以下是一个简单的 TCP 服务器实现，它会监听指定端口并回显接收到的消息。

1. package main
   
2. 
   
3. import (
   
4.     "bufio"
   
5.     "fmt"
   
6.     "net"
   
7. )
   
8. 
   
9. func handleConnection(conn net.Conn) {
   
10.     defer conn.Close()
    
11.     reader := bufio.NewReader(conn)
    
12.     for {
    
13.         // 读取客户端发送的数据
    
14.         message, err := reader.ReadString('\n')
    
15.         if err != nil {
    
16.             fmt.Println("读取数据错误:", err)
    
17.             break
    
18.         }
    
19.         fmt.Printf("收到消息: %s", message)
    
20.         // 回显消息给客户端
    
21.         conn.Write([]byte("Echo: " + message))
    
22.     }
    
23. }
    
24. 
    
25. func main() {
    
26.     // 监听本地 8080 端口
    
27.     listener, err := net.Listen("tcp", ":8080")
    
28.     if err != nil {
    
29.         fmt.Println("监听端口失败:", err)
    
30.         return
    
31.     }
    
32.     defer listener.Close()
    
33.     fmt.Println("服务器正在监听端口 8080...")
    
34. 
    
35.     for {
    
36.         // 接受客户端连接
    
37.         conn, err := listener.Accept()
    
38.         if err != nil {
    
39.             fmt.Println("接受连接失败:", err)
    
40.             continue
    
41.         }
    
42.         // 为每个连接启动一个新的 goroutine 进行处理
    
43.         go handleConnection(conn)
    
44.     }
    
45. }
    

复制代码

说明：

• 使用 net.Listen 监听指定的 IP 地址和端口。
• 通过 listener.Accept 接受客户端的连接，返回一个 net.Conn 对象。
• 每当接收到一个连接时，通过 goroutine 并发处理该连接。
  
  

2.2 客户端实现

以下是一个简单的 TCP 客户端示例，连接到服务器并发送消息。

1. package main
   
2. 
   
3. import (
   
4.     "bufio"
   
5.     "fmt"
   
6.     "net"
   
7.     "os"
   
8. )
   
9. 
   
10. func main() {
    
11.     // 连接到服务器（localhost:8080）
    
12.     conn, err := net.Dial("tcp", "localhost:8080")
    
13.     if err != nil {
    
14.         fmt.Println("连接服务器失败:", err)
    
15.         return
    
16.     }
    
17.     defer conn.Close()
    
18. 
    
19.     reader := bufio.NewReader(os.Stdin)
    
20.     for {
    
21.         // 从标准输入读取用户输入
    
22.         fmt.Print("请输入消息: ")
    
23.         message, _ := reader.ReadString('\n')
    
24.         // 发送消息到服务器
    
25.         _, err := conn.Write([]byte(message))
    
26.         if err != nil {
    
27.             fmt.Println("发送消息失败:", err)
    
28.             return
    
29.         }
    
30.         // 接收服务器回显的消息
    
31.         response, err := bufio.NewReader(conn).ReadString('\n')
    
32.         if err != nil {
    
33.             fmt.Println("接收消息失败:", err)
    
34.             return
    
35.         }
    
36.         fmt.Print("服务器回显: " + response)
    
37.     }
    
38. }
    

复制代码

说明：

• 使用 net.Dial 连接到服务器。
• 从标准输入读取用户输入并将其发送到服务器。
• 接收服务器回显的消息并显示。
  
  

3. UDP Socket 编程

UDP 是一种无连接的协议，适合对实时性要求较高但对数据传输可靠性要求不高的场景。下面是如何在 Go 中实现 UDP 服务器和客户端。

3.1 服务器端实现

以下是一个简单的 UDP 服务器实现，它监听指定端口，接收客户端发送的数据，并回显消息。

1. package main
   
2. 
   
3. import (
   
4.     "fmt"
   
5.     "net"
   
6. )
   
7. 
   
8. func main() {
   
9.     // 监听本地 8081 端口的 UDP
   
10.     addr, err := net.ResolveUDPAddr("udp", ":8081")
    
11.     if err != nil {
    
12.         fmt.Println("解析地址失败:", err)
    
13.         return
    
14.     }
    
15. 
    
16.     conn, err := net.ListenUDP("udp", addr)
    
17.     if err != nil {
    
18.         fmt.Println("监听 UDP 失败:", err)
    
19.         return
    
20.     }
    
21.     defer conn.Close()
    
22.     fmt.Println("UDP 服务器正在监听端口 8081...")
    
23. 
    
24.     buffer := make([]byte, 1024)
    
25.     for {
    
26.         // 读取客户端发送的数据
    
27.         n, clientAddr, err := conn.ReadFromUDP(buffer)
    
28.         if err != nil {
    
29.             fmt.Println("读取数据错误:", err)
    
30.             continue
    
31.         }
    
32.         message := string(buffer[:n])
    
33.         fmt.Printf("收到来自 %s 的消息: %s", clientAddr, message)
    
34. 
    
35.         // 回显消息给客户端
    
36.         _, err = conn.WriteToUDP([]byte("Echo: "+message), clientAddr)
    
37.         if err != nil {
    
38.             fmt.Println("发送消息失败:", err)
    
39.         }
    
40.     }
    
41. }
    

复制代码

说明：

• 使用 net.ResolveUDPAddr 解析 UDP 地址。
• 使用 net.ListenUDP 监听指定的端口。
• conn.ReadFromUDP 用于接收客户端数据，并返回客户端地址。
  
  

3.2 客户端实现

以下是一个简单的 UDP 客户端实现，发送消息到服务器并接收回显。

1. package main
   
2. 
   
3. import (
   
4.     "bufio"
   
5.     "fmt"
   
6.     "net"
   
7.     "os"
   
8. )
   
9. 
   
10. func main() {
    
11.     // 解析服务器地址
    
12.     serverAddr, err := net.ResolveUDPAddr("udp", "localhost:8081")
    
13.     if err != nil {
    
14.         fmt.Println("解析服务器地址失败:", err)
    
15.         return
    
16.     }
    
17. 
    
18.     // 创建一个 UDP 连接（实际上是无连接的）
    
19.     conn, err := net.DialUDP("udp", nil, serverAddr)
    
20.     if err != nil {
    
21.         fmt.Println("连接 UDP 服务器失败:", err)
    
22.         return
    
23.     }
    
24.     defer conn.Close()
    
25. 
    
26.     reader := bufio.NewReader(os.Stdin)
    
27.     for {
    
28.         // 从标准输入读取用户输入
    
29.         fmt.Print("请输入消息: ")
    
30.         message, _ := reader.ReadString('\n')
    
31.         // 发送消息到服务器
    
32.         _, err := conn.Write([]byte(message))
    
33.         if err != nil {
    
34.             fmt.Println("发送消息失败:", err)
    
35.             return
    
36.         }
    
37.         // 接收服务器回显的消息
    
38.         buffer := make([]byte, 1024)
    
39.         n, err := conn.Read(buffer)
    
40.         if err != nil {
    
41.             fmt.Println("接收消息失败:", err)
    
42.             return
    
43.         }
    
44.         fmt.Print("服务器回显: " + string(buffer[:n]))
    
45.     }
    
46. }
    

复制代码

说明：

• 使用 net.ResolveUDPAddr 解析服务器地址。
• 使用 net.DialUDP 创建一个 UDP 连接（实际上是无连接的）。
• 客户端向服务器发送消息并接收回显。
  
  

4. 总结

Go 语言通过其强大的 net 包，简化了 Socket 编程，支持常见的 TCP 和 UDP 协议。无论是需要可靠数据传输的 TCP，还是对实时性要求高的 UDP，Go 都能轻松实现。通过学习本文中的示例，你可以掌握基本的 Socket 编程技巧，并能够在实际应用中灵活运用这些技术。