Golang网络编程

今天看了看Golang的网络编程，总结了一些关于TCP/HTTP的知识，于是记录下来，方便日后回忆。有一说一记忆力差真的是硬伤！👴累趴了都。

如果你有看我的历史文章，你就知道我是个Javaer，我也是最近才转的Golang，虽然之前学过一丢丢。因为现公司用Golang，不捧不踩，Golang写起来真舒服！人生苦短，Let's Go!

TCP

Golang的tcp编程和大多数语言很像，无非是ServerSocket(TcpListener)监听端口，然后连接建立返回一个Socket(Connection)。但是有一点不同，就是Golang支持Goroutine，如果你还记得Java/C编写Socket就知道，对于每个连接是需要开辟线程处理的，然后因为连接多导致开线程开爆了，然后上NIO，然后就是非阻塞编程+异步回调... ...其实这分别对应于Java的Netty和Rust的async关键字。我都搞过，所以第一次用Goroutine觉得，嚯！真简单。

当然如果在这里讨论Goroutine的性能或者Golang的调度器就有点不合适了，你既然接受了这种用户级线程的设计，而且还是语言内置的，那就要接受它给你画出的条条框框。但是基本不会有人触碰到边界，所以这里我们不讨论这种底层，一是没必要，你上Golang就是为了省头发，而不是再去亲自管理调度；二是，我还没学到哈哈哈哈！

让我们开始吧！

首先建立监听：

func Serve() {
	address := "127.0.0.1:8190"
	tcpAddr, err := net.ResolveTCPAddr("tcp4", address)
	if err != nil {
		log.Fatal(err)
	}
	// listener对应ServerSocket
	serverSocket, err := net.ListenTCP("tcp4", tcpAddr)
	if err != nil {
		log.Fatal(err)
	}
	for {
		// 每次连接建立返回一个Connection，Connection对应Socket
		socket, err := serverSocket.AcceptTCP()
		fmt.Println("connection established...")
		if err != nil {
			log.Fatal(err)
		}
		// 开辟Goroutine去处理新的连接
		go server(socket)
	}
}

这一步和任何语言都大同小异，重点看最后，go关键字开启Goroutine去处理新的连接，我们在这个方法里进行读写操作，并响应来自客户端的关闭操作。

基础版

现在来看看服务端怎么处理读写请求的：

// 最普通的版本
func server(socket *net.TCPConn) {
	defer func(tcpConn *net.TCPConn) {
		err := tcpConn.Close()
		if err != nil {
			log.Fatal(err)
		}
	}(socket)
	for {
		request := make([]byte, 1024)
		readLen, err := socket.Read(request)
		if err == io.EOF {
			fmt.Println("连接关闭")
			return
		}
		msg := string(request[:readLen])
		fmt.Println(msg)
		msg = "echo: " + msg
		_, _ = socket.Write([]byte(msg))
	}
}

其实很好理解，定一个byte类型的slice去接收数据，然后处理，再写出。

这里再给出客户端的写法：

func client() {
	tcpAddr, _ := net.ResolveTCPAddr("tcp", "127.0.0.1:8190")
	socket, _ := net.DialTCP("tcp", nil, tcpAddr)
	defer func(socket *net.TCPConn) {
		_ = socket.Close()
	}(socket)
	var input string
	fmt.Println("input for 5 loops")
	for i := 0; i < 5; i++ {
		_, _ = fmt.Scanf("%s", &input)
		_, _ = socket.Write([]byte(input))
		response := make([]byte, 1024)
		readLen, _ := socket.Read(response)
		fmt.Println(string(response[:readLen]))
	}
}

但这里有不少问题，比如，如果我一次发送很多，那我这次定义的slice大小肯定不够，那我怎么办？肯定不能盲目开大，对吧！

而且TCP还有粘包和拆包这一说，我怎么保证我的数据没有被拆包，以及粘包了之后怎么处理？其实TCP协议一般处理方式都是基于分隔符(delimiter)或者基于长度(length)，比方说一个发送文件的HTTP请求，实现就是首部指出整体长度，然后指出分隔字符串，又称边界符，然后根据边界符分隔出不同的文件即可。

现在我们来看这两种方式。

分隔符

基于分隔符：

