golang中tcp socket粘包问题和处理

最新推荐文章于 2024-07-26 06:00:00 发布
最新推荐文章于 2024-07-26 06:00:00 发布
阅读量1.2k 收藏 1
点赞数
分类专栏： Go 文章标签： Go TCP

在用golang开发人工客服系统的时候碰到了粘包问题，那么什么是粘包呢？例如我们和客户端约定数据交互格式是一个json格式的字符串：

{"Id":1,"Name":"golang","Message":"message"}

当客户端发送数据给服务端的时候，如果服务端没有及时接收，客户端又发送了一条数据上来，这时候服务端才进行接收的话就会收到两个连续的字符串，形如：

{"Id":1,"Name":"golang","Message":"message"}{"Id":1,"Name":"golang","Message":"message"}

如果接收缓冲区满了的话，那么也有可能接收到半截的json字符串，酱紫的话还怎么用json解码呢？真是头疼。以下用golang模拟了下这个粘包的产生。

备注：下面贴的代码均可以运行于golang 1.3.1，如果发现有问题可以联系我。

粘包示例

server.go

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
//粘包问题演示服务端
package  main
 
import  (
     "fmt"
     "net"
     "os"
)
 
func  main() {
     netListen, err := net.Listen( "tcp" ,  ":9988" )
     CheckError(err)
 
     defer  netListen.Close()
 
     Log( "Waiting for clients" )
     for  {
         conn, err := netListen.Accept()
         if  err != nil {
             continue
         }
 
         Log(conn.RemoteAddr().String(),  " tcp connect success" )
         go  handleConnection(conn)
     }
}
 
func  handleConnection(conn net.Conn) {
     buffer := make([]byte,  1024 )
     for  {
         n, err := conn.Read(buffer)
         if  err != nil {
             Log(conn.RemoteAddr().String(),  " connection error: " , err)
             return
         }
         Log(conn.RemoteAddr().String(),  "receive data length:" , n)
         Log(conn.RemoteAddr().String(),  "receive data:" , buffer[:n])
         Log(conn.RemoteAddr().String(),  "receive data string:" , string(buffer[:n]))
     }
}
 
func  Log(v ... interface {}) {
     fmt.Println(v...)
}
 
func  CheckError(err error) {
     if  err != nil {
         fmt.Fprintf(os.Stderr,  "Fatal error: %s" , err.Error())
         os.Exit( 1 )
     }
}

client.go

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
//粘包问题演示客户端
package  main
 
import  (
     "fmt"
     "net"
     "os"
     "time"
)
 
func  sender(conn net.Conn) {
     for  i :=  0 ; i <  100 ; i++ {
         words :=  "{\"Id\":1,\"Name\":\"golang\",\"Message\":\"message\"}"
         conn.Write([]byte(words))
     }
}
 
func  main() {
     server :=  "127.0.0.1:9988"
     tcpAddr, err := net.ResolveTCPAddr( "tcp4" , server)
     if  err != nil {
         fmt.Fprintf(os.Stderr,  "Fatal error: %s" , err.Error())
         os.Exit( 1 )
     }
 
     conn, err := net.DialTCP( "tcp" , nil, tcpAddr)
     if  err != nil {
         fmt.Fprintf(os.Stderr,  "Fatal error: %s" , err.Error())
         os.Exit( 1 )
     }
 
     defer  conn.Close()
 
     fmt.Println( "connect success" )
 
     go  sender(conn)
 
     for  {
         time.Sleep( 1  *  1e9 )
     }
}

运行后查看服务端输出：

golang粘包问题演示

golang粘包问题演示

可以看到json格式的字符串都粘到一起了，有种淡淡的忧伤了——头疼的事情又来了。

粘包产生原因

关于粘包的产生原因网上有很多相关的说明，主要原因就是tcp数据传递模式是流模式，在保持长连接的时候可以进行多次的收和发。如果要深入了解可以看看tcp协议方面的内容。这里推荐下鸟哥的私房菜，讲的非常通俗易懂。

