网络编程

:::success 目前主流服务器一般均采用的都是”Non-Block + I/O多路复用“Go语言将该“复杂性”隐藏在Runtime中了：Go开发者无需关注socket是否是 non-block的，也无需亲自注册文件描述符的回调，只需在每个连接对应的goroutine中以“blockI/O”的方式对待socket处理即可;

:::

①、TCP

:::success

TCP协议：<font style="color:rgb(51, 51, 51);">import "net"</font>

TCP/IP(Transmission Control Protocol/Internet Protocol) 即传输控制协议/网间协议，是一种面向连接（连接导向）的、可靠的、基于字节流的传输层（Transport layer）通信协议，因为是面向连接的协议，数据像水流一样传输，会存在黏包问题。

一个TCP服务端可以同时连接很多个客户端：我们可以每建立一次链接就创建一个goroutine去处理。

conn协程安全：对于同一个conn，不同goroutine间共享conn。Write、Read 内部是goroutine安全的，内部都有Lock保护。

:::

:::success TCP**服务端**程序的处理流程：

  1. 监听端口
  2. 接收客户端请求建立链接
  3. 创建goroutine处理链接。

TCP**客户端**进行TCP通信的流程：

  1. 建立与服务端的链接
  2. 进行数据收发
  3. 关闭链接

:::

:::success TCP socket api：

  • **Read():** 从连接上读取数据。
  • **Write()**: 向连接上写入数据。
  • **Close()**: 关闭连接。
  • **LocalAddr()**: 返回本地网络地址。
  • **RemoteAddr()**: 返回远程网络地址。
  • **SetDeadline()**: 设置连接相关的读写最后期限。等价于同时调用SetReadDeadline()和SetWriteDeadline()。
  • **SetReadDeadline()**: 设置将来的读调用和当前阻塞的读调用的超时最后期限。
  • **SetWriteDeadline()**: 设置将来写调用以及当前阻塞的写调用的超时最后期限。

:::

:::color2 **<font style="color:#DF2A3F;">conn.Read</font>**的行为特点：

Socket中无数据：连接建立后，如果对方未发送数据到socket，接收方(Server)会阻塞(这里的阻塞并不会阻塞到linux 的api上去，这里跟linux的阻塞不一样，这个阻塞只是引起协程的切换)在Read操作上，这和前面提到的“模型”原理是一致的。执行该Read操作的goroutine也会被挂起。runtime会监视该socket，直到其有数据才会重新调度(后面不阻塞就是该协程允许被调度)该socket对应的Goroutine完成read。

Socket中有部分数据：如果socket中有部分数据，且长度小于一次Read操作所期望读出的数据长度，那么Read将会成功读出这部分数据并返回，而不是等待所有期望数据全部读取后再返回。

Socket中有足够数据：如果socket中有数据，且长度大于等于一次Read操作所期望读出的数据长度，那么Read将会成功读出这部分数据并返回。这个情景是最符合我们对Read的期待的了：Read将用Socket中的数据将我们传入的slice填满后返回：n = 10, err = nil；

Socket关闭：有数据关闭是指在client关闭时，socket中还有server端未读取的数据。当client端close socket退出后，server依旧没有开始Read，10s后第一次Read成功读出了所有的数据，当第二次Read时，由于client端 socket关闭，Read返回EOF error。无数据关闭情形下的结果，那就是Read直接返回EOF error。

socket协议栈中有数据，客户端关闭，数据还可以读出来，然后返回EOF error ；

socket协议栈中没数据，客户端关闭直接返回EOF error；

读取操作超时：有些场合对Read的阻塞时间有严格限制，在这种情况下，Read的行为到底是什么样的呢？在返回超时错误时，是否也同时Read了一部分数据了呢？不会出现“读出部分数据且返回超时错误”的情况。

只有再err == nil的时候，才是真正的读到了数据

只有再err == nil的时候，才是真正的写进了数据

:::

:::color2 **<font style="color:#DF2A3F;">conn.Write</font>**的行为特点：

成功写：前面例子着重于Read，client端在Write时并未判断Write的返回值。所谓“成功写”指的就是Write调用返回的n与预期要写入的数据长度相等，且error = nil。这是我们在调用Write时遇到的最常见的情形；

写阻塞：TCP连接通信两端的OS都会为该连接保留数据缓冲，一端调用Write后，实际上数据是写入到OS的协议栈的数据缓冲的。TCP是全双工通信，因此每个方向都有独立的数据缓冲。当发送方将对方的接收缓冲区以及自身的发送缓冲区写满后，Write就会阻塞，也是协程的阻塞（调度协程）,不是Linux write api。

