現在我們幾乎每天都在使用互聯網，我們前面已經學習瞭如何編寫Go語言程序，但是如何才能讓我們的程序通過網絡互相通信呢？本章我們就一起來學習下Go語言中的網絡編程。關於網絡編程其實是一個很龐大的領域，本文只是簡單的演示瞭如何使用net包進行TCP和UDP通信。如需瞭解更詳細的網絡編程請自行檢索和閱讀專業資料。

互聯網協議介紹

互聯網的核心是一系列協議，總稱爲”互聯網協議”（Internet Protocol Suite），正是這一些協議規定了電腦如何連接和組網。我們理解了這些協議，就理解了互聯網的原理。由於這些協議太過龐大和複雜，沒有辦法在這裏一概而全，只能介紹一下我們日常開發中接觸較多的幾個協議。

互聯網分層模型

互聯網的邏輯實現被分爲好幾層。每一層都有自己的功能，就像建築物一樣，每一層都靠下一層支持。用戶接觸到的只是最上面的那一層，根本不會感覺到下面的幾層。要理解互聯網就需要自下而上理解每一層的實現的功能。

如上圖所示，互聯網按照不同的模型劃分會有不用的分層，但是不論按照什麼模型去劃分，越往上的層越靠近用戶，越往下的層越靠近硬件。在軟件開發中我們使用最多的是上圖中將互聯網劃分爲五個分層的模型。

接下來我們一層一層的自底向上介紹一下每一層。

| 物理層

我們的電腦要與外界互聯網通信，需要先把電腦連接網絡，我們可以用雙絞線、光纖、無線電波等方式。這就叫做”實物理層”，它就是把電腦連接起來的物理手段。它主要規定了網絡的一些電氣特性，作用是負責傳送0和1的電信號。

| 數據鏈路層

單純的0和1沒有任何意義，所以我們使用者會爲其賦予一些特定的含義，規定解讀電信號的方式：例如：多少個電信號算一組？每個信號位有何意義？這就是”數據鏈接層”的功能，它在”物理層”的上方，確定了物理層傳輸的0和1的分組方式及代表的意義。早期的時候，每家公司都有自己的電信號分組方式。逐漸地，一種叫做”以太網”（Ethernet）的協議，佔據了主導地位。

以太網規定，一組電信號構成一個數據包，叫做”幀”（Frame）。每一幀分成兩個部分：標頭（Head）和數據（Data）。其中”標頭”包含數據包的一些說明項，比如發送者、接受者、數據類型等等；”數據”則是數據包的具體內容。”標頭”的長度，固定爲18字節。”數據”的長度，最短爲46字節，最長爲1500字節。因此，整個”幀”最短爲64字節，最長爲1518字節。如果數據很長，就必須分割成多個幀進行發送。

那麼，發送者和接受者是如何標識呢？以太網規定，連入網絡的所有設備都必須具有”網卡”接口。數據包必須是從一塊網卡，傳送到另一塊網卡。網卡的地址，就是數據包的發送地址和接收地址，這叫做MAC地址。每塊網卡出廠的時候，都有一個全世界獨一無二的MAC地址，長度是48個二進制位，通常用12個十六進制數表示。前6個十六進制數是廠商編號，後6個是該廠商的網卡流水號。有了MAC地址，就可以定位網卡和數據包的路徑了。

我們會通過ARP協議來獲取接受方的MAC地址，有了MAC地址之後，如何把數據準確的發送給接收方呢？其實這裏以太網採用了一種很”原始”的方式，它不是把數據包準確送到接收方，而是向本網絡內所有計算機都發送，讓每臺計算機讀取這個包的”標頭”，找到接收方的MAC地址，然後與自身的MAC地址相比較，如果兩者相同，就接受這個包，做進一步處理，否則就丟棄這個包。這種發送方式就叫做”廣播”（broadcasting）。

| 網絡層

按照以太網協議的規則我們可以依靠MAC地址來向外發送數據。理論上依靠MAC地址，你電腦的網卡就可以找到身在世界另一個角落的某臺電腦的網卡了，但是這種做法有一個重大缺陷就是以太網採用廣播方式發送數據包，所有成員人手一”包”，不僅效率低，而且發送的數據只能侷限在發送者所在的子網絡。也就是說如果兩臺計算機不在同一個子網絡，廣播是傳不過去的。這種設計是合理且必要的，因爲如果互聯網上每一臺計算機都會收到互聯網上收發的所有數據包，那是不現實的。

