服务端代码如下
package main
import (
"bufio"
"fmt"
"net"
)
//处理函数
func process(conn net.Conn) {
defer conn.Close() //关闭连接
for {
//获取输入流
reader := bufio.NewReader(conn)
//每次读取的大小
var buf [1024]byte
n, err := reader.Read(buf[:]) //读取数据 从头到尾读取
if err != nil {
fmt.Println("read from client failed,err", err)
break
}
recvStr := string(buf[:n])
fmt.Println("收到client端发来的数据:", recvStr)
conn.Write([]byte(recvStr))
}
}
func main() {
listen, err := net.Listen("tcp", "127.0.0.1:30000")
if err != nil {
fmt.Println("listen failed,err", err)
return
}
for {
conn, err := listen.Accept()
if err != nil {
fmt.Println("accept failed,err", err)
continue
}
go process(conn) //开启启程去处理读取数据
}
}
客户端
package main
import (
"fmt"
"net"
)
func main() {
conn, err := net.Dial("tcp", "127.0.0.1:30000")
if err != nil {
fmt.Println("diall error:", err)
return
}
defer conn.Close()
for i := 0; i < 20; i++ {
msg := `Hello, Hello. How are you?`
conn.Write([]byte(msg))
}
}
result:
result
通过以上截图可以看出客户端写了19次的消息到服务端。但是服务端接受的数据把19条数据整合成了一条信息。把多条信息都粘在了一起。
为什么会出现粘包？
主要原因就是tcp数据传递模式是流模式，在保持长连接的时候可以进行多次的收和发。"粘包"可以发送在发送端，也可发生在接收端：
- 由Nagle算法造成的发送端的粘包：Nagle算法是一种改善网络传输效率的算法。简单来说就是当我们提交一段数据给TCP发送时，TCP并不立刻发送此段数据，而是等待一小段时间看看在等待期间是否还有要发送的数据，若有则会一次把这两段数据发送出去。
- 接收端接收不及时造成的接收端粘包：TCP会把接收到的数据存在自己的缓冲区中，然后通知应用层取数据。当应用层由于某些原因不能及时的把TCP的数据取出来，就会造成TCP缓冲区中存放了几段数据。
解决办法
粘包主要的问题出现在接收方不确定要传输的数据包的大小。因此我们可以把数据包进行封包和拆包的操作
封包:封包就是给一段数据加上包头，这样以来数据包就分为包头和包体两部分内容了。包头部分的长度是固定的。并且存储了包体的长度，根据包头长度固定以及包含的包体长度 就能正确拆分出一个完整的数据包。
// Encode 将消息编码
func Encode(message string) ([]byte, error) {
// 读取消息的长度，转换成int32类型（占4个字节）
//长度是int32 为4个字节 也就是占包的前4位
var length = int64(len(message))
var pkg = new(bytes.Buffer)
// 写入消息头
//intDataSize write方法中根据第三个参数 data获取字节长度 int32 长度位4字节 int64的话就为8个字节可自行参考
//不一定非要定义4个字节
err := binary.Write(pkg, binary.LittleEndian, length)
if err != nil {
return nil, err
}
// 写入消息实体
err = binary.Write(pkg, binary.LittleEndian, []byte(message))
if err != nil {
return nil, err
}
return pkg.Bytes(), nil
}
// Decode 解码消息
func Decode(reader *bufio.Reader) (string, error) {
// 读取消息的长度
//可能在这边大家不是特别理解为什么指定读取8个字节
//可参考上面ecode的write当中的intDataSize 方法。上面我才用了int64 占byte字节8字节。如果采用int32那么就是占4字节
lengthByte, _ := reader.Peek(8) // 读取前8个字节
lengthBuff := bytes.NewBuffer(lengthByte)
var length int64
err := binary.Read(lengthBuff, binary.LittleEndian, &length)
if err != nil {
return "", err
}
// Buffered返回缓冲中现有的可读取的字节数。
if int64(reader.Buffered()) < length+8 {
return "", err
}
// 读取真正的消息数据
pack := make([]byte, int(8+length))
_, err = reader.Read(pack)
if err != nil {
return "", err
}
return string(pack[8:]), nil
}
//服务端改造如下
func process(conn net.Conn) {
defer conn.Close()
reader := bufio.NewReader(conn)
for {
msg, err := proto.Decode(reader)
if err == io.EOF {
return
}
if err != nil {
fmt.Println("decode msg failed, err:", err)
return
}
fmt.Println("收到client发来的数据：", msg)
}
}
func main() {
listen, err := net.Listen("tcp", "127.0.0.1:30000")
if err != nil {
fmt.Println("listen failed, err:", err)
return
}
defer listen.Close()
for {
conn, err := listen.Accept()
if err != nil {
fmt.Println("accept failed, err:", err)
continue
}
go process(conn)
}
}
//客户端改造如下
func main() {
conn, err := net.Dial("tcp", "127.0.0.1:30000")
if err != nil {
fmt.Println("dial failed, err", err)
return
}
defer conn.Close()
for i := 0; i < 20; i++ {
msg := `Hello, Hello. How are you?`
data, err := proto.Encode(msg)
if err != nil {
fmt.Println("encode msg failed, err:", err)
return
}
conn.Write(data)
}
}
粘包
网友评论