WebSocket的原理和golang实现WebSocket服务器

最近一直在做网关的项目，收获了不少关于网络协议的相关知识点，我打算把这些知识点都串起来完成一个大的项目，其中WebSocket就是其中的一个知识点

WebSocket知识点

Websocket 是服务器推送技术的一种，最大的特点是服务器可以主动向客户端推送消息，客户端也可以主动向服务器发送消息。
WebSocket 是 HTML5 开始提供的一种在单个 TCP 连接上进行全双工通讯的协议。

WebSocket 使得客户端和服务器之间的数据交换变得更加简单，允许服务端主动向客户端推送数据。在 WebSocket API 中，浏览器和服务器只需要完成一次握手，两者之间就直接可以创建持久性的连接，并进行双向数据传输。

HTTP握手

首先客户端向服务器发起HTTP请求，这一次的HTTP请求是客户端和服务端进行的协议升级，具体步骤如下：

客户端发起请求：

客户端会向服务端发送协议升级请求，客户端发送的HTTP报文示例如下：

其中比较重要的头部是：

• Host请求头，其值为要请求的主机名。

• Upgrade请求头，且其值必须为websocket，表示这个HTTP请求的目的是要申请升级到websocket协议，而不是其他协议。

• Connection请求头，其值必须为Upgrade，表示这个HTTP请求是一个协议升级请求。

• Sec-WebSocket-Key请求头，且其值为以BASE-64编码的随机字符串。服务器端会用这些数据来构造出一个SHA-1的信息摘要。把“Sec-WebSocket-Key”的值加上一个特殊字符串“258EAFA5-E914-47DA-95CA-C5AB0DC85B11”，然后计算SHA-1摘要，之后进行BASE-64编码，将结果做为“Sec-WebSocket-Accept”响应头的值，返回给客户端。如此操作，可以尽量避免普通HTTP报文被误认为WebSocket协议握手报文。

• Sec-WebSocket-Version请求头，且其值必须为13，表示使用的WebSocket版本为13。

服务器接收请求：

服务端响应客户端的协议升级请求
当服务端接收到客户端的协议升级请求时，如果服务端接受该协议升级请求，将会返回如下响应报文：

HTTP/1.1 101 Switching Protocols
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Accept: fFBooB7FAkLlXgRSz0BT3v4hq5s=

其中返回的101状态码的意思是同意将当前的HTTP协议切换到WebSocket协议。

来自developer.mozilla.org:
HTTP 101 Switching Protocol（协议切换）状态码表示服务器应客户端升级协议的请求（Upgrade请求头）正在进行协议切换。

相比传统的AJAX轮询，Websockets能够大量地节省服务器的带宽，因为它只需要建立一次连接，从而不同传输大量相同的头部信息。

golang实现websocket服务器

下面我们使用golang实现websocket的服务器

package main

import (
	"flag"
	"html/template"
	"log"
	"net/http"
	"github.com/gorilla/websocket"
)

var addr = flag.String("addr", "localhost:2003", "http service address")

var upgrader = websocket.Upgrader{} // use default options

func echo(w http.ResponseWriter, r *http.Request) {
	c, err := upgrader.Upgrade(w, r, nil)
	if err != nil {
		log.Print("upgrade:", err)
		return
	}
	defer c.Close()
	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
		}
	}
}

func home(w http.ResponseWriter, r *http.Request) {
	homeTemplate.Execute(w, "ws://"+r.Host+"/echo")
}

func main() {
	flag.Parse()
	log.SetFlags(0)
	http.HandleFunc("/echo", echo)
	http.HandleFunc("/", home)
	log.Println("Starting websocket server at " + *addr)
	log.Fatal(http.ListenAndServe(*addr, nil))
}

在以上的代码中我使用了github中的websocket类库，其中最核心的函数就是:upgrader.Upgrade(w, r, nil)，它会返回一个connection，我们得到connnection之后就可以调用它的ReadMessage()和WriteMessage(mt, message)方法进行数据传输了

下面我们深入解析一下Upgrade这个函数

首先它会验证客户端传输过来的HTTP头部信息，如果头部信息不正确，就会返回对应的错误信息

if !tokenListContainsValue(r.Header, "Connection", "upgrade") {
		return u.returnError(w, r, http.StatusBadRequest, badHandshake+"'upgrade' token not found in 'Connection' header")
	}

	if !tokenListContainsValue(r.Header, "Upgrade", "websocket") {
		return u.returnError(w, r, http.StatusBadRequest, badHandshake+"'websocket' token not found in 'Upgrade' header")
	}

	if r.Method != "GET" {
		return u.returnError(w, r, http.StatusMethodNotAllowed, badHandshake+"request method is not GET")
	}

	if !tokenListContainsValue(r.Header, "Sec-Websocket-Version", "13") {
		return u.returnError(w, r, http.StatusBadRequest, "websocket: unsupported version: 13 not found in 'Sec-Websocket-Version' header")
	}

	if _, ok := responseHeader["Sec-Websocket-Extensions"]; ok {
		return u.returnError(w, r, http.StatusInternalServerError, "websocket: application specific 'Sec-WebSocket-Extensions' headers are unsupported")
	}

然后使用bufio创建writer和reader，并利用writer和reader创建connection

var br *bufio.Reader
	if u.ReadBufferSize == 0 && bufioReaderSize(netConn, brw.Reader) > 256 {
		// Reuse hijacked buffered reader as connection reader.
		br = brw.Reader
	}

	buf := bufioWriterBuffer(netConn, brw.Writer)

	var writeBuf []byte
	if u.WriteBufferPool == nil && u.WriteBufferSize == 0 && len(buf) >= maxFrameHeaderSize+256 {
		// Reuse hijacked write buffer as connection buffer.
		writeBuf = buf
	}

	c := newConn(netConn, true, u.ReadBufferSize, u.WriteBufferSize, u.WriteBufferPool, br, writeBuf)

然后会设置返回的头部信息，比如101状态码、Upgrade、Connection并且会利用computeAcceptKey()这个函数计算Sec-WebSocket-Accept

p = append(p, "HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: "...)
	p = append(p, computeAcceptKey(challengeKey)...)
	p = append(p, "\r\n"...)
	if c.subprotocol != "" {
		p = append(p, "Sec-WebSocket-Protocol: "...)
		p = append(p, c.subprotocol...)
		p = append(p, "\r\n"...)
	}
	if compress {
		p = append(p, "Sec-WebSocket-Extensions: permessage-deflate; server_no_context_takeover; client_no_context_takeover\r\n"...)
	}
	for k, vs := range responseHeader {
		if k == "Sec-Websocket-Protocol" {
			continue
		}
		for _, v := range vs {
			p = append(p, k...)
			p = append(p, ": "...)
			for i := 0; i < len(v); i++ {
				b := v[i]
				if b <= 31 {
					// prevent response splitting.
					b = ' '
				}
				p = append(p, b)
			}
			p = append(p, "\r\n"...)
		}
	}
	p = append(p, "\r\n"...)

下面我们开启WebSocket服务器,然后在浏览器输入对应的ip和端口，点击open按钮发起请求:

可以看到浏览器发送了一个带有Upgrade、Host、Sec-Websocket-Key等头部信息的HTTP请求，并接收到了带有Upgrade、Connection、
Sec-WebSocket-Accept等头部的response信息

再往后我们每次利用浏览器向服务器发送数据都能接收到服务器返回的信息，但是都没有产生对应的HTTP请求，可见我们已经成功实现了WebSocket传输的建立