首先iserver的AddRouter()的接口要稍微改一下，增添MsgId参数

    zinx/ziface/iserver.go

    1. package ziface
    3. //定义服务器接口
    4. type IServer interface{
    5.     //启动服务器方法
    6.     Start()
    7.     //停止服务器方法
    8.     Stop()
    9.     //开启业务服务方法
    10.     Serve()
    11.     //路由功能：给当前服务注册一个路由业务方法，供客户端链接处理使用
    12.     AddRouter(msgId uint32, router IRouter)
    13. }

    其次，Server类中 之前有一个Router成员 ，代表唯一的处理方法，现在应该替换成MsgHandler成员

    zinx/znet/server.go

    1. type Server struct {
    2.     //服务器的名称
    3.     Name string
    4.     //tcp4 or other
    5.     IPVersion string
    6.     //服务绑定的IP地址
    7.     IP string
    8.     //服务绑定的端口
    9.     Port int
    10.     //当前Server的消息管理模块，用来绑定MsgId和对应的处理方法
    11.     msgHandler ziface.IMsgHandle
    12. }

    初始化Server自然也要更正，增加msgHandler初始化

    1. /*
    2.   创建一个服务器句柄
    3.  */
    4. func NewServer () ziface.IServer {
    5.     utils.GlobalObject.Reload()
    7.     s:= &Server {
    8.         Name :utils.GlobalObject.Name,
    9.         IPVersion:"tcp4",
    10.         IP:utils.GlobalObject.Host,
    11.         Port:utils.GlobalObject.TcpPort,
    12.         msgHandler: NewMsgHandle(), //msgHandler 初始化
    13.     }
    14.     return s
    15. }

    然后当Server在处理conn请求业务的时候，创建conn的时候也需要把msgHandler作为参数传递给Connection对象

    1. //...
    2. dealConn := NewConntion(conn, cid, s.msgHandler)
    3. //...

    那么接下来就是Connection对象了。固然在Connection对象中应该有MsgHandler的成员，来查找消息对应的回调路由方法

    zinx/znet/connection.go

    1. type Connection struct {
    2.     //当前连接的socket TCP套接字
    3.     Conn *net.TCPConn
    4.     //当前连接的ID 也可以称作为SessionID，ID全局唯一
    5.     ConnID uint32
    6.     //当前连接的关闭状态
    7.     isClosed bool
    8.     //消息管理MsgId和对应处理方法的消息管理模块
    9.     MsgHandler ziface.IMsgHandle
    10.     //告知该链接已经退出/停止的channel
    11.     ExitBuffChan chan bool
    12. }
    14. //创建连接的方法
    15. func NewConntion(conn *net.TCPConn, connID uint32, msgHandler ziface.IMsgHandle) *Connection{
    16.     c := &Connection{
    17.         Conn:     conn,
    18.         ConnID:   connID,
    19.         isClosed: false,
    20.         MsgHandler: msgHandler,
    21.         ExitBuffChan: make(chan bool, 1),
    22.     }
    24.     return c
    25. }

    最后，在conn已经拆包之后，需要调用路由业务的时候，我们只需要让conn调用MsgHandler中的DoMsgHander()方法就好了

    zinx/znet/connection.go

    1. func (c *Connection) StartReader() {
    2.     fmt.Println("[Reader Goroutine is running]")
    3.     defer fmt.Println(c.RemoteAddr().String(), "[conn Reader exit!]")
    4.     defer c.Stop()
    6.     for  {
    7.         // 创建拆包解包的对象
    8.         dp := NewDataPack()
    10.         //读取客户端的Msg head
    11.         headData := make([]byte, dp.GetHeadLen())
    12.         if _, err := io.ReadFull(c.GetTCPConnection(), headData); err != nil {
    13.             fmt.Println("read msg head error ", err)
    14.             break
    15.         }
    17.         //拆包，得到msgid 和 datalen 放在msg中
    18.         msg , err := dp.Unpack(headData)
    19.         if err != nil {
    20.             fmt.Println("unpack error ", err)
    21.             break
    22.         }
    24.         //根据 dataLen 读取 data，放在msg.Data中
    25.         var data []byte
    26.         if msg.GetDataLen() > 0 {
    27.             data = make([]byte, msg.GetDataLen())
    28.             if _, err := io.ReadFull(c.GetTCPConnection(), data); err != nil {
    29.                 fmt.Println("read msg data error ", err)
    30.                 continue
    31.             }
    32.         }
    33.         msg.SetData(data)
    35.         //得到当前客户端请求的Request数据
    36.         req := Request{
    37.             conn:c,
    38.             msg:msg,
    39.         }
    40.         //从绑定好的消息和对应的处理方法中执行对应的Handle方法
    41.         go c.MsgHandler.DoMsgHandler(&req)
    42.     }
    43. }

    好了，大功告成，我们来测试一下Zinx的多路由设置功能吧。