// 基于分隔符的版本
func serverClientDelimiterBased(socket *net.TCPConn) {
	defer func(socket *net.TCPConn) {
		err := socket.Close()
		if err != nil {
			log.Fatal(err)
		}
	}(socket)
	// 构建一个Reader，此时会源源不断的读取，直到Socket为空
	reader := bufio.NewReader(socket)
	for {
		// 相当于对源源不断的数据流进行分割，直到不可读取
		data, err := reader.ReadSlice('\n')
		if err != nil {
			if err == io.EOF {
				// 连接关闭
				break
			} else {
				fmt.Println("出现异常" + err.Error())
			}
		}
		// 剔除分隔符
		data = data[:len(data)-1]
		text := string(data)
		fmt.Println("服务端读到了: " + text)
		resp := fmt.Sprintf("Hello, client. I have read: [%s] from you.", text)
		_, _ = socket.Write([]byte(resp))
	}
	fmt.Println("连接关闭")
}

这里和基础版最大的不同在于，它多了一个分隔符分割输入字节流，可以看到，我们把Socket的读取放到一个Reader中，Reader会源源不断地从Socket中读取，然后每次读取到分隔符(在这里时'\n')，就进行分割，把前面的部分返回，然后重制起始位置为分隔符下一个位置，直到连接被关闭，socket不可读，返回EOF为止。

来看一个可能的客户端实现：

func clientDelimiterBased() {
	tcpAddr, err := net.ResolveTCPAddr("tcp", "127.0.0.1:8190")
	if err != nil {
		log.Fatal(err)
	}
	socket, err := net.DialTCP("tcp", nil, tcpAddr)
	if err != nil {
		log.Fatal(err)
	}
	var input string
	fmt.Println("input for 5 loops")
	for i := 0; i < 5; i++ {
		_, _ = fmt.Scanf("%s", &input)
		// 添加分隔符
		input = input + "\n"
		_, _ = socket.Write([]byte(input))
		response := make([]byte, 1024)
		readLen, _ := socket.Read(response)
		fmt.Println(string(response[:readLen]))
	}
	err = socket.Close()
	if err != nil {
		log.Fatal(err)
	}
}

通过分隔符，我们可以不用考虑粘包和拆包，也不用猜测请求长度，只要源源不断的读，然后分割请求即可；其实这里请求也可以这么写，但是为了图省事和简化代码就没有这么做。

基于分隔符有一个小小的缺点，就是分隔符如果也是内容的一部分，可能就不好处理，此外，使用分隔符进行“分割”，要求对已读取的流进行遍历，或者说需要遍历缓冲区。所以这是一个性能损耗。

基于长度

如果，我们可以在某个位置制定此次请求的长度，而这个记录长度的值一定可以被读取到，且一定是最先读取的，那是不是就可以通过统计目前读取了多少字节来进行请求切分呢？我之前写过一个IM系统，就是自定义消息体，消息体里有长度字段，然后借用Netty的长度分割Handler，进行基于长度分割来实现划分不同的消息这一功能。

当然这里我们为了演示，不会做那么复杂，直接把长度作为第一位写出就行，后面紧跟数据。这里长度选取int32类型，占4个byte，同时因为TCP使用的是大段法，所以我们写出之前记得指定一下。

看看码：

func clientLengthBased() {
	tcpAddr, err := net.ResolveTCPAddr("tcp", "127.0.0.1:8190")
	if err != nil {
		log.Fatal(err)
	}
	socket, err := net.DialTCP("tcp", nil, tcpAddr)
	if err != nil {
		log.Fatal(err)
	}
	var input string
	fmt.Println("input for 5 loops")
	for i := 0; i < 5; i++ {
		_, _ = fmt.Scanf("%s", &input)
		data := []byte(input)
		var buffer = bytes.NewBuffer([]byte{})
		// 先写入长度
		_ = binary.Write(buffer, binary.BigEndian, int32(len(data)))
		// 再写入数据
		_ = binary.Write(buffer, binary.BigEndian, data)
		_, _ = socket.Write(buffer.Bytes())
		response := make([]byte, 1024)
		readLen, _ := socket.Read(response)
		fmt.Println(string(response[:readLen]))
	}
	err = socket.Close()
	if err != nil {
		log.Fatal(err)
	}
}

再来看一个可能的客户端实现：

