首页 > golang > gorilla/websocket包方法汇总
2022
01-10

gorilla/websocket包方法汇总

获取 Conn 实例的方法

func (u *Upgrader) Upgrade(w http.ResponseWriter,r *http.Request,responseHeader http.Header)(*Conn , error)

    方法 必须通过 Upgrader结构体的实例调用

    方法必须传递 w http.ResponseWriter 和  r *http.Reqeust 参数,但是 responseHeader http.Header 参数可以是nil

    方法返回结构体 Conn 的实例的指针 和 error

package main

import (
   "github.com/gorilla/websocket"
   "net/http"
)

// 使用默认配置
upgrader :=  websocket.Upgrader{}

// 处理请求的 处理器函数
func HandlerWebsocket (w http.ResponseWriter,r *http.Request){
   conn,err := upgrader.Upgrade(w,r,nil)

   if err != nil{
      // 处理错误
   }

   // 使用 Conn
}


关闭 websocket 连接的方法

func(c *Conn) Close() error

    关闭 基础的网络连接 ,但是不会发送 或 等待 一个 关闭消息(close message)

package main

import (
   "github.com/gorilla/websocket"
   "net/http"
)

var conn *websocket.Conn
var err *errors

// 使用默认设置的 Upgrader
var upgrader  =  websocket.Upgrader{}


