go-websocket服务端/客户端

目录

• websocket
• 服务端
• 客户端

websocket

websocket.Upgrader升级为websocket协议

服务端

package main

import (
	"fmt"
	"net/http"
	"unsafe"

	"github.com/gin-gonic/gin"
	"github.com/gorilla/websocket"
)
//设置websocket
//CheckOrigin防止跨站点的请求伪造
var upGrader = websocket.Upgrader{
	CheckOrigin: func(r *http.Request) bool {
		return true
	},
}

//websocket实现
func ping(c *gin.Context) {
	//升级get请求为webSocket协议
	ws, err := upGrader.Upgrade(c.Writer, c.Request, nil)
	if err != nil {
		return
	}
	defer ws.Close() //返回前关闭
	for {
		//读取客户端发送来到消息
		mt, message, err := ws.ReadMessage()
		if err != nil {
			break
		}
		fmt.Println("服务端收到消息:",string(message))
		fmt.Println("mt类型:",mt)
		//写入ws数据
		T:=string(message) +"收到"
		msg:=*(*[]byte)(unsafe.Pointer(&T))

		//服务端发送消息到客户端websocket
		err = ws.WriteMessage(mt, msg)
		if err != nil {
			break
		}
		fmt.Println("发送消息：",T)
	}
}

func main() {
	r := gin.Default()
	r.GET("/ping", ping)
	r.Run(":8080")
}

客户端

package main

import (
	"fmt"
	"log"
	"net/url"
	"strconv"
	"sync"
	"time"

	"github.com/gorilla/websocket"
)

type websocketClientManager struct {
	conn        *websocket.Conn
	addr        *string
	path        string
	sendMsgChan chan string
	recvMsgChan chan string
	isAlive     bool
	timeout     int
}

// 构造函数
func NewWsClientManager(addrIp, addrPort, path string, timeout int) *websocketClientManager {
	addrString := addrIp + ":" + addrPort
	var sendChan = make(chan string, 10) //定义channel大小，需要及时处理消费，否则会阻塞
	var recvChan = make(chan string, 10) //定义channel大小，需要及时处理消费，否则会阻塞
	var conn *websocket.Conn
	return &websocketClientManager{
		addr:        &addrString,
		path:        path,
		conn:        conn,
		sendMsgChan: sendChan,
		recvMsgChan: recvChan,
		isAlive:     false,
		timeout:     timeout,
	}
}

// 链接服务端
func (wsc *websocketClientManager) dail() {
	var err error
	u := url.URL{Scheme: "ws", Host: *wsc.addr, Path: wsc.path}
	fmt.Println("connecting to:", u.String())
	wsc.conn, _, err = websocket.DefaultDialer.Dial(u.String(), nil)
	if err != nil {
		fmt.Println(err)
		return
	}
	wsc.isAlive = true
	log.Printf("connecting to %s 链接成功！！！", u.String())

}

// 发送消息到服务端
func (wsc *websocketClientManager) sendMsgThread() {
	go func() {
		for {
			msg := <-wsc.sendMsgChan
			fmt.Println("发送消息:",msg)
			// websocket.TextMessage类型
			err := wsc.conn.WriteMessage(websocket.TextMessage, []byte(msg))
			if err != nil {
				fmt.Println("write:", err)
				continue
			}
		}
	}()
}

// 读取服务端消息
func (wsc *websocketClientManager) readMsgThread() {
	go func() {
		for {
			if wsc.conn != nil {
				_, message, err := wsc.conn.ReadMessage()
				if err != nil {
					log.Println("readErr:", err)
					wsc.isAlive = false
					// 出现错误，退出读取，尝试重连
					break
				}
				// 需要读取数据，不然会阻塞
				wsc.recvMsgChan <- string(message)

			}
		}
	}()
}

// 开启服务并重连
func (wsc *websocketClientManager) start() {
	for {
		if wsc.isAlive == false {
			wsc.dail()
			wsc.sendMsgThread()
			wsc.readMsgThread()
			wsc.Msg() //构造假消息
			wsc.Recv() //接收处理服务端返回到消息
		}
		time.Sleep(time.Second * time.Duration(wsc.timeout))
	}
}

//模拟websocket心跳包，假数据
func (wsc *websocketClientManager)Msg()  {
	go func() {
		a:=0
		for {
			wsc.sendMsgChan <- strconv.Itoa(a)
			time.Sleep(time.Second*1)
			a+=1
		}
	}()
}

//接收处理服务端返回到消息
func (wsc *websocketClientManager) Recv()  {
	go func() {
		for  {
			msg, ok := <-wsc.recvMsgChan
			if ok {
				fmt.Println("收到消息：",msg)
			}
		}
	}()
}

func main() {
	wsc := NewWsClientManager("127.0.0.1", "8080", "/ping", 10)
	wsc.start()

	var w1 sync.WaitGroup
	w1.Add(1)
	w1.Wait()
}