写入部分数据：Write操作存在写入部分数据的情况。没有按照预期的写入所有数据。这时候循环写入便是综上例子，虽然Go给我们提供了阻塞I/O的便利，但在调用Read和Write时依旧要综合需要方法返回的n和err的结果，以做出正确处理。net.conn实现了io.Reader和io.Writer接口，因此可以试用一些wrapper包进行socket读写，比如bufio包下面的Writer和Reader、io/ioutil下的函数等。

:::

  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. }
  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. }

②、TCP黏包问题及解决方案示例

:::success 黏包问题演示：

:::

  1. // socket_stick/server/main.go
  2. package main
  4. import (
  5.     "fmt"
  6.     "io"
  7.     "bufio"
  8.     "net"
  9. )
  10. func process(conn net.Conn) {
  11.     defer conn.Close()
  12.     reader := bufio.NewReader(conn)
  13.     var buf [1024]byte
  14.     for {
  15.         n, err := reader.Read(buf[:])
  16.         if err == io.EOF {
  17.             break
  18.         }
  19.         if err != nil {
  20.             fmt.Println("read from client failed, err:", err)
  21.             break
  22.         }
  23.         recvStr := string(buf[:n])
  24.         fmt.Println("收到client发来的数据：", recvStr)
  25.     }
  26. }
  28. func main() {
  30.     listen, err := net.Listen("tcp", "127.0.0.1:30000")
  31.     if err != nil {
  32.         fmt.Println("listen failed, err:", err)
  33.         return
  34.     }
  35.     defer listen.Close()
  36.     for {
  37.         conn, err := listen.Accept()
  38.         if err != nil {
  39.             fmt.Println("accept failed, err:", err)
  40.             continue
  41.         }
  42.         go process(conn)
  43.     }
  44. }
  1. // context_timeout/server/main.go
  2. package main
  4. import (
  5.     "fmt"
  6.     "net"
  7. )
  8. // socket_stick/client/main.go
  10. func main() {
  11.     conn, err := net.Dial("tcp", "127.0.0.1:30000")
  12.     if err != nil {
  13.         fmt.Println("dial failed, err", err)
  14.         return
  15.     }
  16.     defer conn.Close()
  17.     for i := 0; i < 20; i++ {
  18.         msg := `Hello, Hello. How are you?`
  19.         conn.Write([]byte(msg))
  20.     }
  21. }
  1. 收到client发来的数据： Hello, Hello. How are you?Hello, Hello. How are you?Hello, Hello. How are you?Hello, Hello. How are you?Hello, Hello. How are you?
  2. 收到client发来的数据： Hello, Hello. How are you?Hello, Hello. How are you?Hello, Hello. How are you?Hello, Hello. How are you?Hello, Hello. How are you?Hello, Hello. How are you?Hello, Hello. How are you?Hello, Hello. How are you?
  3. 收到client发来的数据： Hello, Hello. How are you?Hello, Hello. How are you?
  4. 收到client发来的数据： Hello, Hello. How are you?Hello, Hello. How are you?Hello, Hello. How are you?
  5. 收到client发来的数据： Hello, Hello. How are you?Hello, Hello. How are you?
  1. <font style="color:#DF2A3F;">客户端分10次发送的数据，在服务端并没有成功的输出10次，而是多条数据“粘”到了一起。</font>

:::success

为什么会出现粘包：

主要原因就是tcp数据传递模式是流模式，在保持长连接的时候可以进行多次的收和发。“粘包”可发生在发送端也可发生在接收端：
  1. 由Nagle算法造成的发送端的粘包：Nagle算法是一种改善网络传输效率的算法。简单来说就是当我们提交一段数据给TCP发送时，TCP并不立刻发送此段数据，而是等待一小段时间看看在等待期间是否还有要发送的数据，若有则会一次把这两段数据发送出去。
  2. 接收端接收不及时**造成的接收端粘包**：TCP会把接收到的数据存在自己的缓冲区中，然后通知应用层取数据。当应用层由于某些原因不能及时的把TCP的数据取出来，就会造成TCP缓冲区中存放了几段数据。

:::

:::success

解决办法①：

出现”粘包”的关键在于接收方不确定将要传输的数据包的大小，因此我们可以对数据包进行封包和拆包的操作。

封包：封包就是给一段数据加上包头，这样一来数据包就分为包头和包体两部分内容了(过滤非法包时封包会加入”包尾”内容)。包头部分的长度是固定的，并且它存储了包体的长度，根据包头长度固定以及包头中含有包体长度的变量就能正确的拆分出一个完整的数据包。

我们可以自己定义一个协议，比如数据包的前4个字节为包头，里面存储的是发送的数据的长度：