func clientLengthBased() {
	tcpAddr, err := net.ResolveTCPAddr("tcp", "127.0.0.1:8190")
	if err != nil {
		log.Fatal(err)
	}
	socket, err := net.DialTCP("tcp", nil, tcpAddr)
	if err != nil {
		log.Fatal(err)
	}
	var input string
	fmt.Println("input for 5 loops")
	for i := 0; i < 5; i++ {
		_, _ = fmt.Scanf("%s", &input)
		data := []byte(input)
		var buffer = bytes.NewBuffer([]byte{})
		// 先写入长度
		_ = binary.Write(buffer, binary.BigEndian, int32(len(data)))
		// 再写入数据
		_ = binary.Write(buffer, binary.BigEndian, data)
		_, _ = socket.Write(buffer.Bytes())
		response := make([]byte, 1024)
		readLen, _ := socket.Read(response)
		fmt.Println(string(response[:readLen]))
	}
	err = socket.Close()
	if err != nil {
		log.Fatal(err)
	}
}

简单易懂是吧！好！结束。因为Socket编程本身在Golang里就没什么好说的，也不像Java还有Reactor模型，直接无脑go跑一下就行。所以人生苦短，CS:GO。

HTTP

Golang诞生之初就是为了解决谷歌网络编程的痛点问题，比如说写一个WebApp要导一堆的包，还要一堆的框架去跑，否则开发效率上不来（我可没有说Java。

Golang简单很多，直接Http监听然后设置路由，每个path对应一个HTTPHandle方法，每个请求跑在独立的Goroutine中。所以很容易扛住千万并发，也不用管什么阻塞，直接一步到位写就是了。

来看一个简单的使用：

package server

import (
	"fmt"
	"net/http"
	"strings"
)

type HandlerFunc func(w http.ResponseWriter, r *http.Request)

type myHandler struct {
	// 我们这里路径映射匹配只在最开始是写的，所以不需要同步
	handlers map[string]HandlerFunc
}

func NewMyHandler() *myHandler {
	return &myHandler{
		handlers: make(map[string]HandlerFunc),
	}
}

func (h *myHandler) AddHandler(path, method string, handler http.Handler) {
	key := path + "#" + method
	h.handlers[key] = handler.ServeHTTP
}

func (h *myHandler) AddHandlerFunc(path, method string, f HandlerFunc) {
	key := path + "#" + method
	h.handlers[key] = f
}

type notFound struct {
}

func (n *notFound) ServeHTTP(writer http.ResponseWriter, request *http.Request) {
}

var handler404 = notFound{}

func (h *myHandler) getHandlerFunc(path, method string) HandlerFunc {
	key := path + "#" + method
	handler, ok := h.handlers[key]
	if !ok {
		// todo 返回404专有handler
		return handler404.ServeHTTP
	} else {
		return handler
	}
}

func (h *myHandler) ServeHTTP(writer http.ResponseWriter, request *http.Request) {
	url := request.RequestURI
	method := request.Method
	uri := strings.Split(url, "?")[0]
	h.getHandlerFunc(uri, method)(writer, request)
}

func ServeHttp() {
	myHandler := NewMyHandler()
	myHandler.AddHandlerFunc("/hello", "GET", func(w http.ResponseWriter, r *http.Request) {
		// 必须解析哈！不然会报错
		_ = r.ParseForm()
		fmt.Println(r.Form.Get("name"))
		_, _ = w.Write([]byte("ok"))
	})
	myHandler.AddHandlerFunc("/hello", "POST", func(w http.ResponseWriter, r *http.Request) {
		_ = r.ParseForm()
		fmt.Println(r.PostForm.Get("name"))
		_, _ = w.Write([]byte("ok"))
	})
	myHandler.AddHandlerFunc("/upload", "POST", func(w http.ResponseWriter, r *http.Request) {
		// 限制大小为8MB
		_ = r.ParseMultipartForm(8 << 20)
		fileHeader := r.MultipartForm.File["my_file"][0]
		fmt.Println(fileHeader.Filename)
		_, _ = w.Write([]byte("ok"))
	})
	_ = http.ListenAndServe(":8190", myHandler)
}

上面代码我们先不说，先理一下Golang的整个HTTP处理流程，回过头来再看。

揭开面纱

首先进入最开始的http.ListenAndServe()方法，这个方法源码如下：