因此，必須找到一種方法區分哪些MAC地址屬於同一個子網絡，哪些不是。如果是同一個子網絡，就採用廣播方式發送，否則就採用”路由”方式發送。這就導致了”網絡層”的誕生。它的作用是引進一套新的地址，使得我們能夠區分不同的計算機是否屬於同一個子網絡。這套地址就叫做”網絡地址”，簡稱”網址”。

“網絡層”出現以後，每臺計算機有了兩種地址，一種是MAC地址，另一種是網絡地址。兩種地址之間沒有任何聯繫，MAC地址是綁定在網卡上的，網絡地址則是網絡管理員分配的。網絡地址幫助我們確定計算機所在的子網絡，MAC地址則將數據包送到該子網絡中的目標網卡。因此，從邏輯上可以推斷，必定是先處理網絡地址，然後再處理MAC地址。

規定網絡地址的協議，叫做IP協議。它所定義的地址，就被稱爲IP地址。目前，廣泛採用的是IP協議第四版，簡稱IPv4。IPv4這個版本規定，網絡地址由32個二進制位組成，我們通常習慣用分成四段的十進制數表示IP地址，從0.0.0.0一直到255.255.255.255。

根據IP協議發送的數據，就叫做IP數據包。IP數據包也分爲”標頭”和”數據”兩個部分：”標頭”部分主要包括版本、長度、IP地址等信息，”數據”部分則是IP數據包的具體內容。IP數據包的”標頭”部分的長度爲20到60字節，整個數據包的總長度最大爲65535字節。

| 傳輸層

有了MAC地址和IP地址，我們已經可以在互聯網上任意兩臺主機上建立通信。但問題是同一臺主機上會有許多程序都需要用網絡收發數據，比如QQ和瀏覽器這兩個程序都需要連接互聯網並收發數據，我們如何區分某個數據包到底是歸哪個程序的呢？也就是說，我們還需要一個參數，表示這個數據包到底供哪個程序（進程）使用。這個參數就叫做”端口”（port），它其實是每一個使用網卡的程序的編號。每個數據包都發到主機的特定端口，所以不同的程序就能取到自己所需要的數據。

“端口”是0到65535之間的一個整數，正好16個二進制位。0到1023的端口被系統佔用，用戶只能選用大於1023的端口。有了IP和端口我們就能實現唯一確定互聯網上一個程序，進而實現網絡間的程序通信。

我們必須在數據包中加入端口信息，這就需要新的協議。最簡單的實現叫做UDP協議，它的格式幾乎就是在數據前面，加上端口號。UDP數據包，也是由”標頭”和”數據”兩部分組成：”標頭”部分主要定義了發出端口和接收端口，”數據”部分就是具體的內容。UDP數據包非常簡單，”標頭”部分一共只有8個字節，總長度不超過65,535字節，正好放進一個IP數據包。

UDP協議的優點是比較簡單，容易實現，但是缺點是可靠性較差，一旦數據包發出，無法知道對方是否收到。爲了解決這個問題，提高網絡可靠性，TCP協議就誕生了。TCP協議能夠確保數據不會遺失。它的缺點是過程複雜、實現困難、消耗較多的資源。TCP數據包沒有長度限制，理論上可以無限長，但是爲了保證網絡的效率，通常TCP數據包的長度不會超過IP數據包的長度，以確保單個TCP數據包不必再分割。

| 應用層

應用程序收到”傳輸層”的數據，接下來就要對數據進行解包。由於互聯網是開放架構，數據來源五花八門，必須事先規定好通信的數據格式，否則接收方根本無法獲得真正發送的數據內容。”應用層”的作用就是規定應用程序使用的數據格式，例如我們TCP協議之上常見的Email、HTTP、FTP等協議，這些協議就組成了互聯網協議的應用層。

如下圖所示，發送方的HTTP數據經過互聯網的傳輸過程中會依次添加各層協議的標頭信息，接收方收到數據包之後再依次根據協議解包得到數據。

詳見計算機網絡一節

socket編程

Socket是BSD UNIX的進程通信機制，通常也稱作”套接字”，用於描述IP地址和端口，是一個通信鏈的句柄。Socket可以理解爲TCP/IP網絡的API，它定義了許多函數或例程，程序員可以用它們來開發TCP/IP網絡上的應用程序。電腦上運行的應用程序通常通過”套接字”向網絡發出請求或者應答網絡請求。

