Zinx-V0.5消息封装和处理tcp粘包

Zinx-V0.5消息封装和处理tcp粘包

1.将Request中的data、len再进行封装，封装成一个message，其中包含id、data、len

1.1.抽象层ziface

type IMessage interface { GetDataLen() uint32 //获取消息数据段长度 GetMsgId() uint32 //获取消息ID GetData() []byte //获取消息内容 SetMsgId(uint32) //设计消息ID SetData([]byte) //设计消息内容 SetDataLen(uint32) //设置消息数据段长度 }

1.2.实现层znet

type Message struct { Id uint32 //消息的ID DataLen uint32 //消息的长度 Data []byte //消息的内容 } //创建一个Message消息包 func NewMsgPackage(id uint32, data []byte) *Message { return &Message{ Id: id, DataLen: uint32(len(data)), Data: data, } } //获取消息数据段长度 func (msg *Message) GetDataLen() uint32 { return msg.DataLen } //获取消息ID func (msg *Message) GetMsgId() uint32 { return msg.Id } //获取消息内容 func (msg *Message) GetData() []byte { return msg.Data } //设置消息数据段长度 func (msg *Message) SetDataLen(len uint32) { msg.DataLen = len } //设计消息ID func (msg *Message) SetMsgId(msgId uint32) { msg.Id = msgId } //设计消息内容 func (msg *Message) SetData(data []byte) { msg.Data = data }

2.定义一个能解决tcp粘包问题的拆包封包模块

2.1.抽象层ziface

type IDataPack interface{ GetHeadLen() uint32 //获取包头长度方法 Pack(msg IMessage)([]byte, error) //封包方法 Unpack([]byte)(IMessage, error) //拆包方法 }

2.2.实现层znet

//封包拆包类实例，暂时不需要成员 type DataPack struct {} //封包拆包实例初始化方法 func NewDataPack() *DataPack { return &DataPack{} } //获取包头长度方法 func(dp *DataPack) GetHeadLen() uint32 { //Id uint32(4字节) + DataLen uint32(4字节) return 8 } //封包方法(压缩数据) func(dp *DataPack) Pack(msg ziface.IMessage)([]byte, error) { //创建一个存放bytes字节的缓冲 dataBuff := bytes.NewBuffer([]byte{}) //写dataLen if err := binary.Write(dataBuff, binary.LittleEndian, msg.GetDataLen()); err != nil { return nil, err } //写msgID if err := binary.Write(dataBuff, binary.LittleEndian, msg.GetMsgId()); err != nil { return nil, err } //写data数据 if err := binary.Write(dataBuff, binary.LittleEndian, msg.GetData()); err != nil { return nil ,err } return dataBuff.Bytes(), nil } //拆包方法(解压数据) func(dp *DataPack) Unpack(binaryData []byte)(ziface.IMessage, error) { //创建一个从输入二进制数据的ioReader dataBuff := bytes.NewReader(binaryData) //只解压head的信息，得到dataLen和msgID msg := &Message{} //读dataLen if err := binary.Read(dataBuff, binary.LittleEndian, &msg.DataLen); err != nil { return nil, err } //读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 }

​ 封包过程就是将一个message封装成一条[]byte类型的数据，其中前4字节是一个uint32类型数据，内容为data数据的len，后面4字节是一个uint32类型数据，内容为data数据的id。

​ 拆包过程就是先读出数据的前8字节内容，代表了后面data的len和id，用这两数据返回一个message类型的对象，然后通过len来判断后面data的len，创建一个len长度的缓冲区，将一条完整的data读出，添加到message中，完成解读。

3.将上述两模块集成到zinx中

3.1改变Request的抽象层和实现层

type IRequest interface { //得到当前的请求的链接 GetConnection() IConnection //得到请求的消息 GetMsg() IMessage } type Request struct { //链接信息 conn ziface.IConnection //客户端发送的消息 msg ziface.IMessage } func NewReqeust(conn ziface.IConnection, msg ziface.IMessage) ziface.IRequest { req := &Request{ conn:conn, msg:msg, } return req } //得到当前的请求的链接 func(r *Request) GetConnection() ziface.IConnection { return r.conn } //得到链接的数据 func(r *Request) GetMsg() ziface.IMessage { return r.msg }

3.2将zinx读包 的机制，由之前的一次read，改成按照拆包机制， 读取两次

func (c *Connection) StartReader() { ...... for { /* buf := make([]byte, config.GlobalObject.MaxPackageSize) cnt, err := c.Conn.Read(buf) if err != nil { fmt.Println("recv buf err", err) break } */ //创建拆包封包的对象 dp := NewDataPack() //读取客户端消息的头部 headData := make([]byte, dp.GetHeadLen()) if _, err := io.ReadFull(c.Conn, headData); err != nil { fmt.Println("read msg head error", err) break } //根据头部 获取数据的长度，进行第二次读取 msg, err := dp.UnPack(headData) //将msg 头部信息填充满 if err != nil { fmt.Println("unpack error ", err) break } //根据长度 再次读取 var data []byte if msg.GetMsgLen() > 0 { //有内容 data = make([]byte, msg.GetMsgLen()) if _, err := io.ReadFull(c.Conn, data); err != nil { fmt.Println("read msg data error ", err) break } } msg.SetData(data) //将读出来的msg 组装一个request //将当前一次性得到的对端客户端请求的数据 封装成一个Request req := NewReqeust(c, msg) //调用用户传递进来的业务 模板 设计模式 go func() { c.Router.PreHandle(req) c.Router.Handle(req) c.Router.PostHandle(req) }() } }

3.3将zinx的发包机制， 有之前的write二进制，改成先封包，再发送

修改send方法

func (c *Connection) Send(msgId uint32, msgData []byte) error { if c.isClosed == true { return errors.New("Connection closed ..send Msg ") } //封装成msg dp := NewDataPack() binaryMsg, err := dp.Pack(NewMsgPackage(msgId, msgData)) if err != nil { fmt.Println("Pack error msg id = ", msgId) return err } //将binaryMsg发送给对端 if _, err := c.Conn.Write(binaryMsg); err != nil { fmt.Println("send buf error") return err } return nil }