粘包解决办法

主要有两种方法：

1、客户端发送一次就断开连接，需要发送数据的时候再次连接，典型如http。下面用golang演示一下这个过程，确实不会出现粘包问题。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
//客户端代码，演示了发送一次数据就断开连接的
package  main
 
import  (
     "fmt"
     "net"
     "os"
     "time"
)
 
func  main() {
     server :=  "127.0.0.1:9988"
 
     for  i :=  0 ; i <  10000 ; i++ {
         tcpAddr, err := net.ResolveTCPAddr( "tcp4" , server)
         if  err != nil {
             fmt.Fprintf(os.Stderr,  "Fatal error: %s" , err.Error())
             os.Exit( 1 )
         }
 
         conn, err := net.DialTCP( "tcp" , nil, tcpAddr)
         if  err != nil {
             fmt.Fprintf(os.Stderr,  "Fatal error: %s" , err.Error())
             os.Exit( 1 )
         }
 
         words :=  "{\"Id\":1,\"Name\":\"golang\",\"Message\":\"message\"}"
         conn.Write([]byte(words))
 
         conn.Close()
     }
 
     for  {
         time.Sleep( 1  *  1e9 )
     }
}

服务端代码参考上面演示粘包产生过程的服务端代码

2、包头+数据的格式，根据包头信息读取到需要分析的数据。形式如下图：

golang粘包问题包头定义

golang粘包问题包头定义

从数据流中读取数据的时候，只要根据包头和数据长度就能取到需要的数据。这个其实就是平时说的协议（protocol），只是这个数据传输协议非常简单，不像tcp、ip等协议有较多的定义。在实际的过程中通常会定义协议类或者协议文件来封装封包和解包的过程。下面代码演示了封包和解包的过程：

protocol.go

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
//通讯协议处理，主要处理封包和解包的过程
package  protocol
 
import  (
     "bytes"
     "encoding/binary"
)
 
const (
     ConstHeader         =  "www.01happy.com"
     ConstHeaderLength   =  15
     ConstSaveDataLength =  4
)
 
//封包
func  Packet(message []byte) []byte {
     return  append(append([]byte(ConstHeader), IntToBytes(len(message))...), message...)
}
 
//解包
func  Unpack(buffer []byte, readerChannel chan []byte) []byte {
     length := len(buffer)
 
     var  i int
     for  i =  0 ; i < length; i = i +  1  {
         if  length < i+ConstHeaderLength+ConstSaveDataLength {
             break
         }
         if  string(buffer[i:i+ConstHeaderLength]) == ConstHeader {
             messageLength := BytesToInt(buffer[i+ConstHeaderLength : i+ConstHeaderLength+ConstSaveDataLength])
             if  length < i+ConstHeaderLength+ConstSaveDataLength+messageLength {
                 break
             }
             data := buffer[i+ConstHeaderLength+ConstSaveDataLength : i+ConstHeaderLength+ConstSaveDataLength+messageLength]
             readerChannel <- data
 
             i += ConstHeaderLength + ConstSaveDataLength + messageLength -  1
         }
     }
 
     if  i == length {
         return  make([]byte,  0 )
     }
     return  buffer[i:]
}
 
//整形转换成字节
func  IntToBytes(n int) []byte {
     x := int32(n)
 
     bytesBuffer := bytes.NewBuffer([]byte{})
     binary.Write(bytesBuffer, binary.BigEndian, x)
     return  bytesBuffer.Bytes()
}
 
//字节转换成整形
func  BytesToInt(b []byte) int {
     bytesBuffer := bytes.NewBuffer(b)
 
     var  x int32
     binary.Read(bytesBuffer, binary.BigEndian, &x)
 
     return  int(x)
}

tips：解包的过程中要注意数组越界的问题；另外包头要注意唯一性。

