現在我們幾乎每天都在使用互聯網，我們前面已經學習了如何撰寫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)
}

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/43074.html

標籤：Go

上一篇：Go語言基礎之單元測驗

下一篇：Go語言基礎之并發

Go語言基礎之網路編程