现在我们可以基于Zinx框架完成发送msg功能的测试用例了。

    Server.go

    1. package main
    3. import (
    4.     "fmt"
    5.     "zinx/ziface"
    6.     "zinx/znet"
    7. )
    9. //ping test 自定义路由
    10. type PingRouter struct {
    11.     znet.BaseRouter
    12. }
    14. //Test Handle
    15. func (this *PingRouter) Handle(request ziface.IRequest) {
    16.     fmt.Println("Call PingRouter Handle")
    17.     //先读取客户端的数据，再回写ping...ping...ping
    18.     fmt.Println("recv from client : msgId=", request.GetMsgID(), ", data=", string(request.GetData()))
    20.     //回写数据
    21.     err := request.GetConnection().SendMsg(1, []byte("ping...ping...ping"))
    22.     if err != nil {
    23.         fmt.Println(err)
    24.     }
    25. }
    27. func main() {
    28.     //创建一个server句柄
    29.     s := znet.NewServer()
    31.     //配置路由
    32.     s.AddRouter(&PingRouter{})
    34.     //开启服务
    35.     s.Serve()
    36. }

    当前Server端是先把客户端发送来Msg解析，然后返回一个MsgId为1的消息，消息内容是”ping…ping…ping”

    Client.go

    1. package main
    3. import (
    4.     "fmt"
    5.     "io"
    6.     "net"
    7.     "time"
    8.     "zinx/znet"
    9. )
    11. /*
    12.     模拟客户端
    13.  */
    14. func main() {
    16.     fmt.Println("Client Test ... start")
    17.     //3秒之后发起测试请求，给服务端开启服务的机会
    18.     time.Sleep(3 * time.Second)
    20.     conn,err := net.Dial("tcp", "127.0.0.1:7777")
    21.     if err != nil {
    22.         fmt.Println("client start err, exit!")
    23.         return
    24.     }
    26.     for {
    27.         //发封包message消息
    28.         dp := znet.NewDataPack()
    29.         msg, _ := dp.Pack(znet.NewMsgPackage(0,[]byte("Zinx V0.5 Client Test Message")))
    30.         _, err := conn.Write(msg)
    31.         if err !=nil {
    32.             fmt.Println("write error err ", err)
    33.             return
    34.         }
    36.         //先读出流中的head部分
    37.         headData := make([]byte, dp.GetHeadLen())
    38.         _, err = io.ReadFull(conn, headData) //ReadFull 会把msg填充满为止
    39.         if err != nil {
    40.             fmt.Println("read head error")
    41.             break
    42.         }
    43.         //将headData字节流 拆包到msg中
    44.         msgHead, err := dp.Unpack(headData)
    45.         if err != nil {
    46.             fmt.Println("server unpack err:", err)
    47.             return
    48.         }
    50.         if msgHead.GetDataLen() > 0 {
    51.             //msg 是有data数据的，需要再次读取data数据
    52.             msg := msgHead.(*znet.Message)
    53.             msg.Data = make([]byte, msg.GetDataLen())
    55.             //根据dataLen从io中读取字节流
    56.             _, err := io.ReadFull(conn, msg.Data)
    57.             if err != nil {
    58.                 fmt.Println("server unpack data err:", err)
    59.                 return
    60.             }
    62.             fmt.Println("==> Recv Msg: ID=", msg.Id, ", len=", msg.DataLen, ", data=", string(msg.Data))
    63.         }
    65.         time.Sleep(1*time.Second)
    66.     }
    67. }

    这里Client客户端，模拟了一个MsgId为0的”Zinx V0.5 Client Test Message”消息，然后把服务端返回的数据打印出来。

    我们分别在两个终端运行

    1. $go run Server.go
    1. $go run Client.go

    服务端结果:

    1. $ go run Server.go 
    2. Add Router succ! 
    3. [START] Server name: zinx v-0.5 demoApp,listenner at IP: 127.0.0.1, Port 7777 is starting
    4. [Zinx] Version: V0.4, MaxConn: 3, MaxPacketSize: 4096
    5. start Zinx server   zinx v-0.5 demoApp  succ, now listenning...
    6. Reader Goroutine is  running
    7. Call PingRouter Handle
    8. recv from client : msgId= 0 , data= Zinx V0.5 Client Test Message
    9. Call PingRouter Handle
    10. recv from client : msgId= 0 , data= Zinx V0.5 Client Test Message
    11. Call PingRouter Handle
    12. recv from client : msgId= 0 , data= Zinx V0.5 Client Test Message
    13. ...

    客户端结果:

    1. $ go run Client.go 
    2. Client Test ... start
    3. ==> Recv Msg: ID= 1 , len= 18 , data= ping...ping...ping
    4. ==> Recv Msg: ID= 1 , len= 18 , data= ping...ping...ping
    5. ==> Recv Msg: ID= 1 , len= 18 , data= ping...ping...ping
    6. ...

    好了，我们的Zinx已经成功的集成消息的封装功能了，这样我们就有Zinx的通信的基本协议标准了。