构造一个Server对象，并调用它的ListenAndServe()方法，设置监听地址和handler，这个handler暂时理解成路由器。

Golang默认对于Http的处理是开发者提供一个路由器，然后对于每次请求，调用路由器路由到指定的处理函数，一般来说，处理函数也是开发者指定的，即，你要提供一个路由器，Golang把URI传给你，你根据URI找到处理这个URI的函数，并调用它，这一切都是在一个独立的Goroutine中处理的，每个请求互相隔离。

server.ListenAndServe()的实现就是简单的监听端口，得到一个Listener：

这个方法实现比较简单：

首先使用死循环不停轮训端口，直到有连接建立，否则阻塞。然后设置用于连接建立后的上下文，然后使用Accept()方法得到一个Socket，因为Socket可读可写，所以命名为rw。

这个上下文在每一个Socket中保存了创建这个Socket的ServerSocket(就是Listener)；此外，context的实现也很有意思，通过父context派生出子context的方式实现扩展context，或者增加值的操作。查询则是通过递归实现，如果当前context没有，则去父context中寻找。

这里面使用serverSocket的newConn()方法构造了一个连接对象，这个对象包含了用于读写的Socket，ServerSocket等信息，我们称它为新的更加全面的Socket(因为它还是用来操作远程客户端的读写)。

最后看到，开启一个新的Goroutine去执行新连接的读写请求，这和我们上面写的TCP好像啊！这也就是Golang可以抗住高连接的秘密。其实到现在为止，你也猜到了，c.server()方法无非就是封装HTTP请求和响应呗？确实如此！所以我们深入一下这个方法：

这个方法很简单，就是根据Socket的读写方法和缓冲区(之前有设置，我省略了没展示)来构造一个Response对象，并通过响应对象获得与它绑定的请求，传入新构建的Server对象的ServeHTTP()进行处理。

这里可以明白，虽然每次都构造了Server对象，但实质上所有的连接共享的都是同一个ServerSocket对象，即使这里有构造操作。

这里的handle其实就是一个路由表，指出了URI+Method=Func的对应关系，Func指的是业务逻辑函数。如果没有实现，则会使用默认的路由器。这个默认的路由器实现可以一谈，因为我们可以模仿它做一个属于我们的路由器：

这是默认路由器的结构，这个读写锁用于给路由表加锁，在读取路由表时加读锁，在更新路由表时加写锁。默认路由器实现了ServeHTTP()方法，这个方法会根据URI+Method作为key，去map里面查找对应的Entry并调用它的Handler.ServerHTTP()方法。

注意⚠️，这里虽然出现了两次ServeHTTP()方法，但是前者不做业务处理，仅做请求转发，后者是被转发的请求对应的业务处理函数，负责处理实际的请求。

回到最初

现在我们看到，构造一个HTTP服务器，需要的两个参数，分别是监听地址和实现了ServeHTTP()方法的对象，Golang会为每一个请求调用我们传入的对象的ServeHTTP()方法去处理，所以我们必须在这个方法里实现我们自己的路由逻辑。至于路由之后你完全可以重新定一个新的业务逻辑方法，只要能根据请求找到可以处理它的Handler/Func即可。默认路由器使用业务处理函数和路由函数一样的定义是为了省事（我也是。

不要重复造轮子

最后，不要重复造轮子，Golang的HTTP包已经很好用了，但那不是你手撸框架的理由，这里推荐一个我个人蛮喜欢的框架：

Gin

这里给出一些它的基本用法：

package src

import (
	"fmt"
	"github.com/gin-gonic/gin"
	"strings"
)

func wrapStr(context *gin.Context, str string) {
	context.String(200, "%s", str)
}

// CRUD 比较简单的RESTFul格式的请求
func CRUD() {
	router := gin.Default()
	// 每个请求一个Context
	router.GET("/isGet", func(context *gin.Context) {
		context.String(200, "%s", "ok")
	})
	router.POST("/isPost", func(context *gin.Context) {
		context.String(200, "%s", "ok")
	})
	router.DELETE("/isDelete", func(context *gin.Context) {
		context.String(200, "%s", "ok")
	})
	router.PUT("isPut", func(context *gin.Context) {
		context.String(200, "%s", "ok")
	})
	router.Run("127.0.0.1:8190")
}