socket圖解

Socket是應用層與TCP/IP協議族通信的中間軟件抽象層。在設計模式中，Socket其實就是一個門面模式，它把複雜的TCP/IP協議族隱藏在Socket後面，對用戶來說只需要調用Socket規定的相關函數，讓Socket去組織符合指定的協議數據然後進行通信。

Go語言實現TCP通信

| TCP協議

TCP/IP(Transmission Control Protocol/Internet Protocol) 即傳輸控制協議/網間協議，是一種面向連接（連接導向）的、可靠的、基於字節流的傳輸層（Transport layer）通信協議，因爲是面向連接的協議，數據像水流一樣傳輸，會存在黏包問題。

| TCP服務端

一個TCP服務端可以同時連接很多個客戶端，例如世界各地的用戶使用自己電腦上的瀏覽器訪問淘寶網。因爲Go語言中創建多個goroutine實現併發非常方便和高效，所以我們可以每建立一次鏈接就創建一個goroutine去處理。

TCP服務端程序的處理流程：

監聽端口
接收客戶端請求建立鏈接
創建goroutine處理鏈接。

我們使用Go語言的net包實現的TCP服務端代碼如下：

// tcp/server/main.go

// TCP server端

// 處理函數
func process(conn net.Conn) {
	defer conn.Close() // 關閉連接
	for {
		reader := bufio.NewReader(conn)
		var buf [128]byte
		n, err := reader.Read(buf[:]) // 讀取數據
		if err != nil {
			fmt.Println("read from client failed, err:", err)
			break
		}
		recvStr := string(buf[:n])
		fmt.Println("收到client端發來的數據：", recvStr)
		conn.Write([]byte(recvStr)) // 發送數據
	}
}

func main() {
	listen, err := net.Listen("tcp", "127.0.0.1:20000")
	if err != nil {
		fmt.Println("listen failed, err:", err)
		return
	}
	for {
		conn, err := listen.Accept() // 建立連接
		if err != nil {
			fmt.Println("accept failed, err:", err)
			continue
		}
		go process(conn) // 啓動一個goroutine處理連接
	}
}

將上面的代碼保存之後編譯成server或server.exe可執行文件。

| TCP客戶端

一個TCP客戶端進行TCP通信的流程如下：

建立與服務端的鏈接
進行數據收發
關閉鏈接

使用Go語言的net包實現的TCP客戶端代碼如下：

// tcp/client/main.go

// 客戶端
func main() {
	conn, err := net.Dial("tcp", "127.0.0.1:20000")
	if err != nil {
		fmt.Println("err :", err)
		return
	}
	defer conn.Close() // 關閉連接
	inputReader := bufio.NewReader(os.Stdin)
	for {
		input, _ := inputReader.ReadString('\n') // 讀取用戶輸入
		inputInfo := strings.Trim(input, "\r\n")
		if strings.ToUpper(inputInfo) == "Q" { // 如果輸入q就退出
			return
		}
		_, err = conn.Write([]byte(inputInfo)) // 發送數據
		if err != nil {
			return
		}
		buf := [512]byte{}
		n, err := conn.Read(buf[:])
		if err != nil {
			fmt.Println("recv failed, err:", err)
			return
		}
		fmt.Println(string(buf[:n]))
	}
}

將上面的代碼編譯成client或client.exe可執行文件，先啓動server端再啓動client端，在client端輸入任意內容回車之後就能夠在server端看到client端發送的數據，從而實現TCP通信。

TCP黏包

| 黏包示例

服務端代碼如下：

// socket_stick/server/main.go

func process(conn net.Conn) {
	defer conn.Close()
	reader := bufio.NewReader(conn)
	var buf [1024]byte
	for {
		n, err := reader.Read(buf[:])
		if err == io.EOF {
			break
		}
		if err != nil {
			fmt.Println("read from client failed, err:", err)
			break
		}
		recvStr := string(buf[:n])
		fmt.Println("收到client發來的數據：", recvStr)
	}
}

func main() {

	listen, err := net.Listen("tcp", "127.0.0.1:30000")
	if err != nil {
		fmt.Println("listen failed, err:", err)
		return
	}
	defer listen.Close()
	for {
		conn, err := listen.Accept()
		if err != nil {
			fmt.Println("accept failed, err:", err)
			continue
		}
		go process(conn)
	}
}