server.go

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
//服务端解包过程
package  main
 
import  (
     "./protocol"
     "fmt"
     "net"
     "os"
)
 
func  main() {
     netListen, err := net.Listen( "tcp" ,  ":9988" )
     CheckError(err)
 
     defer  netListen.Close()
 
     Log( "Waiting for clients" )
     for  {
         conn, err := netListen.Accept()
         if  err != nil {
             continue
         }
 
         Log(conn.RemoteAddr().String(),  " tcp connect success" )
         go  handleConnection(conn)
     }
}
 
func  handleConnection(conn net.Conn) {
     //声明一个临时缓冲区，用来存储被截断的数据
     tmpBuffer := make([]byte,  0 )
 
     //声明一个管道用于接收解包的数据
     readerChannel := make(chan []byte,  16 )
     go  reader(readerChannel)
 
     buffer := make([]byte,  1024 )
     for  {
         n, err := conn.Read(buffer)
         if  err != nil {
             Log(conn.RemoteAddr().String(),  " connection error: " , err)
             return
         }
 
         tmpBuffer = protocol.Unpack(append(tmpBuffer, buffer[:n]...), readerChannel)
     }
}
 
func  reader(readerChannel chan []byte) {
     for  {
         select {
         case data := <-readerChannel:
             Log(string(data))
         }
     }
}
 
func  Log(v ... interface {}) {
     fmt.Println(v...)
}
 
func  CheckError(err error) {
     if  err != nil {
         fmt.Fprintf(os.Stderr,  "Fatal error: %s" , err.Error())
         os.Exit( 1 )
     }
}

client.go

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
//客户端发送封包
package  main
 
import  (
     "./protocol"
     "fmt"
     "net"
     "os"
     "time"
)
 
func  sender(conn net.Conn) {
     for  i :=  0 ; i <  1000 ; i++ {
         words :=  "{\"Id\":1,\"Name\":\"golang\",\"Message\":\"message\"}"
         conn.Write(protocol.Packet([]byte(words)))
     }
     fmt.Println( "send over" )
}
 
func  main() {
     server :=  "127.0.0.1:9988"
     tcpAddr, err := net.ResolveTCPAddr( "tcp4" , server)
     if  err != nil {
         fmt.Fprintf(os.Stderr,  "Fatal error: %s" , err.Error())
         os.Exit( 1 )
     }
 
     conn, err := net.DialTCP( "tcp" , nil, tcpAddr)
     if  err != nil {
         fmt.Fprintf(os.Stderr,  "Fatal error: %s" , err.Error())
         os.Exit( 1 )
     }
 
     defer  conn.Close()
     fmt.Println( "connect success" )
     go  sender(conn)
     for  {
         time.Sleep( 1  *  1e9 )
     }
}

