同时支持websocket和socket的轻量框架

前言：

通过之前的几篇文章我们详细的介绍到了一个socket框架应该怎么架构，需要些什么模块，可是美中不足的就是它只支持最简单的socket协议，不能够满足实际生产情况，于是我便对此框架进行了改造，让它能够同时支持websocket 和 socket ，而且插件式 注册，当需要别的长连接协议的时，完全可以自己定制。已经把所有代码整合了，希望给个星星支持一下 microSocket。

实现基础：

一切编程皆socket ，这话有点说的绝对。但是仔细想想，确实也就是那么回事，网络通信现在99%都是socket吧。我们有n多种协议，但是都是socket的，所以这些协议无非就是 握手 解包 封包 上面不同 ，那我们把这些 过程 单独封装 不就能够 写一个框架能够随意切换 协议了么！

代码实现：

废话不多说 我们直接看代码 ！

type SocketTypes interface{
    ConnHandle(msf *Msf,sess *Session)
    Pack(data []byte)[]byte
}

我们定义了一个接口 必须实现两个 函数

• .ConnHandle 函数 传入一个session 对象 其实就是一个 socket握手成功的句柄，我们在这个函数里面死循环不断地读取 句柄 的数据 并且 解包 处理粘包 和 解析数据 并 路由
• . Pack 函数 负责把要发送的数据 打包成指定协议的 数据包

如此一来我们 server 代码便 非常的 整洁

func NewMsf(msfEvent MsfEventer,socketType SocketTypes) *Msf {
    msf := &Msf{
        EventPool:     NewRouterMap(),
        MsfEvent:      msfEvent,
        SocketType   :socketType,
    }
    msf.SessionMaster = NewSessonM(msf)
    return msf
}

func (this *Msf) Listening(address string) {
    tcpListen, err := net.Listen("tcp", address)

    if err != nil {
        panic(err)
    }
    go this.SessionMaster.HeartBeat(2)
    fd := uint32(0)
    for {
        conn, err := tcpListen.Accept()
        if err != nil {
            log.Println(err)
            continue
        }

        //调用握手事件
        if this.MsfEvent.OnHandel(fd, conn) == false {
            continue
        }

        sess := NewSession(fd, conn)
        this.SessionMaster.SetSession(fd, sess)
        fd++
        //调用相应协议的处理函数
        go this.SocketType.ConnHandle(this,sess)
    }
}

上面就是 server 的两个主要 函数

• . 第一个函数 不用多介绍，就是创建一个server 对象 ，传入一个框架事件对象，和一个 协议对象。
• . 第二个函数实现的逻辑就是 监听一个端口 死循环 不断的接收新连接 ，一接到新连接 就 调用 协议对象 处理该连接 ，并且设置 心跳 还有 一些错误处理 。

websocket协议对象的实现：

为了给大家做一个例子 我搜索了相关资料 除了 封装了一个普通 socket 的协议对象 还封装了一个 websocket 对象 希望能够一起学习，

type WebSocket struct {
}

//ws接收消息
func (this *WebSocket) ConnHandle(msf *Msf, sess *Session) {
    defer func() {
        msf.SessionMaster.DelSessionById(sess.Id)
        //调用断开链接事件
        msf.MsfEvent.OnClose(sess.Id)
    }()

    if this.Handshake(sess) == false {
        return
    }

    var (
        buf     []byte
        err     error
        fin     byte
        opcode  byte
        mask    byte
        mKey    []byte
        length  uint64
        l       uint16
        payload byte
        tembuf  []byte
    )

    for {
        buf = make([]byte, 2)
        _, err = io.ReadFull(sess.Con, buf)
        if err != nil {
            break
        }
        fin = buf[0] >> 7
        opcode = buf[0] & 0xf
        if opcode == 8 {
            break
        }
        mask = buf[1] >> 7
        payload = buf[1] & 0x7f
        switch {
        case payload < 126:
            length = uint64(payload)
        case payload == 126:
            buf = make([]byte, 2)
            io.ReadFull(sess.Con, buf)
            binary.Read(bytes.NewReader(buf), binary.BigEndian, &l)
            length = uint64(l)
        case payload == 127:
            buf = make([]byte, 8)
            io.ReadFull(sess.Con, buf)
            binary.Read(bytes.NewReader(buf), binary.BigEndian, &length)
        }
        if mask == 1 {
            mKey = make([]byte, 4)
            io.ReadFull(sess.Con, mKey)
        }
        buf = make([]byte, length)
        io.ReadFull(sess.Con, buf)
        if mask == 1 {
            for i, v := range buf {
                buf[i] = v ^ mKey[i%4]
            }
        }
        //更新最近接收到消息的时间
        sess.UpdateTime()
        if len(buf) == 0 {
            continue
        }
        tembuf = append(tembuf,buf...)
        if fin == 0 {
            continue
        }
        //把请求的到数据转化为map
        requestData := util.String2Map(string(tembuf))
        tembuf = make([]byte,0)
        if requestData["module"] == "" || requestData["action"] == "" ||
msf.EventPool.ModuleExit(requestData["module"]) == false {
            log.Println("not find module ", requestData)
            continue
        }
        requestData["fd"] = fmt.Sprintf("%d", sess.Id)
        //调用接收消息事件
        if msf.MsfEvent.OnMessage(sess.Id, requestData) == false {
            return
        }
        //路由
        msf.EventPool.Hook(requestData["module"], requestData["action"], requestData)
    }
}

//websocket 打包事件
func (this *WebSocket) Pack(data []byte) []byte {
    length := len(data)
    frame := []byte{129}
    switch {
    case length < 126:
        frame = append(frame, byte(length))
    case length <= 0xffff:
        buf := make([]byte, 2)
        binary.BigEndian.PutUint16(buf, uint16(length))
        frame = append(frame, byte(126))
        frame = append(frame, buf...)
    case uint64(length) <= 0xffffffffffffffff:
        buf := make([]byte, 8)
        binary.BigEndian.PutUint64(buf, uint64(length))
        frame = append(frame, byte(127))
        frame = append(frame, buf...)
    default:
        return []byte{}
    }
    frame = append(frame, data...)
    return frame
}

//握手包
func (this *WebSocket) Handshake(sess *Session) bool {
    reader := bufio.NewReader(sess.Con)
    key := ""
    str := ""
    for {
        line, _, err := reader.ReadLine()
        if err != nil {
            log.Fatal(err)
            return false
        }
        if len(line) == 0 {
            break
        }
        str = string(line)
        if strings.HasPrefix(str, "Sec-WebSocket-Key") {
            key = str[19:43]
        }
    }
    sha := sha1.New()
    io.WriteString(sha, key+"258EAFA5-E914-47DA-95CA-C5AB0DC85B11")
    key = base64.StdEncoding.EncodeToString(sha.Sum(nil))

    header := "HTTP/1.1 101 Switching Protocols\r\n" +
        "Connection: Upgrade\r\n" +
        "Sec-WebSocket-Version: 13\r\n" +
        "Sec-WebSocket-Accept: " + key + "\r\n" +
        "Upgrade: websocket\r\n\r\n"
    sess.Con.Write([]byte(header))
    return true
}

此对象我已经测试过了 完全没有问题 ！
如果有什么 疑问的 欢迎 留言 一起讨论 。