:::

  1. // socket_stick/proto/proto.go
  2. package proto
  4. import (
  5.     "bufio"
  6.     "bytes"
  7.     "encoding/binary"
  8. )
  10. // Encode 将消息编码
  11. func Encode(message string) ([]byte, error) {
  12.     // 读取消息的长度，转换成int32类型（占4个字节）
  13.     var length = int32(len(message))
  14.     var pkg = new(bytes.Buffer)
  15.     // 写入消息头
  16.     err := binary.Write(pkg, binary.LittleEndian, length)
  17.     if err != nil {
  18.         return nil, err
  19.     }
  20.     // 写入消息实体
  21.     err = binary.Write(pkg, binary.LittleEndian, []byte(message))
  22.     if err != nil {
  23.         return nil, err
  24.     }
  25.     return pkg.Bytes(), nil
  26. }
  28. // Decode 解码消息
  29. func Decode(reader *bufio.Reader) (string, error) {
  30.     // 读取消息的长度
  31.     lengthByte, _ := reader.Peek(4) // 读取前4个字节的数据
  32.     lengthBuff := bytes.NewBuffer(lengthByte)
  33.     var length int32
  34.     err := binary.Read(lengthBuff, binary.LittleEndian, &length)
  35.     if err != nil {
  36.         return "", err
  37.     }
  38.     // Buffered返回缓冲中现有的可读取的字节数。
  39.     if int32(reader.Buffered()) < length+4 {
  40.         return "", err
  41.     }
  43.     // 读取真正的消息数据
  44.     pack := make([]byte, int(4+length))
  45.     _, err = reader.Read(pack)
  46.     if err != nil {
  47.         return "", err
  48.     }
  49.     return string(pack[4:]), nil
  50. }