转自：http://www.cnblogs.com/lost-1987/articles/4303881.html
RyoHo2015
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Go】详解TCP黏包
Fanjufei的博客
07-31 450
目录1、TCP黏包现象2、为什么会出现粘包服务端代码如下： 客户端代码如下： 多条数据“粘”到了一起。主要原因就是tcp数据传递模式是流模式，在保持长连接的时候可以进行多次的收和发。TCP黏包是指在使用TCP协议进行数据传输时，发送方所发送的数据包在接收方接收时被粘成一个或多个大的数据块。这种情况通常发生在发送端连续发送多个小数据包，而接收端并非一次性接收所有数据包，而是以较大的数据块进行接收的时候。造成TCP黏包的主要原因有两个：为了解决TCP黏包问题，可以采取以下几种方法：采取以上方法之一或者
go TCP 粘包原理和解决方案
qq_24425451的博客
04-11 3095
1 为什么会出现粘包 主要原因是tcp 数据传递模式是留模式，在长连接过程中可以进行多次收发。数据粘包可以发生在客户端和服务端。 2 解决办法 出现粘包的关键在于不确定包的大小，因此可以通过封包将把的内容长度封装在包头，用固定长度的值来存储包内容长度。自己封装一个数据传输协议。如下： package proto import ( "bufio" "bytes" "encoding/binary" ) // Encode 将消息编码 func Encode(message stri
Go解决TCP粘包
qq_41009846的博客
07-10 1460
粘包 tcp粘包： tcp是流式协议：发送包的时候一次可能没有发完可能给了下一次 nagle算法导致客户端发送的粘包，本意是为了改善客户端网络 nagle算法 该算法要求一个tcp连接上最多只能有一个未被确认的未完成的小分组，在该分组ack到达之前不能发送其他的小分组，tcp需要收集这些少量的分组，并在ack到来时以一个分组的方式发送出去；其中小分组的定义是小于MSS的任何分组； 该算法的优越之处在于它是自适应的，确认到达的越快，数据也就发哦送的越快；而在希望减少微小分组数目的低速广域网上，则
Golang Tcp粘包处理（转）
weixin_33940102的博客
04-13 2669
在用golang开发人工客服系统的时候碰到了粘包问题，那么什么是粘包呢？例如我们和客户端约定数据交互格式是一个json格式的字符串： {"Id":1,"Name":"golang","Message":"message"} 当客户端发送数据给服务端的时候，如果服务端没有及时接收，客户端又发送了一条数据上来，这时候服务端才进行接收的话就会收到两个连续的字符串，形如： {"Id":1,"Name...
golang网络编程-解决TCP粘包问题
最新发布
北桥源木
07-26 304
包头部分的长度是固定的，并且它存储了包体的长度，根据包头长度固定以及包头中含有包体长度的变量就能正确的拆分出一个完整的数据包。出现”粘包”的关键在于接收方不确定将要传输的数据包的大小，因此我们可以对数据包进行封包和拆包的操作。接下来在服务端和客户端分别使用上面定义的proto包的Decode和Encode函数处理数据。客户端分10次发送的数据，在服务端并没有成功的输出10次，而是多条数据“粘”到了一起。我们可以自己定义一个协议，比如数据包的前4个字节为包头，里面存储的是发送的数据的长度。
GO语言如何手动处理TCP粘包详解
01-01
前言 一般所谓的TCP粘包是在一次接收数据不能完全地体现一个完整的消息数据。TCP通讯为何存在粘包呢？主要原因是TCP是以流的方式来处理数据，再加上网络上MTU的往往小于在应用处理的消息数据，所以就会引发一次接收的数据无法满足消息的需要，导致粘包的存在。处理粘包的唯一方法就是制定应用层的数据通讯协议，通过协议来规范现有接收的数据是否满足消息数据的需要。在应用中处理粘包的基础方法主要有两种分别是以4节字描述消息大小或以结束符，实际上也有两者相结合的如HTTP,redis的通讯协议等。 应用场景 大部分TCP通讯场景下，使用自定义通讯协议 粘包处理原理：通过请求头中数据包大小，将客户端N次发送
GOLANG中TCP SOCKET粘包问题和处理
oguro的博客
04-07 1292
在用golang开发人工客服系统的时候碰到了粘包问题，那么什么是粘包呢？例如我们和客户端约定数据交互格式是一个json格式的字符串： {"Id":1,"Name":"golang","Message":"message"} 当客户端发送数据给服务端的时候，如果服务端没有及时接收，客户端又发送了一条数据上来，这时候服务端才进行接收的话就会收到两个连续的字符串，形如： {"Id":1,"Name":"golang","Message":"message"}{"Id":1,"Name":"golang"
golang解决TCP粘包问题
思月行云
05-05 2375
6行代码解决golang TCP粘包 转自：https://studygolang.com/articles/12483 什么是TCP粘包问题以及为什么会产生TCP粘包，本文不加讨论。本文使用golang的bufio.Scanner来实现自定义协议解包。 协议数据包定义 本文模拟一个日志服务器，该服务器接收客户端传到的数据包并显示出来 type Package struct { ...
golang tcp粘包处理
jank1369的博客
10-23 2316
go
golang TCP处理数据包粘包的代码,可直接使用
Programmer小卫
11-26 509
package main import ( "bytes" "encoding/binary" "fmt" ) const ( DEFAULE_HEADER = "[**********]" DEFAULT_HEADER_LENGTH = 12 DEFAULT_SAVE_DATA_LENGTH = 4 ) type Packet struct { Header string HeaderLength int32 SaveDataLeng.
6行代码快速解决golang TCP粘包问题
09-20
在用golang开发人工客服系统的时候碰到了粘包问题，那么什么是粘包呢？下面这篇文章主要给大家介绍了关于如何通过6行代码快速解决golang TCP粘包问题的相关资料，文中通过示例代码介绍的非常详细，需要的朋友可以参考借鉴下面随着小编来一起学习学习吧。
TCP 粘包解决办法
03-13
TCP 通信 粘包解决办法
GOLANG语言实现SOCKET通讯粘包问题解决示例
03-28
GOLANG语言实现SOCKET通讯粘包问题解决示例，对于TCP传输分段，组合无明显界线，造成传输和接收数据包不完整的解决方法！
socket的粘包处理
09-16
当前在网络传输应用中，广泛采用的是TCP/IP通信协议及其标准的socket应用开发编程接口（API）。TCP/IP传输层有两个并列的协议：TCP和UDP。其中TCP（transport control protocol，传输控制协议）是面向连接的，提供高可靠性服务。UDP（user datagram protocol，用户数据报协议）是无连接的，提供高效率服务。在实际工程应用中，对可靠性和效率的选择取决于应用的环境和需求。一般情况下，普通数据的网络传输采用高效率的udp，重要数据的网络传输采用高可靠性的TCP。
TCP的粘包、拆包、解决方案以及Go语言实现
CoLiuRs
06-29 1644
TCP 不管发送端要发什么，都基于字节流把数据发到接收端。这个字节流里可能包含上一次想要发的数据的部分信息。接收端根据需要在消息里加上识别消息边界的信息。不加就可能出现粘包问题UDP 是基于数据报的传输协议，每个数据报都是独立传输的（接收端一次只能接受一条独立的消息），不会有粘包问题。
GO Tcp终极粘包解决方案，保姆级教程
qq_34844048的博客
01-11 646
GO Tcp粘包解决方案
golang 解决 TCP 粘包问题
lxw1844912514的博客
09-24 234
什么是 TCP 粘包问题以及为什么会产生 TCP 粘包，本文不加讨论,本文使用 golang 的 bufio.Scanner 来实现自定义协议解包。协议数据包定义本文模拟一个日志服务器，该服务器接收客户端传到的数据包并显示出来typePackagestruct{ Version [2]byte// 协议版本，暂定V1 Length int16// 数...
服务器客户端约定协议包,Golang的socket编程（四）：解决粘包问题及制定通信协议...
weixin_29474859的博客
08-04 617
一、概述前面已经完成了一个完美的多并发CS模型，但美中不足的是没有解决粘包问题。1.1 什么是粘包问题？在网络传输中，数据都是通过数据流来传输的，也就是以比特来传输。传输的过程中我们可能会遇到各种各样的问题导致数据传输异常，最常见的就是网络发送时延。网络时延会导致服务端此时收到的数据的时间有偏差，然后就导致数据接收数据的时间不一致。可以看一个例子，修改上篇的服务端和客户端为以下内容：1234567...
Golang加头和尾部来解决tcp粘包问题.代码片段示例
JieLinDee的专栏
03-09 2339
package main import ( "bufio" "encoding/binary" "fmt" "io" "net" ) var empty []byte func main() { lis, _ := net.Listen("tcp", ":1789") for { con, err := lis.Accept() if err != nil { c
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值