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)
}

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持我们。

(0)

相关推荐

  • golang基于websocket实现的简易聊天室程序

    本文实例讲述了golang基于websocket实现的简易聊天室.分享给大家供大家参考,具体如下: 先说点无关的,最近忙于工作没有更新博客,今天休息顺便把golang websocket研究了一下,挺好玩的,写了一个聊天室,分享给大家. websocket包 : code.google.com/p/go.net/websocket 文档 : http://go.pkgdoc.org/code.google.com/p/go.net/websocket 首先安装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 nex

  • Python Websocket服务端通信的使用示例

    1.唠唠叨叨 最近又回顾了下Websocket,发现已经忘的七七八八了.于是用js写了客户端,用python写了服务端,来复习一下这方面的知识. WebSocket 是一种标准协议,用于在客户端和服务端之间进行双向数据传输.但它跟 HTTP 没什么关系,它是基于 TCP 的一种独立实现. 以前客户端想知道服务端的处理进度,要不停地使用 Ajax 进行轮询,让浏览器隔个几秒就向服务器发一次请求,这对服务器压力较大.另外一种轮询就是采用 long poll 的方式,这就跟打电话差不多,没收到消息就一

  • C# 实现WebSocket服务端教程

    .net4.5中实现了对websocket的支持 在这里我使用的是.net4.0.因此需要对原本的socket发送的数据根据websocket的协议进行解析和打包. using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Net.Sockets; using System.Threading; using System.Net; namespace We

  • java WebSocket 服务端实现代码

    1.什么是WebSocket WebSocket协议是基于TCP的一种新的网络协议.它实现了浏览器与服务器全双工(full-duplex)通信——允许服务器主动发送信息给客户端. 2.实现原理 在实现websocket连线过程中,需要通过浏览器发出websocket连线请求,然后服务器发出回应,这个过程通常称为“握手” .在 WebSocket API,浏览器和服务器只需要做一个握手的动作,然后,浏览器和服务器之间就形成了一条快速通道.两者之间就直接可以数据互相传送. 3.优点 在以前的消息推送

  • .NET实现WebSocket服务端即时通信实例

    即时通信常用手段 1.第三方平台 谷歌.腾讯 环信等多如牛毛,其中谷歌即时通信是免费的,但免费就是免费的并不好用.其他的一些第三方一般收费的,使用要则限流(1s/限制x条消息)要么则限制用户数. 但稳定性什么都还不错,又能将服务压力甩出 2.System.Net.Sockets.Socket,也能写一套较好的服务器端.在.NET 4.5之前用较多,使用起来麻烦.需要对数据包进行解析等操作(但貌似网上有对超长包的处理方法) 3.System.Net.WebSockets.WebSocket,这个,

  • python实现WebSocket服务端过程解析

    一种类似Flask开发的WebSocket-Server服务端框架,适用python3.X 1.安装模块Pywss pip install pywss 2.搭建简易服务器 2.1 服务端代码 代码简介 route: 注册请求路径 example_1(request, data): request: socket句柄,能够发送和接收数据接.发送数据request.ws.send(data),收数据request.ws_recv(1024) data: 客户端发送的数据存于此处 from pywss

  • C++编写的WebSocket服务端客户端实现示例代码

    目录 使用过标准的libwebsockets服务端库测试过,主要是短小精悍,相对于libwebsockets不需要依赖zlib和openssl 以及其他库,直接make就可以使用了,linux跟windows都可以使用. 测试用例: #include "easywsclient.hpp" #include <assert.h> #include <stdio.h> #include <string> using easywsclient::WebSo

  • node.js ws模块搭建websocket服务端的方法示例

    首先下载websocket模块,命令行输入 npm install ws node.js的 模块ws,可用于创建websocket服务,基本的express 和 http模块的使用 var express = require('express'); var http = require('http'); var WebSocket = require('ws'); var app = express(); var server = http.createServer(app); var wss

  • 利用Go语言搭建WebSocket服务端方法示例

    Go 搭建一个简单 WebSocket 服务端代码例子 test.go, 如下: package main import ( "fmt" "log" "net/http" "golang.org/x/net/websocket" ) func Echo(ws *websocket.Conn) { var err error for { var reply string if err = websocket.Message.Re

  • 使用Go语言创建WebSocket服务的实现示例

    今天介绍如何用 Go 语言创建 WebSocket 服务,文章的前两部分简要介绍了 WebSocket 协议以及用 Go 标准库如何创建 WebSocket 服务.第三部分实践环节我们使用了 gorilla/websocket 库帮助我们快速构建 WebSocket 服务,它帮封装了使用 Go 标准库实现 WebSocket 服务相关的基础逻辑,让我们能从繁琐的底层代码中解脱出来,根据业务需求快速构建 WebSocket 服务. Go Web 编程系列的每篇文章的源代码都打了对应版本的软件包,供

随机推荐