接下来在服务端和客户端分别使用上面定义的proto包的Decode和Encode函数处理数据。如下： 
  1. // socket_stick/server/main.go
  2. package main
  4. import (
  5.     "bufio"
  6.     "fmt"
  7.     "io"
  8.     "bytes"
  9.     "encoding/binary"
  10.     "net"
  11. )
  13. func Encode(message string) ([]byte, error) {
  14.     // 读取消息的长度，转换成int32类型（占4个字节）
  15.     var length = int32(len(message))
  16.     var pkg = new(bytes.Buffer)
  17.     // 写入消息头
  18.     err := binary.Write(pkg, binary.LittleEndian, length)
  19.     if err != nil {
  20.         return nil, err
  21.     }
  22.     // 写入消息实体
  23.     err = binary.Write(pkg, binary.LittleEndian, []byte(message))
  24.     if err != nil {
  25.         return nil, err
  26.     }
  27.     return pkg.Bytes(), nil
  28. }
  30. // Decode 解码消息
  31. func Decode(reader *bufio.Reader) (string, error) {
  32.     // 读取消息的长度
  33.     lengthByte, _ := reader.Peek(4) // 读取前4个字节的数据
  34.     lengthBuff := bytes.NewBuffer(lengthByte)
  35.     var length int32
  36.     err := binary.Read(lengthBuff, binary.LittleEndian, &length)
  37.     if err != nil {
  38.         return "", err
  39.     }
  40.     // Buffered返回缓冲中现有的可读取的字节数。
  41.     if int32(reader.Buffered()) < length+4 {
  42.         return "", err
  43.     }
  45.     // 读取真正的消息数据
  46.     pack := make([]byte, int(4+length))
  47.     _, err = reader.Read(pack)
  48.     if err != nil {
  49.         return "", err
  50.     }
  51.     return string(pack[4:]), nil
  52. }
  53. func process(conn net.Conn) {
  54.     defer conn.Close()
  55.     reader := bufio.NewReader(conn)
  56.     for {
  57.         msg, err := Decode(reader)
  58.         if err == io.EOF {
  59.             return
  60.         }
  61.         if err != nil {
  62.             fmt.Println("decode msg failed, err:", err)
  63.             return
  64.         }
  65.         fmt.Println("收到client发来的数据：", msg)
  66.     }
  67. }
  69. func main() {
  71.     listen, err := net.Listen("tcp", "127.0.0.1:30000")
  72.     if err != nil {
  73.         fmt.Println("listen failed, err:", err)
  74.         return
  75.     }
  76.     defer listen.Close()
  77.     for {
  78.         conn, err := listen.Accept()
  79.         if err != nil {
  80.             fmt.Println("accept failed, err:", err)
  81.             continue
  82.         }
  83.         go process(conn)
  84.     }
  85. }
  1. // context_timeout/server/main.go
  2. package main
  4. import (
  5.     "fmt"
  6.     "bufio"
  7.     "bytes"
  8.     "encoding/binary"
  10.     "net"
  11. )
  12. // socket_stick/client/main.go
  13. // socket_stick/client2/main.go
  14. // Encode 将消息编码
  15. func Encode(message string) ([]byte, error) {
  16.     // 读取消息的长度，转换成int32类型（占4个字节）
  17.     var length = int32(len(message))
  18.     var pkg = new(bytes.Buffer)
  19.     // 写入消息头
  20.     err := binary.Write(pkg, binary.LittleEndian, length)
  21.     if err != nil {
  22.         return nil, err
  23.     }
  24.     // 写入消息实体
  25.     err = binary.Write(pkg, binary.LittleEndian, []byte(message))
  26.     if err != nil {
  27.         return nil, err
  28.     }
  29.     return pkg.Bytes(), nil
  30. }
  32. // Decode 解码消息
  33. func Decode(reader *bufio.Reader) (string, error) {
  34.     // 读取消息的长度
  35.     lengthByte, _ := reader.Peek(4) // 读取前4个字节的数据
  36.     lengthBuff := bytes.NewBuffer(lengthByte)
  37.     var length int32
  38.     err := binary.Read(lengthBuff, binary.LittleEndian, &length)
  39.     if err != nil {
  40.         return "", err
  41.     }
  42.     // Buffered返回缓冲中现有的可读取的字节数。
  43.     if int32(reader.Buffered()) < length+4 {
  44.         return "", err
  45.     }
  47.     // 读取真正的消息数据
  48.     pack := make([]byte, int(4+length))
  49.     _, err = reader.Read(pack)
  50.     if err != nil {
  51.         return "", err
  52.     }
  53.     return string(pack[4:]), nil
  54. }
  56. func main() {
  57.     conn, err := net.Dial("tcp", "127.0.0.1:30000")
  58.     if err != nil {
  59.         fmt.Println("dial failed, err", err)
  60.         return
  61.     }
  62.     defer conn.Close()
  63.     for i := 0; i < 20; i++ {
  64.         msg := `Hello, Hello. How are you?`
  65.         data, err := Encode(msg)
  66.         if err != nil {
  67.             fmt.Println("encode msg failed, err:", err)
  68.             return
  69.         }
  70.         conn.Write(data)
  71.     }
  72. }
  1. 收到client发来的数据： Hello, Hello. How are you?
  2. 收到client发来的数据： Hello, Hello. How are you?
  3. 收到client发来的数据： Hello, Hello. How are you?
  4. 收到client发来的数据： Hello, Hello. How are you?
  5. 收到client发来的数据： Hello, Hello. How are you?
  6. 收到client发来的数据： Hello, Hello. How are you?
  7. 收到client发来的数据： Hello, Hello. How are you?
  8. 收到client发来的数据： Hello, Hello. How are you?
  9. 收到client发来的数据： Hello, Hello. How are you?
  10. 收到client发来的数据： Hello, Hello. How are you?
  11. 收到client发来的数据： Hello, Hello. How are you?
  12. 收到client发来的数据： Hello, Hello. How are you?
  13. 收到client发来的数据： Hello, Hello. How are you?
  14. 收到client发来的数据： Hello, Hello. How are you?
  15. 收到client发来的数据： Hello, Hello. How are you?
  16. 收到client发来的数据： Hello, Hello. How are you?
  17. 收到client发来的数据： Hello, Hello. How are you?
  18. 收到client发来的数据： Hello, Hello. How are you?
  19. 收到client发来的数据： Hello, Hello. How are you?
  20. 收到client发来的数据： Hello, Hello. How are you?

③、TCP流式传输和UDP数据报的区别？

UDP：发送缓冲区的发送按照每一个数据报一发送；

TCP：由于是流式传输，TCP的发送缓冲区的发送由系统控制，会时不时的发送，协议栈没有发送之前，再来的所有数据都会追加到发送缓冲区内，等待协议栈一同发送，所以会存在粘包和分包的问题，但是注意：用户发送的每个包，不会拆分到不同的传输批次中，同一个包会完整的出现在一次TCP传输中。解决办法就是TCP的接收需要注意分包问题，可以自定义协议头，代表本包长度。只获取本包长度数据，进行处理，读取的剩余数据再分包循环处理。

④、Socket属性

⑤、UDP编程

:::color2 UDP协议（User Datagram Protocol）中文名称是用户数据报协议，是OSI（Open System Interconnection，开放式系统互联）参考模型中一种无连接的传输层协议，不需要建立连接就能直接进行数据发送和接收，属于不可靠的、没有时序的通信，但是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. }
  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. }