golang開發 gorilla websocket的使用

很多APP都需要主動向用戶推送消息，這就需要用到長連接的服務，即我們通常提到的websocket，同樣也是使用socket服務，通信協議是基本類似的，在go中用的最多的、也是最簡單的socket服務就是gorilla/websocket，它有21.1K的star，足以說明它的受歡迎程度， 它的github地址是 https://github.com/gorilla/websocket，我們的長連接服務也是通過gorilla/websocket改造出來的。

websocket的簡單使用

我們使用的版本是1.3.0，首先下載websocket
go get github.com/gorilla/[email protected]

把websocket/examples/echo下麵的 client.go server.go 現在下來拷貝到項目裡面。
https://github.com/gorilla/websocket/blob/v1.3.0/examples/echo/server.go
https://github.com/gorilla/websocket/blob/v1.3.0/examples/echo/client.go

在一個終端執行 websocket 服務
go run server.go

recv: 2024-04-16 15:09:45.805438 +0800 CST m=+1.007536889
recv: 2024-04-16 15:09:46.805425 +0800 CST m=+2.007517605
recv: 2024-04-16 15:09:47.806274 +0800 CST m=+3.008359325
recv: 2024-04-16 15:09:48.80495 +0800 CST m=+4.007028866
recv: 2024-04-16 15:09:49.805743 +0800 CST m=+5.007816108
recv: 2024-04-16 15:09:50.806087 +0800 CST m=+6.008153310
recv: 2024-04-16 15:09:51.805348 +0800 CST m=+7.007407266

再打開一個終端執行 go run client.go，充當客戶端

connecting to ws://localhost:8080/echo
recv: 2024-04-16 15:09:45.805438 +0800 CST m=+1.007536889
recv: 2024-04-16 15:09:46.805425 +0800 CST m=+2.007517605
recv: 2024-04-16 15:09:47.806274 +0800 CST m=+3.008359325
recv: 2024-04-16 15:09:48.80495 +0800 CST m=+4.007028866
recv: 2024-04-16 15:09:49.805743 +0800 CST m=+5.007816108
recv: 2024-04-16 15:09:50.806087 +0800 CST m=+6.008153310
recv: 2024-04-16 15:09:51.805348 +0800 CST m=+7.007407266

我們看看這個簡單的例子。
client.go

go func() {
		defer close(done)
		for {
			_, message, err := c.ReadMessage()
			if err != nil {
				log.Println("read:", err)
				return
			}
			log.Printf("recv: %s", message)
		}
	}()

	ticker := time.NewTicker(time.Second)
	defer ticker.Stop()

	for {
		select {
		case <-done:
			return
		case t := <-ticker.C:
			err := c.WriteMessage(websocket.TextMessage, []byte(t.String()))
			if err != nil {
				log.Println("write:", err)
				return
			}
		case <-interrupt:
			log.Println("interrupt")

			// Cleanly close the connection by sending a close message and then
			// waiting (with timeout) for the server to close the connection.
			err := c.WriteMessage(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseNormalClosure, ""))
			if err != nil {
				log.Println("write close:", err)
				return
			}
			select {
			case <-done:
			case <-time.After(time.Second):
			}
			return
		}
	}

go func() 的 c.ReadMessage 不停的從socket裡面讀取數據並且列印。
for 迴圈不停的從1秒的定時器裡面讀取時間，寫到socket

server.go

	for {
		mt, message, err := c.ReadMessage()
		if err != nil {
			log.Println("read:", err)
			break
		}
		log.Printf("recv: %s", message)
		err = c.WriteMessage(mt, message)
		if err != nil {
			log.Println("write:", err)
			break
		}
	}

for c.ReadMessage 迴圈不停的從 socket讀取數據，把數據列印之後，又寫給客戶端。
這是大致的websocket 客戶端與服務端通信的簡單例子。

改成自定義的協議

我們使用二進位數據流，自定義的協議是這樣的，
先是無符號的 uint 占4個位元組，表示行為邏輯，比如111-獲取信息， 110- 加好友等等
後面是具體的數據，跟HTTP請求的GET或者POST參數類似,具體數據格式定義好就行，比如可以使用JSON數據、可以使用RPC定義好的數據格式

修改完之後 client.go 代碼是這樣的

	for {
		select {
		case <-done:
			return
		case <-ticker.C:
			buf := bytes.NewBuffer([]byte{})
			binary.Write(buf, binary.BigEndian, uint32(110))
			binary.Write(buf, binary.BigEndian, []byte("我們都好"))
			err := c.WriteMessage(websocket.BinaryMessage, buf.Bytes())
			if err != nil {
				log.Println("write:", err)
				return
			}
		case <-interrupt:
			log.Println("interrupt")

			// Cleanly close the connection by sending a close message and then
			// waiting (with timeout) for the server to close the connection.
			err := c.WriteMessage(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseNormalClosure, ""))
			if err != nil {
				log.Println("write close:", err)
				return
			}
			select {
			case <-done:
			case <-time.After(time.Second):
			}
			return
		}
	}

主要是這個

buf := bytes.NewBuffer([]byte{})
binary.Write(buf, binary.BigEndian, uint32(110))
binary.Write(buf, binary.BigEndian, []byte("我們都好"))

創建一個bytes Buffer
寫入一個uint32，占4個位元組，表示行為邏輯
寫入行為邏輯具體的數據
以上採用大端通信

修改之後的 server.go

	for {
		mt, message, err := c.ReadMessage()
		if err != nil {
			log.Println("read:", err)
			break
		}
		log.Println("messagetype:%d", mt)

		log.Println("messagelen:%d", len(message))

		log.Println("messagetype:%d", binary.BigEndian.Uint32(message[0:4]))
		
		log.Println("recv: %s", string(message[4:]))
		err = c.WriteMessage(mt, message)
		if err != nil {
			log.Println("write:", err)
			break
		}
	}

mt websocket 類型
TextMessage = 1 文本類型傳傳輸
BinaryMessage = 2 位元組類型傳輸

從socket裡面獲取到message之後
先取前4個位元組，表示邏輯行為
再取剩餘的位元組，表示行為邏輯需要的參數

我們重新執行一下，server.go 和 client.go

go run client.go
connecting to ws://localhost:8080/echo
recv: n我們都好
recv: n我們都好


go run server.go
messagetype:%d 2
messagelen:%d 16
messagetype:%d 110
recv: %s 我們都好

messagetype=2表示二進位通信
message長度是16，前四個位元組是無符號整形，四個漢字占12個位元組，一共16個位元組，無符號uint是110表示加好友。

這就是一個簡單自定義協議的socket服務。

如果有需要登錄鑒權的話，在server.go中可以從r *http.Request 獲取header或者cookie，進行登錄鑒權驗證。

生產的部署

因為是 websocket 協議，如果有代理伺服器的話，需要在各代理伺服器上的Nginx做協議升級，將HTTP 升級為 websocket ，比如下麵的代理伺服器。

map $http_upgrade $connection_upgrade {
default upgrade;
''      close;
}


server {
    listen 80;
    location /serv/ {

        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection $connection_upgrade;

        proxy_connect_timeout 3;
        proxy_redirect     off;
        proxy_read_timeout 3600;
        proxy_send_timeout 3600;

        proxy_pass http://push_web/serv/;
    }
}