golang中tcp socket粘包问题和处理
http://www.01happy.com/golang-tcp-socket-adhere/
在用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 )
}
}
|
运行后查看服务端输出:
可以看到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、包头+数据的格式,根据包头信息读取到需要分析的数据。形式如下图:
从数据流中读取数据的时候,只要根据包头和数据长度就能取到需要的数据。这个其实就是平时说的协议(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 )
}
}
|
运行这个程序可以看到服务端很好的获取到期望的json格式数据。完整代码演示下载:golang粘包问题解决示例
最后
上面演示的两种方法适用于不同的场景。第一种方法比较适合被动型的场景,例如打开网页,用户有请求才处理交互。第二种方法适合于主动推送的类型,例如即时聊天系统,因为要即时给用户推送消息,保持长连接是不可避免的,这时候就要用这种方法。
转载请注明:快乐编程 » golang中tcp socket粘包问题和处理
golang中tcp socket粘包问题和处理相关推荐
- TCP Socket 粘包
这两天看csdn有一些关于socket粘包,socket缓冲区设置的问题.发现自己不是非常清楚,所以查资料了解记录一下: 一两个简单概念长连接与短连接: 1.长连接 Client方与Server ...
- Go语言中Tcp协议粘包问题处理
在用golang开发人工客服系统的时候碰到了粘包问题,那么什么是粘包呢?例如我们和客户端约定数据交互格式是一个json格式的字符串: {"Id":1,"Name" ...
- socket Php 粘包,python3 tcp的粘包现象和解决办法解析
这篇文章主要介绍了python3 tcp的粘包现象和解决办法解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 服务器端 import socket ...
- Socket粘包问题
这两天看csdn有一些关于socket粘包,socket缓冲区设置的问题,发现自己不是很清楚,所以查资料了解记录一下: 一两个简单概念长连接与短连接: 1.长连接 Client方与Server方先建立 ...
- TCP通信粘包问题分析和解决
在socket网络程序中,TCP和UDP分别是面向连接和非面向连接的.因此TCP的socket编程,收发两端(客户端和服务器端)都要有成对的socket,因此,发送端为了将多个发往接收端的包,更有效的 ...
- TCp传输粘包问题
解决TCP网络传输"粘包"问题 当前在网络传输应用中,广泛采用的是TCP/IP通信协议及其标准的socket应用开发编程接口(API).TCP/IP传输层有两个并列的协 议:T ...
- Socket粘包问题终极解决方案—Netty版(2W字)!
作者 | 王磊 来源 | Java中文社群(ID:javacn666) 转载请联系授权(微信ID:GG_Stone) 上一篇我们写了<Socket粘包问题的3种解决方案>,但没想到评论区竟 ...
- Netty解决TCP的粘包和分包(二)
2019独角兽企业重金招聘Python工程师标准>>> Netty解决TCP的粘包和分包(二) 使用LengthFieldBasedFrameDecoder解码器分包 先看一下这个类 ...
- (Java)socket网络编程及处理socket粘包拆包问题
目录 1.socket简介 2.TCP/IP协议 3.tcp三次握手 4.socket的一些接口函数原理 5.java socket 长连接粘包拆包问题 6.socket模拟服务端客户端发消息 7.U ...
最新文章
- CenterFusion:融合雷达与摄像头数据的高精度3D目标检测
- china-pub,当当,卓越购书经验谈
- 放上了一篇几个月前写的东西
- Spring 学习二-----AOP的原理与简单实践
- 通过kubeadm安装kubernetes 1.7文档记录[docker容器方式]
- sql无法写入mysql_无法通过写入mysql数据库pandas.to\u sql使用sqlalchemy,但不能通过没有pandas的sqlalchemy...
- excel保存快捷键_干货 | 快速提高工作效率的电脑快捷键!
- java 扫描jar包_java 扫描指定包(包括jar包)
- 网站开发中敏感信息加密
- Linux系统通过Squid配置实现代理上网
- ftp服务器多用文件夹权限,自己动手搭建隔离用户的FTP服务器之权限分配(二)...
- boost asio linux原理,Linux C++ Boost asio ACE 视频教程
- Python中的文件基础
- Microsoft Word 进行简繁转换时,报错“word无法进行处理,缺少多个进行间/繁体中文转换所必需的文件”的解决办法
- Eagle设计师必备利器管理工具
- java jpanel边框_JPanel设置边框
- 计算机考研专业课考c语言的大学,【择校必看】十三所计算机专业课只考数据结构的985院校!...
- 锥智科技完成5000万元融资 官网启用拼音域名zhuizhikeji.com
- mysql经典问题四表查询(教师,学生,成绩,课程表)
- 郑州分销系统开发|如何实现快速分销裂变?
热门文章
- 洛谷——P1179 [NOIP2010 普及组] 数字统计
- JBDC操作事务源码解析
- oreo另一个意思_other和another区别:两种不同的“另一个”
- C# 类与对象(面向对象的编程)
- 分布式系统面试连环炮
- Android进程框架:线程通信的桥梁Handler
- ASP.NETMVC Model验证(五)
- NetApp公司的4KB块写入技术真能容纳更多数据吗?
- image.merge图像有什么变化_图像特征工程:HOG特征描述子介绍
- 【编译原理笔记14】中间代码生成:布尔表达式的回填,控制流语句的回填,switch语句的翻译,过程调用语句的翻译