客戶端代碼如下：

// socket_stick/client/main.go

func main() {
	conn, err := net.Dial("tcp", "127.0.0.1:30000")
	if err != nil {
		fmt.Println("dial failed, err", err)
		return
	}
	defer conn.Close()
	for i := 0; i < 20; i++ {
		msg := `Hello, Hello. How are you?`
		conn.Write([]byte(msg))
	}
}

將上面的代碼保存後，分別編譯。先啓動服務端再啓動客戶端，可以看到服務端輸出結果如下：

收到client發來的數據： Hello, Hello. How are you?Hello, Hello. How are you?Hello, Hello. How are you?Hello, Hello. How are you?Hello, Hello. How are you?
收到client發來的數據： Hello, Hello. How are you?Hello, Hello. How are you?Hello, Hello. How are you?Hello, Hello. How are you?Hello, Hello. How are you?Hello, Hello. How are you?Hello, Hello. How are you?Hello, Hello. How are you?
收到client發來的數據： Hello, Hello. How are you?Hello, Hello. How are you?
收到client發來的數據： Hello, Hello. How are you?Hello, Hello. How are you?Hello, Hello. How are you?
收到client發來的數據： Hello, Hello. How are you?Hello, Hello. How are you?

客戶端分10次發送的數據，在服務端並沒有成功的輸出10次，而是多條數據“粘”到了一起。

| 爲什麼會出現粘包

主要原因就是tcp數據傳遞模式是流模式，在保持長連接的時候可以進行多次的收和發。

“粘包”可發生在發送端也可發生在接收端：

由Nagle算法造成的發送端的粘包：Nagle算法是一種改善網絡傳輸效率的算法。簡單來說就是當我們提交一段數據給TCP發送時，TCP並不立刻發送此段數據，而是等待一小段時間看看在等待期間是否還有要發送的數據，若有則會一次把這兩段數據發送出去。
接收端接收不及時造成的接收端粘包：TCP會把接收到的數據存在自己的緩衝區中，然後通知應用層取數據。當應用層由於某些原因不能及時的把TCP的數據取出來，就會造成TCP緩衝區中存放了幾段數據。

| 爲什麼會出現粘包

出現”粘包”的關鍵在於接收方不確定將要傳輸的數據包的大小，因此我們可以對數據包進行封包和拆包的操作。

封包：封包就是給一段數據加上包頭，這樣一來數據包就分爲包頭和包體兩部分內容了(過濾非法包時封包會加入”包尾”內容)。包頭部分的長度是固定的，並且它存儲了包體的長度，根據包頭長度固定以及包頭中含有包體長度的變量就能正確的拆分出一個完整的數據包。

我們可以自己定義一個協議，比如數據包的前4個字節爲包頭，裏面存儲的是發送的數據的長度。

// socket_stick/proto/proto.go
package proto

import (
	"bufio"
	"bytes"
	"encoding/binary"
)

// Encode 將消息編碼
func Encode(message string) ([]byte, error) {
	// 讀取消息的長度，轉換成int32類型（佔4個字節）
	var length = int32(len(message))
	var pkg = new(bytes.Buffer)
	// 寫入消息頭
	err := binary.Write(pkg, binary.LittleEndian, length)
	if err != nil {
		return nil, err
	}
	// 寫入消息實體
	err = binary.Write(pkg, binary.LittleEndian, []byte(message))
	if err != nil {
		return nil, err
	}
	return pkg.Bytes(), nil
}

// Decode 解碼消息
func Decode(reader *bufio.Reader) (string, error) {
	// 讀取消息的長度
	lengthByte, _ := reader.Peek(4) // 讀取前4個字節的數據
	lengthBuff := bytes.NewBuffer(lengthByte)
	var length int32
	err := binary.Read(lengthBuff, binary.LittleEndian, &length)
	if err != nil {
		return "", err
	}
	// Buffered返回緩衝中現有的可讀取的字節數。
	if int32(reader.Buffered()) < length+4 {
		return "", err
	}

	// 讀取真正的消息數據
	pack := make([]byte, int(4+length))
	_, err = reader.Read(pack)
	if err != nil {
		return "", err
	}
	return string(pack[4:]), nil
}

