Go-websocket

最近在学习Go语言，利用之前的项目作为案例进行重构。项目背景：php提供TCP服务，硬件连接服务器需要处理信息，然后将处理的信息在发送客户端，客户端拿到信息展示给用户。第一种方案客户端对发送信息的接口进行轮询，检查硬件是否有信息返回，这样不好太浪费资源；第二种方案采用websocket将信息主动发送给客户端，客户端做后续的展示和处理工作；所以最终采用websocket。PHP实现websocket采用GatewayWorker，经过商业论证还是很稳定的。
在用Go语言重构项目的时候，需要用Go重新搭建Websocket，去网上查了一些资料，利用gorilla/websocket在嵌套web框架就可以实现websocket，目前采用Go语言的iris Web框架，接下来就说说我是怎么实现的。

说明

首先我们要理解这个过程是怎么实现的，其实就是以下几个过程：
1、首先要创建连接；
2、为连接的客户端绑定id，让它具有唯一的标识；
3、确认客户端要发送给谁，在他们传送信息的时候，对于Go语言来说需要为他俩创建一个通道（chan）进行传递信息；
4、将信息发送给指定的用户，这个过程其实就是一个用户将信息发送给通道，让另一个用户去读取，最终实现发送和接收信息的流程。
提示：对于多个用户来说需要使用map集合来保存连接对象和绑定唯一标识的关系。

初始化操作

var (
    upgrader = websocket.Upgrader{ //对websocket做一些初始化
        WriteBufferSize: 10240,
        ReadBufferSize:  10240,
        CheckOrigin: func(r *http.Request) bool { //允许跨域
            return true
        },
    }
    Clients = make(map[string]*Client)
)

type Client struct {
    client    *websocket.Conn            //websocket连接
    Broadcast chan *BroadcastMessageType // websocket连接传输数据的通道
}

type BroadcastMessageType struct {
    To      string //发给谁
    Msg     []byte //发送的内容
    MsgType int    //发送内容的类型
}

//服务端接收信息，要发送给指定的用户
type ReceiveMsgType struct {
    FromUser    string `json:"fromUser"`
    ToUser      string `json:"toUser"`
    Content     string `json:"content"`
    ContentType int    `json:"contentType"`
}

封装返回的信息

//websocket返回
type SocketReturnValue struct {
    CallbackName string `json:"callbackName"`
    JsonResponse string `json:"jsonResponse"`
}

//websocket响应，这块的响应是为返回JsonResponse做扩展，可以返回你想要的各种数据
type ReturnConn struct {
    ConnId string `json:"connId"`
}

发送信息

//发送信息
func (c *Client) SendMessage() {
    for {
        select {
        case data := <-c.Broadcast:
            toClient := Clients["websocket"] //要发送给谁
            err := toClient.client.WriteMessage(websocket.TextMessage, data.Msg)
            if err != nil {
                golog.Error(err)
            }
        }
    }
}

接收信息

func (c *Client) ReceiveMessage() {
    for {
        _, msg, err := c.client.ReadMessage()
        var receiveType ReceiveMsgType
        if err != nil || len(msg) == 0 {
            golog.Error(err)
            return
        }
        returnValue := SocketReturnValue{
            CallbackName: "onReceiveMsg",
            JsonResponse: string(msg),
        }
        err = json.Unmarshal(msg, &receiveType)
        res, err := json.Marshal(&returnValue)
        if err != nil {
            golog.Error(err)
        }
        message := BroadcastMessageType{
            To:      "websocket",
            Msg:     res,
            MsgType: websocket.TextMessage,
        }
        c.Broadcast <- &message
    }
}

实例化

//创建websocket
func NewSocketClient(ctx iris.Context) {
    w := ctx.ResponseWriter()
    r := ctx.Request()
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        golog.Error(err)
    }
    connId := "websocket"
    newClient := Client{
        client:    conn,
        Broadcast: make(chan *BroadcastMessageType),
    }
    Clients[connId] = &newClient
    go newClient.SendMessage()    //发送信息
    go newClient.ReceiveMessage() //接收信息
    returnConn := ReturnConn{ConnId: connId}
    connJson, _ := json.Marshal(&returnConn)
    returnValue := SocketReturnValue{
        CallbackName: "onConn",
        JsonResponse: string(connJson),
    }
    var receiveMsg ReceiveMsgType
    receiveMsg.ToUser = connId

    resultJson, _ := json.Marshal(returnValue)
    message := BroadcastMessageType{
        To:      receiveMsg.ToUser,
        Msg:     resultJson,
        MsgType: websocket.TextMessage,
    }
    newClient.Broadcast <- &message
}

说明：考虑到有很多用户需要连接、 发送、接收信息，这块采用GO语言的高并发特性携程进行处理。目前我实现的是单个客户端与服务端进行连接，因为之前的项目的架构师服务端和客户端在同一台主机上，所以不涉及多用户。这块有个改进的方案：因为websocket嵌套在Web框架里面（参考下面的启动服务），所以每次连接是将当前的用户名传过来，将用户的信息以及连接唯一ID存放在数据库当中，这样可以扩展为多人的在线聊天室。可以扩展为好友聊天的形式

启动

//启动服务
func RunWebsocket(app *iris.Application) {
    app.Get("/socket", NewSocketClient)
}

以上就是实现websocket的全部过程，欢迎大家进行分讨论