传送门：网络编程

TCP服务端

一个TCP服务端可以同时连接很多个客户端，例如世界各地的用户使用自己电脑上的浏览器访问淘宝网。因为Go语言中创建多个goroutine实现并发非常方便和高效，所以我们可以每建立一次链接就创建一个goroutine去处理。


TCP服务端程序的处理流程：

  • 监听端口
  • 接收客户端请求建立链接
  • 创建goroutine处理链接。

我们使用Go语言的net包实现的TCP服务端代码如下：

  1. // tcp/server/main.go
  3. // TCP server端
  5. // 处理函数
  6. func process(conn net.Conn) {
  7.     defer conn.Close() // 关闭连接
  8.     for {
  9.         reader := bufio.NewReader(conn)
  10.         var buf [128]byte
  11.         n, err := reader.Read(buf[:]) // 读取数据
  12.         if err != nil {
  13.             fmt.Println("read from client failed, err:", err)
  14.             break
  15.         }
  16.         recvStr := string(buf[:n])
  17.         fmt.Println("收到client端发来的数据：", recvStr)
  18.         conn.Write([]byte(recvStr)) // 发送数据
  19.     }
  20. }
  22. func main() {
  23.     listen, err := net.Listen("tcp", "127.0.0.1:20000")
  24.     if err != nil {
  25.         fmt.Println("listen failed, err:", err)
  26.         return
  27.     }
  28.     for {
  29.         conn, err := listen.Accept() // 建立连接
  30.         if err != nil {
  31.             fmt.Println("accept failed, err:", err)
  32.             continue
  33.         }
  34.         go process(conn) // 启动一个goroutine处理连接
  35.     }
  36. }

TCP客户端

一个TCP客户端进行TCP通信的流程如下：

  • 建立与服务端的链接
  • 进行数据收发
  • 关闭链接


使用Go语言的net包实现的TCP客户端代码如下：

  1. // tcp/client/main.go
  3. // 客户端
  4. func main() {
  5.     conn, err := net.Dial("tcp", "127.0.0.1:20000")
  6.     if err != nil {
  7.         fmt.Println("err :", err)
  8.         return
  9.     }
  10.     defer conn.Close() // 关闭连接
  11.     inputReader := bufio.NewReader(os.Stdin)
  12.     for {
  13.         input, _ := inputReader.ReadString('\n') // 读取用户输入
  14.         inputInfo := strings.Trim(input, "\r\n")
  15.         if strings.ToUpper(inputInfo) == "Q" { // 如果输入q就退出
  16.             return
  17.         }
  18.         _, err = conn.Write([]byte(inputInfo)) // 发送数据
  19.         if err != nil {
  20.             return
  21.         }
  22.         buf := [512]byte{}
  23.         n, err := conn.Read(buf[:])
  24.         if err != nil {
  25.             fmt.Println("recv failed, err:", err)
  26.             return
  27.         }
  28.         fmt.Println(string(buf[:n]))
  29.     }
  30. }

UDP服务端

使用Go语言的net包实现的UDP服务端代码如下：

  1. // UDP/server/main.go
  3. // UDP server端
  4. func main() {
  5.     listen, err := net.ListenUDP("udp", &net.UDPAddr{
  6.         IP:   net.IPv4(0, 0, 0, 0),
  7.         Port: 30000,
  8.     })
  9.     if err != nil {
  10.         fmt.Println("listen failed, err:", err)
  11.         return
  12.     }
  13.     defer listen.Close()
  14.     for {
  15.         var data [1024]byte
  16.         n, addr, err := listen.ReadFromUDP(data[:]) // 接收数据
  17.         if err != nil {
  18.             fmt.Println("read udp failed, err:", err)
  19.             continue
  20.         }
  21.         fmt.Printf("data:%v addr:%v count:%v\n", string(data[:n]), addr, n)
  22.         _, err = listen.WriteToUDP(data[:n], addr) // 发送数据
  23.         if err != nil {
  24.             fmt.Println("write to udp failed, err:", err)
  25.             continue
  26.         }
  27.     }
  28. }

UDP客户端

使用Go语言的net包实现的UDP客户端代码如下：

  1. // UDP 客户端
  2. func main() {
  3.     socket, err := net.DialUDP("udp", nil, &net.UDPAddr{
  4.         IP:   net.IPv4(0, 0, 0, 0),
  5.         Port: 30000,
  6.     })
  7.     if err != nil {
  8.         fmt.Println("连接服务端失败，err:", err)
  9.         return
  10.     }
  11.     defer socket.Close()
  12.     sendData := []byte("Hello server")
  13.     _, err = socket.Write(sendData) // 发送数据
  14.     if err != nil {
  15.         fmt.Println("发送数据失败，err:", err)
  16.         return
  17.     }
  18.     data := make([]byte, 4096)
  19.     n, remoteAddr, err := socket.ReadFromUDP(data) // 接收数据
  20.     if err != nil {
  21.         fmt.Println("接收数据失败，err:", err)
  22.         return
  23.     }
  24.     fmt.Printf("recv:%v addr:%v count:%v\n", string(data[:n]), remoteAddr, n)
  25. }