大橙子网站建设,新征程启航

为企业提供网站建设、域名注册、服务器等服务

使用golang在实现一个websocket服务端-创新互联

本篇文章为大家展示了使用golang在实现一个websocket 服务端,内容简明扼要并且容易理解,绝对能使你眼前一亮,通过这篇文章的详细介绍希望你能有所收获。

在金州等地区,都构建了全面的区域性战略布局,加强发展的系统性、市场前瞻性、产品创新能力,以专注、极致的服务理念,为客户提供网站设计制作、网站设计 网站设计制作按需网站建设,公司网站建设,企业网站建设,成都品牌网站建设,全网营销推广,成都外贸网站制作,金州网站建设费用合理。

创建一个websocket的服务端

package smile

import (
  "errors"
  "log"
  "net/http"
  "sync"
  "time"

  "github.com/gorilla/websocket"
)

const (
  // 允许等待的写入时间
  writeWait = 10 * time.Second

  // Time allowed to read the next pong message from the peer.
  pongWait = 60 * time.Second

  // Send pings to peer with this period. Must be less than pongWait.
  pingPeriod = (pongWait * 9) / 10

  // Maximum message size allowed from peer.
  maxMessageSize = 512
)

// 大的连接ID,每次连接都加1 处理
var maxConnId int64

// 客户端读写消息
type wsMessage struct {
  // websocket.TextMessage 消息类型
  messageType int
  data    []byte
}

// ws 的所有连接
// 用于广播
var wsConnAll map[int64]*wsConnection

var upgrader = websocket.Upgrader{
  ReadBufferSize: 1024,
  WriteBufferSize: 1024,
  // 允许所有的CORS 跨域请求,正式环境可以关闭
  CheckOrigin: func(r *http.Request) bool {
    return true
  },
}

// 客户端连接
type wsConnection struct {
  wsSocket *websocket.Conn // 底层websocket
  inChan  chan *wsMessage // 读队列
  outChan chan *wsMessage // 写队列

  mutex   sync.Mutex // 避免重复关闭管道,加锁处理
  isClosed bool
  closeChan chan byte // 关闭通知
  id    int64
}

func wsHandler(resp http.ResponseWriter, req *http.Request) {
  // 应答客户端告知升级连接为websocket
  wsSocket, err := upgrader.Upgrade(resp, req, nil)
  if err != nil {
    log.Println("升级为websocket失败", err.Error())
    return
  }
  maxConnId++
  // TODO 如果要控制连接数可以计算,wsConnAll长度
  // 连接数保持一定数量,超过的部分不提供服务
  wsConn := &wsConnection{
    wsSocket: wsSocket,
    inChan:  make(chan *wsMessage, 1000),
    outChan:  make(chan *wsMessage, 1000),
    closeChan: make(chan byte),
    isClosed: false,
    id:    maxConnId,
  }
  wsConnAll[maxConnId] = wsConn
  log.Println("当前在线人数", len(wsConnAll))

  // 处理器,发送定时信息,避免意外关闭
  go wsConn.processLoop()
  // 读协程
  go wsConn.wsReadLoop()
  // 写协程
  go wsConn.wsWriteLoop()
}

// 处理队列中的消息
func (wsConn *wsConnection) processLoop() {
  // 处理消息队列中的消息
  // 获取到消息队列中的消息,处理完成后,发送消息给客户端
  for {
    msg, err := wsConn.wsRead()
    if err != nil {
      log.Println("获取消息出现错误", err.Error())
      break
    }
    log.Println("接收到消息", string(msg.data))
    // 修改以下内容把客户端传递的消息传递给处理程序
    err = wsConn.wsWrite(msg.messageType, msg.data)
    if err != nil {
      log.Println("发送消息给客户端出现错误", err.Error())
      break
    }
  }
}

// 处理消息队列中的消息
func (wsConn *wsConnection) wsReadLoop() {
  // 设置消息的大长度
  wsConn.wsSocket.SetReadLimit(maxMessageSize)
  wsConn.wsSocket.SetReadDeadline(time.Now().Add(pongWait))
  for {
    // 读一个message
    msgType, data, err := wsConn.wsSocket.ReadMessage()
    if err != nil {
      websocket.IsUnexpectedCloseError(err, websocket.CloseGoingAway, websocket.CloseAbnormalClosure)
      log.Println("消息读取出现错误", err.Error())
      wsConn.close()
      return
    }
    req := &wsMessage{
      msgType,
      data,
    }
    // 放入请求队列,消息入栈
    select {
    case wsConn.inChan <- req:
    case <-wsConn.closeChan:
      return
    }
  }
}

// 发送消息给客户端
func (wsConn *wsConnection) wsWriteLoop() {
  ticker := time.NewTicker(pingPeriod)
  defer func() {
    ticker.Stop()
  }()
  for {
    select {
    // 取一个应答
    case msg := <-wsConn.outChan:
      // 写给websocket
      if err := wsConn.wsSocket.WriteMessage(msg.messageType, msg.data); err != nil {
        log.Println("发送消息给客户端发生错误", err.Error())
        // 切断服务
        wsConn.close()
        return
      }
    case <-wsConn.closeChan:
      // 获取到关闭通知
      return
    case <-ticker.C:
      // 出现超时情况
      wsConn.wsSocket.SetWriteDeadline(time.Now().Add(writeWait))
      if err := wsConn.wsSocket.WriteMessage(websocket.PingMessage, nil); err != nil {
        return
      }
    }
  }
}

// 写入消息到队列中
func (wsConn *wsConnection) wsWrite(messageType int, data []byte) error {
  select {
  case wsConn.outChan <- &wsMessage{messageType, data}:
  case <-wsConn.closeChan:
    return errors.New("连接已经关闭")
  }
  return nil
}

// 读取消息队列中的消息
func (wsConn *wsConnection) wsRead() (*wsMessage, error) {
  select {
  case msg := <-wsConn.inChan:
    // 获取到消息队列中的消息
    return msg, nil
  case <-wsConn.closeChan:

  }
  return nil, errors.New("连接已经关闭")
}

// 关闭连接
func (wsConn *wsConnection) close() {
  log.Println("关闭连接被调用了")
  wsConn.wsSocket.Close()
  wsConn.mutex.Lock()
  defer wsConn.mutex.Unlock()
  if wsConn.isClosed == false {
    wsConn.isClosed = true
    // 删除这个连接的变量
    delete(wsConnAll, wsConn.id)
    close(wsConn.closeChan)
  }
}

// 启动程序
func StartWebsocket(addrPort string) {
  wsConnAll = make(map[int64]*wsConnection)
  http.HandleFunc("/ws", wsHandler)
  http.ListenAndServe(addrPort, nil)
}

上述内容就是使用golang在实现一个websocket 服务端,你们学到知识或技能了吗?如果还想学到更多技能或者丰富自己的知识储备,欢迎关注创新互联成都网站设计公司行业资讯频道。

另外有需要云服务器可以了解下创新互联scvps.cn,海内外云服务器15元起步,三天无理由+7*72小时售后在线,公司持有idc许可证,提供“云服务器、裸金属服务器、高防服务器、香港服务器、美国服务器、虚拟主机、免备案服务器”等云主机租用服务以及企业上云的综合解决方案,具有“安全稳定、简单易用、服务可用性高、性价比高”等特点与优势,专为企业上云打造定制,能够满足用户丰富、多元化的应用场景需求。


分享文章:使用golang在实现一个websocket服务端-创新互联
网页网址:http://dzwzjz.com/article/dhcooo.html
在线咨询
服务热线
服务热线:028-86922220
TOP