Go進階之網路程式設計

BigSun丶發表於2024-03-19
Go程式設計

目錄
  • Go語言基礎之網路程式設計
  • 一、網際網路協議介紹
  • 二、網際網路分層模型
    • 1. 物理層
    • 2. 資料鏈路層
    • 3. 網路層
    • 4. 傳輸層
    • 5. 應用層
  • 三、socket程式設計
    • 1. socket圖解
  • 四、Go語言實現TCP通訊
    • 1. TCP協議
    • 2. TCP服務端
    • 3. TCP客戶端
    • 4. TCP黏包
      • （1）黏包示例
      • （2）為什麼會出現粘包
      • （3）解決辦法
  • 五、Go語言實現UDP通訊
    • 1. UDP協議
    • 2. UDP服務端
    • 3. UDP客戶端

Go語言基礎之網路程式設計

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

一、網際網路協議介紹

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

二、網際網路分層模型

  • 網際網路的邏輯實現被分為好幾層。每一層都有自己的功能，就像建築物一樣，每一層都靠下一層支援。使用者接觸到的只是最上面的那一層，根本不會感覺到下面的幾層。要理解網際網路就需要自下而上理解每一層的實現的功能。 網際網路按照不同的模型劃分會有不用的分層，但是不論按照什麼模型去劃分，越往上的層越靠近使用者，越往下的層越靠近硬體。在軟體開發中我們使用最多的是上圖中將網際網路劃分為五個分層的模型。
  • 接下來我們一層一層的自底向上介紹一下每一層

1. 物理層

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

2. 資料鏈路層

  • 單純的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）。

3. 網路層

  • 按照乙太網協議的規則我們可以依靠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位元組。

4. 傳輸層

  • 有了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資料包不必再分割。

5. 應用層

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

  • 如下圖所示，傳送方的HTTP資料經過網際網路的傳輸過程中會依次新增各層協議的標頭資訊，接收方收到資料包之後再依次根據協議解包得到資料。

三、socket程式設計

  • Socket是BSD UNIX的程序通訊機制，通常也稱作”套接字”，用於描述IP地址和埠，是一個通訊鏈的控制代碼。Socket可以理解為TCP/IP網路的API，它定義了許多函式或例程，程式設計師可以用它們來開發TCP/IP網路上的應用程式。電腦上執行的應用程式通常透過”套接字”向網路發出請求或者應答網路請求。

1. socket圖解

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

四、Go語言實現TCP通訊

1. TCP協議

  • TCP/IP(Transmission Control Protocol/Internet Protocol) 即傳輸控制協議/網間協議，是一種面向連線（連線導向）的、可靠的、基於位元組流的傳輸層（Transport layer）通訊協議，因為是面向連線的協議，資料像水流一樣傳輸，會存在黏包問題。

2. TCP服務端

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

  • TCP服務端程式的處理流程：

    1. 監聽埠
    2. 接收客戶端請求建立連結
    3. 建立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可執行檔案。

3. TCP客戶端

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

    1. 建立與服務端的連結
    2. 進行資料收發
    3. 關閉連結

  • 使用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通訊。

4. TCP黏包

（1）黏包示例

  • 服務端程式碼如下：
// 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次，而是多條資料“粘”到了一起。

（2）為什麼會出現粘包

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

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

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

（3）解決辦法

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

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

  • 我們可以自己定義一個協議，比如資料包的前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通訊

1. UDP協議

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

2. 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
		}
	}
}

3. 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)
}

相關文章