接下來在服務端和客戶端分別使用上面定義的proto包的Decode和Encode函數處理數據。

服務端代碼如下：

// socket_stick/server2/main.go

func process(conn net.Conn) {
	defer conn.Close()
	reader := bufio.NewReader(conn)
	for {
		msg, err := proto.Decode(reader)
		if err == io.EOF {
			return
		}
		if err != nil {
			fmt.Println("decode msg failed, err:", err)
			return
		}
		fmt.Println("收到client發來的數據：", msg)
	}
}

func main() {

	listen, err := net.Listen("tcp", "127.0.0.1:30000")
	if err != nil {
		fmt.Println("listen failed, err:", err)
		return
	}
	defer listen.Close()
	for {
		conn, err := listen.Accept()
		if err != nil {
			fmt.Println("accept failed, err:", err)
			continue
		}
		go process(conn)
	}
}

客戶端代碼如下：

// socket_stick/client2/main.go

func main() {
	conn, err := net.Dial("tcp", "127.0.0.1:30000")
	if err != nil {
		fmt.Println("dial failed, err", err)
		return
	}
	defer conn.Close()
	for i := 0; i < 20; i++ {
		msg := `Hello, Hello. How are you?`
		data, err := proto.Encode(msg)
		if err != nil {
			fmt.Println("encode msg failed, err:", err)
			return
		}
		conn.Write(data)
	}
}

Go語言實現UDP通信

| UDP協議

UDP協議（User Datagram Protocol）中文名稱是用戶數據報協議，是OSI（Open System Interconnection，開放式系統互聯）參考模型中一種 無連接 的傳輸層協議，不需要建立連接就能直接進行數據發送和接收，屬於不可靠的、沒有時序的通信，但是UDP協議的實時性比較好，通常用於視頻直播相關領域。

| UDP服務端

使用Go語言的net包實現的UDP服務端代碼如下：

// UDP/server/main.go

// UDP server端
func main() {
	listen, err := net.ListenUDP("udp", &net.UDPAddr{
		IP:   net.IPv4(0, 0, 0, 0),
		Port: 30000,
	})
	if err != nil {
		fmt.Println("listen failed, err:", err)
		return
	}
	defer listen.Close()
	for {
		var data [1024]byte
		n, addr, err := listen.ReadFromUDP(data[:]) // 接收數據
		if err != nil {
			fmt.Println("read udp failed, err:", err)
			continue
		}
		fmt.Printf("data:%v addr:%v count:%v\n", string(data[:n]), addr, n)
		_, err = listen.WriteToUDP(data[:n], addr) // 發送數據
		if err != nil {
			fmt.Println("write to udp failed, err:", err)
			continue
		}
	}
}

| UDP客戶端

使用Go語言的net包實現的UDP客戶端代碼如下：

// UDP 客戶端
func main() {
	socket, err := net.DialUDP("udp", nil, &net.UDPAddr{
		IP:   net.IPv4(0, 0, 0, 0),
		Port: 30000,
	})
	if err != nil {
		fmt.Println("連接服務端失敗，err:", err)
		return
	}
	defer socket.Close()
	sendData := []byte("Hello server")
	_, err = socket.Write(sendData) // 發送數據
	if err != nil {
		fmt.Println("發送數據失敗，err:", err)
		return
	}
	data := make([]byte, 4096)
	n, remoteAddr, err := socket.ReadFromUDP(data) // 接收數據
	if err != nil {
		fmt.Println("接收數據失敗，err:", err)
		return
	}
	fmt.Printf("recv:%v addr:%v count:%v\n", string(data[:n]), remoteAddr, n)
}

【對比python】

詳見python網絡編程

Go語言全棧開發：網絡編程

互聯網協議介紹

socket編程

如何使用 JS 判斷用戶是否處於活躍狀態

lightdb秒級增加列和刪除列（not null帶默認值）

lightdb數據庫超時相關控制參數

通過HPA+CronHPA組合應對業務複雜彈性伸縮場景

❤️‍🔥 Solon Cloud Event 新的事務特性與應用

lightdb mysql 8.0兼容之不可見主鍵

基於Ubuntu-22.04安裝K8s-v1.28.2實驗（四）使用域名訪問網站應用

Flask開發：初識Flask

Go語言全棧開發：基本數據類型

RabbitMQ在python開發中的應用

Go語言全棧開發：流程控制

Go語言全棧開發：切片

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結