我们这里就是采用经典的TLV(Type-Length-Value)封包格式来解决TCP粘包问题吧。

Type: 类型
Length: 数据长度
Value: 数据内容

5.2 消息的封包与拆包 - 图1

由于Zinx也是TCP流的形式传播数据,难免会出现消息1和消息2一同发送,那么zinx就需要有能力区分两个消息的边界,所以Zinx此时应该提供一个统一的拆包和封包的方法。在发包之前打包成如上图这种格式的有head和body的两部分的包,在收到数据的时候分两次进行读取,先读取固定长度的head部分,得到后续Data的长度,再根据DataLen读取之后的body。这样就能够解决粘包的问题了。

A) 创建 拆包 封包 的抽象类

在zinx/ziface下,创建idatapack.go文件

zinx/ziface/idatapack.go

package ziface

/*
    封包数据和拆包数据
    直接面向TCP连接中的数据流,为传输数据添加头部信息,用于处理TCP粘包问题。
 */
type IDataPack interface{
    GetHeadLen() uint32                    //获取包头长度方法
    Pack(msg IMessage)([]byte, error)    //封包方法
    Unpack([]byte)(IMessage, error)        //拆包方法
}

B) 拆包 封包 的实现类

在zinx/znet/下,创建datapack.go文件.

zinx/znet/datapack.go

package znet

import (
    "bytes"
    "encoding/binary"
    "errors"
    "zinx/utils"
    "zinx/ziface"
)

//封包拆包类实例,暂时不需要成员
type DataPack struct {}

//封包拆包实例初始化方法
func NewDataPack() *DataPack {
    return &DataPack{}
}

//获取包头长度方法
func(dp *DataPack) GetHeadLen() uint32 {
    //消息ID + 数据长度
    //Id uint32(4字节) +  DataLen uint32(4字节)
    return 8
}
//封包方法(压缩数据)
func(dp *DataPack) Pack(msg ziface.IMessage)([]byte, error) {
    //创建一个存放bytes字节的缓冲区
    dataBuff := bytes.NewBuffer([]byte{})

    //向 dataBuff[]缓冲区 写dataLen值:
    if err := binary.Write(dataBuff, binary.LittleEndian, msg.GetDataLen()); err != nil {
        return nil, err
    }

    //向 dataBuff[]缓冲区 写msgID值:
    if err := binary.Write(dataBuff, binary.LittleEndian, msg.GetMsgId()); err != nil {
        return nil, err
    }

    //向 dataBuff[]缓冲区 写data[]数据:
    if err := binary.Write(dataBuff, binary.LittleEndian, msg.GetData()); err != nil {
        return nil ,err
    }

    return dataBuff.Bytes(), nil
}
//拆包方法(解压数据)
//功能:读取 binaryData[] 中的 head部分
func(dp *DataPack) Unpack(binaryData []byte)(ziface.IMessage, error) {
    //创建一个从输入二进制数据的ioReader
    dataBuff := bytes.NewReader(binaryData)

    //只解压head的信息,得到dataLen和msgID
    msg := &Message{}

    //从dataBuff缓冲区,读取dataLen
    if err := binary.Read(dataBuff, binary.LittleEndian, &msg.DataLen); err != nil {
        return nil, err
    }

    //从dataBuff缓冲区,读取msgID
    if err := binary.Read(dataBuff, binary.LittleEndian, &msg.Id); err != nil {
        return nil, err
    }

    //判断dataLen的长度是否超出我们允许的最大包长度
    if (utils.GlobalObject.MaxPacketSize > 0 && msg.DataLen > utils.GlobalObject.MaxPacketSize) {
        return nil, errors.New("Too large msg data recieved")
    }

    //这里只需要把head的数据拆包出来就可以了,然后再通过head的长度,再从conn读取一次数据
    return msg, nil
}

需要注意的是整理的Unpack方法,因为我们从上图可以知道,我们进行拆包的时候是分两次过程的,第二次是依赖第一次的dataLen结果,所以Unpack只能解压出包头head的内容,得到msgId 和 dataLen。之后调用者再根据dataLen继续从io流中读取body中的数据

C) 测试拆包封包功能

为了容易理解,我们先不用集成zinx框架来测试,而是单独写一个Server和Client来测试一下封包拆包的功能

Server.go


package main

import (
    "fmt"
    "io"
    "net"
    "zinx/znet"
)

//只是负责测试datapack拆包,封包功能
func main() {
    //创建socket TCP Server
    listener, err := net.Listen("tcp", "127.0.0.1:7777")
    if err != nil {
        fmt.Println("server listen err:", err)
        return
    }

    //创建服务器gotoutine,负责从客户端goroutine读取粘包的数据,然后进行解析

    for {
        conn, err := listener.Accept()
        if err != nil {
            fmt.Println("server accept err:", err)
        }

        //处理客户端请求
        go func(conn net.Conn) {
            //创建封包拆包对象dp
            dp := znet.NewDataPack()
            for {
                //1 先读出流中的head部分
                headData := make([]byte, dp.GetHeadLen())
                _, err := io.ReadFull(conn, headData) //ReadFull 会把msg填充满为止
                if err != nil {
                    fmt.Println("read head error")
                    break
                }
                //将headData字节流 拆包到msg中
                msgHead, err := dp.Unpack(headData)
                if err != nil {
                    fmt.Println("server unpack err:", err)
                    return
                }

                if msgHead.GetDataLen() > 0 {
                    //msg 是有data数据的,需要再次读取data数据
                    msg := msgHead.(*znet.Message)
                    msg.Data = make([]byte, msg.GetDataLen())

                    //根据dataLen从io中读取字节流
                    _, err := io.ReadFull(conn, msg.Data)
                    if err != nil {
                        fmt.Println("server unpack data err:", err)
                        return
                    }

                    fmt.Println("==> Recv Msg: ID=", msg.Id, ", len=", msg.DataLen, ", data=", string(msg.Data))
                }
            }
        }(conn)
    }

}

Client.go

package main

import (
    "fmt"
    "net"
    "zinx/znet"
)

func main() {
    //客户端goroutine,负责模拟粘包的数据,然后进行发送
    conn, err := net.Dial("tcp", "127.0.0.1:7777")
    if err != nil {
        fmt.Println("client dial err:", err)
        return
    }

    //创建一个封包对象 dp
    dp := znet.NewDataPack()

    //封装一个msg1包
    msg1 := &znet.Message{
        Id:      0,
        DataLen: 5,
        Data:    []byte{'h', 'e', 'l', 'l', 'o'},
    }

    sendData1, err := dp.Pack(msg1)
    if err != nil {
        fmt.Println("client pack msg1 err:", err)
        return
    }

    msg2 := &znet.Message{
        Id:      1,
        DataLen: 7,
        Data:    []byte{'w', 'o', 'r', 'l', 'd', '!', '!'},
    }
    sendData2, err := dp.Pack(msg2)
    if err != nil {
        fmt.Println("client temp msg2 err:", err)
        return
    }

    //将sendData1,和 sendData2 拼接一起,组成粘包
    sendData1 = append(sendData1, sendData2...)

    //向服务器端写数据
    conn.Write(sendData1)

    //客户端阻塞
    select {}
}

运行Server.go

go run Server.go

运行Client.go

go run Client.go

我们从服务端看到运行结果

$go run Server.go 
==> Recv Msg: ID= 0 , len= 5 , data= hello
==> Recv Msg: ID= 1 , len= 7 , data= world!!

我们成功的得到了客户端发送的两个包,并且成功的解析出来。