GolangTCP通信办理粘包问题

重要原因就是tcp数据传递模式是流模式，在保持长毗连的时间可以举行多次的收和发。
“粘包"可发生在发送端也可发生在接收端：
   

• 由Nagle算法造成的发送端的粘包：Nagle算法是一种改善网络传输效率的算法。简单来说就是当我们提交一段数据给TCP发送时，TCP并不立刻发送此段数据，而是等待一小段时间看看在等待期间是否还有要发送的数据，如有则会一次把这两段数据发送出去。
  
• 接收端接收不实时造成的接收端粘包：TCP会把接收到的数据存在自己的缓冲区中，然后关照应用层取数据。当应用层由于某些原因不能实时的把TCP的数据取出来，就会造成TCP缓冲区中存放了几段数据。
  

  办理办法

出现"粘包"的关键在于接收方不确定将要传输的数据包的大小，因此我们可以对数据包举行封包和拆包的操纵。
封包：封包就是给一段数据加上包头，如许一来数据包就分为包头和包体两部门内容了(过滤非法包时封包会参加"包尾"内容)。包头部门的长度是固定的，并且它存储了包体的长度，根据包头长度固定以及包头中含有包体长度的变量就能正确的拆分出一个完备的数据包。
我们可以自己定义一个协议，好比数据包的前4个字节为包头，里面存储的是发送的数据的长度。
protocol包：

1. package protocol
3. import (
4.         "bufio"
5.         "bytes"
6.         "encoding/binary"
7. )
9. // Encode 将消息编码
10. func Encode(message string) ([]byte, error) {
11.         // 读取消息的长度，转换成int32类型（占4个字节）
12.         var length = int32(len(message))
13.         var pkg = new(bytes.Buffer)
14.         // 写入消息头
15.         err := binary.Write(pkg, binary.LittleEndian, length)
16.         if err != nil {
17.                 return nil, err
18.         }
19.         // 写入消息实体
20.         err = binary.Write(pkg, binary.LittleEndian, []byte(message))
21.         if err != nil {
22.                 return nil, err
23.         }
24.         return pkg.Bytes(), nil
25. }
27. // Decode 解码消息
28. func Decode(reader *bufio.Reader) (string, error) {
29.         // 读取消息的长度
30.         lengthByte, _ := reader.Peek(4) // 读取前4个字节的数据
31.         lengthBuff := bytes.NewBuffer(lengthByte)
32.         var length int32
33.         err := binary.Read(lengthBuff, binary.LittleEndian, &length)
34.         if err != nil {
35.                 return "", err
36.         }
37.         // Buffered返回缓冲中现有的可读取的字节数。
38.         if int32(reader.Buffered()) < length+4 {
39.                 return "", err
40.         }
42.         // 读取真正的消息数据
43.         pack := make([]byte, int(4+length))
44.         _, err = reader.Read(pack)
45.         if err != nil {
46.                 return "", err
47.         }
48.         return string(pack[4:]), nil
49. }

复制代码

客户端：

1. func main() {
2.         conn, err := net.Dial("tcp", "127.0.0.1:30000")
3.         if err != nil {
4.                 fmt.Println("dial failed, err", err)
5.                 return
6.         }
7.         defer conn.Close()
8.         for i := 0; i < 20; i++ {
9.                 msg := `Hello, Hello. How are you?`
10.                 data, err := proto.Encode(msg)
11.                 if err != nil {
12.                         fmt.Println("encode msg failed, err:", err)
13.                         return
14.                 }
15.                 conn.Write(data)
16.         }
17. }

复制代码

服务器：

1. package main
3. import (
4.         "bufio"
5.         "fmt"
6.         "io"
7.         "net"
8.         proto "studygo/studygo/tcp/protocol"
9.         "sync"
10. )
12. var wg sync.WaitGroup
14. func process(conn net.Conn) {
15.         //与客户端通信
16.         defer conn.Close()
17.         reader := bufio.NewReader(conn)
18.         for {
19.                 msg, err := proto.Decode(reader)
20.                 if err == io.EOF {
21.                         break
22.                 }
23.                 if err!=nil{
24.                         fmt.Println("decode msg failed,err:",err)
25.                         return
26.                 }
27.                 fmt.Println(msg)
28.         }
30. }
32. func main() {
33.         //本地端口启动服务
34.         listener, err := net.Listen("tcp", "127.0.0.1:8000")
35.         if err != nil {
36.                 fmt.Println("listen failed,err:%v\n", err)
37.                 return
38.         }
39.         defer listener.Close()
40.         for {
41.                 //等待别人连接
42.                 conn, err := listener.Accept()
43.                 if err != nil {
44.                         fmt.Println("accept failed,err:%v\n", err)
45.                         return
46.                 }
47.                 go process(conn)
48.         }
50. }

复制代码

参考出处：Go语言基础之网络编程 | 李文周的博客

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。