func PathVariable() {
	router := gin.Default()
	// 路径参数
	router.GET("/param/:name", func(context *gin.Context) {
		wrapStr(context, "name is:"+context.Param("name"))
	})
	// 强匹配，优先于路径参数匹配，和书写顺序无关
	router.GET("/param/msl", func(context *gin.Context) {
		wrapStr(context, "just msl")
	})
	// 可为空匹配
	router.GET("/param/nullable/:name1/*name2", func(context *gin.Context) {
		wrapStr(context, "nullable name: "+context.Param("name1")+", "+context.Param("name2"))
	})
	router.Run(":8190")
}

func GetAndPost() {
	r := gin.Default()
	r.GET("/get", func(context *gin.Context) {
		// 进行参数查询，也可以设置缺省值
		name := context.DefaultQuery("name", "msl")
		age := context.Query("age")
		wrapStr(context, "name: "+name+", age: "+age)
	})
	r.POST("/post", func(context *gin.Context) {
		name := context.DefaultPostForm("name", "msl")
		age := context.PostForm("age")
		wrapStr(context, "name: "+name+", age: "+age)
	})
	// 当然，路径查询也可以和表单查询混合使用
	r.POST("/map", func(context *gin.Context) {
		// 进行map解析，要求查询参数符合map书写形式，比如：/map?ids[0]=1&ids[1]=2
		// 同时请求体：names[0]=msl;names[1]=cwb
		ids := context.QueryMap("ids")
		names := context.PostFormMap("names")
		context.JSON(200, gin.H{
			"ids":   ids,
			"names": names,
		})
	})
	r.Run(":8190")
}

func FileUpload() {
	r := gin.Default()
	// 限制文件存储使用的内存大小为8MB
	r.MaxMultipartMemory = 8 << 20
	r.POST("/upload", func(context *gin.Context) {
		file, _ := context.FormFile("file")
		wrapStr(context, "get file: "+file.Filename+", size: "+fmt.Sprintf("%d", file.Size))
	})
	// 多文件上传
	r.POST("/uploads", func(context *gin.Context) {
		form, _ := context.MultipartForm()
		files := form.File["files"]
		stringBuilder := strings.Builder{}
		for _, file := range files {
			// 保存文件
			// context.SaveUploadedFile(file, "")
			stringBuilder.WriteString(file.Filename)
			stringBuilder.WriteString(", ")
		}
		wrapStr(context, stringBuilder.String())
	})
	r.Run(":8190")
}

func MiddleWare() {
	r := gin.New()
	r.GET("/test1", func(context *gin.Context) {
		wrapStr(context, "ok")
	})
	// 对所有/a开头的请求进行拦截
	auth := r.Group("/a")
	// 类似于添加请求拦截器
	auth.Use(func(context *gin.Context) {
		fmt.Println("need auth")
	})
	// 这个花括号就是为了美观
	// 在这里处理所有以/a为开头的请求
	{
		auth.POST("/signIn", func(context *gin.Context) {
			username := context.PostForm("username")
			password := context.PostForm("password")
			context.JSON(200, gin.H{
				"username": username,
				"password": password,
			})
		})
	}
	// 统一拦截和书写位置无关
	r.GET("/test2", func(context *gin.Context) {
		wrapStr(context, "ok")
	})
	r.Use(gin.CustomRecovery(func(context *gin.Context, err interface{}) {
		// 在这里编写panic处理逻辑
	}))
	r.Run(":8190")
}

一些想法

Golang的Goroutine固然好用，也很容易扛住高连接，而且开发心智低，但是它不是万能药，尤其是在性能方面。

现在处理高连接无非就是Golang/Kotlin的协程；或者是Java/Rust/C++的异步，听说C++也开始支持协程了。这两个方式有好有坏。

首先是协程，优点很明显，就是简单，写起来不容易出问题，学习成本低；但是缺点有一个不太容易想到的，就是用户级线程通过自定义执行上下文的方法，会造成更多的Cache Miss以及更难让CPU做出指令级优化，比如分支预测。

其次是异步，优点不是很明显，但是它本质依旧是函数调用，可以让编译器进行更多的优化，以及指令级优化；缺点就很明显，如果你写过类似的框架，比如Java的Netty，就知道需要处处处理阻塞和线程，这样会容易产生BUG和降低开发效率。

最后，人生苦短，Let's Go!