// 定义网络请求的处理器函数
func HandlerWebsocket (w http.ResponseWriter, r *http.Reqeust){

   // 不设置响应头的 websocket 连接
   conn ,err = upgrader.Upgrade(w,r,nil)
   `   
    if err != nil{
        // 处理 err
        return
    }

    // 关闭基础网络连接
    err = conn.Close()
    
    if err != nil{
        // 处理 err
        return
    }    
}


设置关闭处理器

func (c *Conn) SetCloseHandler(h func(closeCode int,text string) error)

    当前接受到对映端发送的close message 的时候触发当前定义的函数

    函数接受 关闭代码 和 文本字符串作为参数

package main
import (
   "github.com/gorilla/websocket"
   "net/http"
)
import "errors"


// 使用默认的 Upgrader 参数
var upgrader  = websocket.Upgrader{}
var conn *websocket.Conn
var err error
var isClose = false


// 请求处理器
func HandlerWebsocket (w http.ResponseWriter,r *http.Request){
   // 不设置响应头
   conn,err = upgrader.Upgrade(w,r,nil)
   if err !=nil{
      // 处理错误
      return
   }

   // 设置关闭处理器
   conn.SetCloseHandler(func (closeCode int,text string) error {
      isClose = true
      conn.Close()
   })

   // loop
   for{
      // 判断是否停止循环
      if isClose{
         break
      }
   }
}

备注

    只有当前接受到close message 消息的时候才会触发 设置的函数调用

    一般而言里面至少要设置 关闭当前连接

    停止 循环操作


读物一般性文本消息

func(c *Conn) ReadMessage()(messageType int,p []byte,err error)

    读取消息

    返回消息的类型 messageType

    返回消息文本 p []byte

    返回 error 对象

package main

import "github.com/gorilla/websocket"
import errors

// 使用默认参数实例化 Upgrader结构体
var upgrader = websocket.Upgrader{}
var conn *websocket.Conn
var err error
func HanderWebsocket(w http.ResponseWriter,r *http.Request){

   // 不设置相应头
   conn,err = upgrader.Upgrade(w,r,nil)
   if err!=nil{
      // 处理错误
      return
   }

   // 设置 关闭处理器
   conn.SetCloseHandler(func(closeCode int,text string) error{
      //当接受到 关闭消息的时候调用
      isClose = true
      conn.Close() // 关闭连接
   })

   // loop
   for{
      if isClose{
         break
      }
      // 获取一般性的文本消息
      var mt int
      var message []byte
      mt,message,err = conn.ReadMessage()
      if err!=nil{
         // 处理错误其他代码...
         conn.Close() // 关闭连接
         break
      }
      //处理消息文本,消息类型数据代码……

   }

}

向连接写入消息

func (c *Conn) WriteMessage(messageType int , data []byte) error

    向对映端发送消息

    WriteMessage 是一个帮助方法,得到一个写入器,写入消息同时关闭写入器

    messageType 写入的消息类型

    data []byte 需要写入的数据

package main
import (
   "errors"
   "github.com/gorilla/websocket"
   "net/http"
)

var err error
// 使用默认配置
var upgrader = websocket.Upgrader{}
var conn *websocket.Conn
var isClose = false
var mt int
var message []byte
func closeHandler(closeCode int ,text string) error {
   isClose = true
   conn.Close() // 关闭连接
}

// 设置应答处理器
func HandlerWebsocket(w http.ResponseWriter,r *http.Request){
   // 不设置应答的头
   // 获取连接的实例
   conn,err := upgrader.Upgrade(w,r,nill)
   if err!= nil{
      // 处理错误
      return
   }
   // 设置关闭处理器
   conn.SetCloseHandler(closeHandler)
   //loop
   for{
      // 获取消息
      mt,message,err  = conn.ReadMessage()
      if err != nil{
         // 标准处理的错误代码
         conn.Close() // 关闭连接
         break // 停止循环
         // 自定义错误代码……
      }

      // 写入消息
      err = conn.WriteMessage(1,message)
      if err != nil{
         // 自定义错误处理的代码……
      }
   }
}


读取 json类型的消息

func(c *Conn) ReadJSON (v interface{}) error

    读取JSON编码的消息

    把读取出来的值保存到 v 变量里面

    v 参数必须传递一个 接口的引用

    v 参数保存后是一个map

    JSON 的处理查看 encodeing/json 包的文档内容

package main
import(
   "github.com/gorilla/websocket"
   "errors"
   "net/http"
)
var upgrader = websocket.Upgrader{}
var conn *websocket.Conn
var err error
var isClose = false
var mt int
var message []byte
var v interface{}

// 定义关闭处理器函数
func CloseHandler(closeCode int, text string) error{
   isClose = true
   conn.Close()// 关闭连接
}

// 请求处理器
func HandlerWebsocket(w http.ResponseWriter,r *http.Reqeust){
   conn,err = upgrader.Upgrade(w,r,nil) //不设置响应的头,创建 websocket 连接的实例
   if err!=nil{
      // 处理错误的代码……
      return
   }
   // 设置关闭处理器
   conn.SetCloseHandler(CloseHandler)

   // loop
   for{
      if isClose{ break } // 如果关闭状态 停止循环
      err = conn.ReadJSON(&v)
      if err != nil{
         // 一般性错误处理
         conn.Close() //关闭连接
         break // 停止循环
         // 自定义 错误处理……
      }
      // 从 v中获取值
      if _map,ok := v.(map[string]interface{}) ;ok{
         // _map 即使传递过来的json对象的值
      }
   }
}

向连接写入JSON类型的消息

func (c *Conn) WriteJSON(v interface{}) error

    向连接写入 JSON 类型的消息,

    接受的参数是 interface{} 任意数据

    一般写入的是 map 切片等

package main

import (
   "errors"
   "net/http"
   "github.con/gorilla/websocket"
)

// 升级对象
var upgrader = websocket.Upgrader()
var conn *websocket.Conn
var err error
var isClose = false
var v interface{}
// 关闭处理器调用的函数
func closeHandler( closeCode int, closeText string) error{
   conn.Close()
   isClose = true
}

func HandlerWebsocket( w http.ResponseWriter, r *http.Request){
   conn,err = upgrader.Upgrade(w,r,nil) // 不设置 应答的头
   if err != {
      // 自定义错误需要执行的代码
      // 通用代码
      return
   }

   // 设置关闭处理器
   // 当接受到关闭消息的时候触发
   conn.SetCloseHandler(closeHandler)

   // loop
   for{
      //判断是否关闭
      if isClose{
         break
      }
      // 读取数据
      err = conn.ReadJSON(&v)
      if err != nil {
         conn.Close()
         break // 出错停止循环
      }
      // 写入数据
      err = conn.WriteJSON(v)

      if err != nil{
         // 写入失败
         // 自定义错误操作
      }

   }
}

检查发起请求的来源是否合法

websocket.Upgrader{}.CheckOrigin = h func(r *http.Request) bool

    设置 upgreader 实例的参数

    CheckOrigin 字段是一个函数,接受 r *http.Request 作为参数

    函数放回 bool 如果返回 true 合法的来源,如果返回false 不是合法的来源

package main
import(
   "errors"
   "net/http"
   "github.com/gorilla/websocket"
)

var upgrader = websocket.Upgrader{}

func checkOrigin (r *http.Request) bool{
   // 自定义判断条件
   // r.Header["Origin"] 返回原始的请求的主机和端口 ,也就是浏览器地址栏上的主机和接口

   return true
}

// 初始化执行的函数
func init(){
   upgrader.CheckOrigin = checkOrigin
}

// 请求处理器
func HandlerWebsocket( w http.ResponseWriter, r *http.Reqeust){
   // 处理器内部操作的代码……
}

获取服务器的主机和端口

func (c *Conn) LocalAddr() *net.TCPAddr

    返回服务器所在的 net.TCPAddr 的指针

    net.TCTAddr 结构体的数据结构

type TCPAddr struct{
    IP IP // 127.0.0.1
    Port int // 8888
    Zone string // IPv6 范围寻址域
}

获取请求端的主机和端口

func(c *Conn) RemoteAddr() *net.TCPAddr

    获取请求端的主机和端口

    返回net.TCPAddr 对象的指针

    net.TCPAddr 对象的结构说明

type TCPAddr struct{
    IP IP // 127.0.0.1
    Port int // 8888
    Zone string // IPv6 范围寻址域
}


本文》有 0 条评论

留下一个回复