引言

現(xiàn)在我們幾乎每天都在使用互聯(lián)網(wǎng)，我們前面已經(jīng)學(xué)習(xí)了如何編寫Go語言程序，但是如何才能讓我們的程序通過網(wǎng)絡(luò)互相通信呢？本章我們就一起來學(xué)習(xí)下Go語言中的網(wǎng)絡(luò)編程， 關(guān)于網(wǎng)絡(luò)編程其實是一個很龐大的領(lǐng)域，本文簡單演示如何使用net包進(jìn)行TCP和UDP通信，如需了解更詳細(xì)的網(wǎng)絡(luò)編程請自行檢索和閱讀專業(yè)資料。

互聯(lián)網(wǎng)協(xié)議介紹

互聯(lián)網(wǎng)的核心是一系列協(xié)議，總稱為”互聯(lián)網(wǎng)協(xié)議”（Internet Protocol Suite），正是這一些協(xié)議規(guī)定了電腦如何連接和組網(wǎng)。我們理解了這些協(xié)議，就理解了互聯(lián)網(wǎng)的原理。由于這些協(xié)議太過龐大和復(fù)雜，沒有辦法在這里一概而全，只能介紹一下我們?nèi)粘ｉ_發(fā)中接觸較多的幾個協(xié)議。

互聯(lián)網(wǎng)分層模型

互聯(lián)網(wǎng)的邏輯實現(xiàn)被分為好幾層。每一層都有自己的功能，就像建筑物一樣，每一層都靠下一層支持。用戶接觸到的只是最上面的那一層，根本不會感覺到下面的幾層。要理解互聯(lián)網(wǎng)就需要自下而上理解每一層的實現(xiàn)的功能。

如上圖所示，互聯(lián)網(wǎng)按照不同的模型劃分會有不用的分層，但是不論按照什么模型去劃分，越往上的層越靠近用戶，越往下的層越靠近硬件。在軟件開發(fā)中我們使用最多的是上圖中將互聯(lián)網(wǎng)劃分為五個分層的模型。

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

物理層

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

數(shù)據(jù)鏈路層

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

以太網(wǎng)規(guī)定，一組電信號構(gòu)成一個數(shù)據(jù)包，叫做”幀”（Frame）。每一幀分成兩個部分：標(biāo)頭（Head）和數(shù)據(jù)（Data）。其中”標(biāo)頭”包含數(shù)據(jù)包的一些說明項，比如發(fā)送者、接受者、數(shù)據(jù)類型等等；”數(shù)據(jù)”則是數(shù)據(jù)包的具體內(nèi)容。”標(biāo)頭”的長度，固定為18字節(jié)。”數(shù)據(jù)”的長度，最短為46字節(jié)，最長為1500字節(jié)。因此，整個”幀”最短為64字節(jié)，最長為1518字節(jié)。如果數(shù)據(jù)很長，就必須分割成多個幀進(jìn)行發(fā)送。

那么，發(fā)送者和接受者是如何標(biāo)識呢？以太網(wǎng)規(guī)定，連入網(wǎng)絡(luò)的所有設(shè)備都必須具有”網(wǎng)卡”接口。數(shù)據(jù)包必須是從一塊網(wǎng)卡，傳送到另一塊網(wǎng)卡。網(wǎng)卡的地址，就是數(shù)據(jù)包的發(fā)送地址和接收地址，這叫做MAC地址。每塊網(wǎng)卡出廠的時候，都有一個全世界獨一無二的MAC地址，長度是48個二進(jìn)制位，通常用12個十六進(jìn)制數(shù)表示。前6個十六進(jìn)制數(shù)是廠商編號，后6個是該廠商的網(wǎng)卡流水號。有了MAC地址，就可以定位網(wǎng)卡和數(shù)據(jù)包的路徑了。

我們會通過ARP協(xié)議來獲取接受方的MAC地址，有了MAC地址之后，如何把數(shù)據(jù)準(zhǔn)確的發(fā)送給接收方呢？其實這里以太網(wǎng)采用了一種很”原始”的方式，它不是把數(shù)據(jù)包準(zhǔn)確送到接收方，而是向本網(wǎng)絡(luò)內(nèi)所有計算機(jī)都發(fā)送，讓每臺計算機(jī)讀取這個包的”標(biāo)頭”，找到接收方的MAC地址，然后與自身的MAC地址相比較，如果兩者相同，就接受這個包，做進(jìn)一步處理，否則就丟棄這個包。這種發(fā)送方式就叫做”廣播”（broadcasting）。

網(wǎng)絡(luò)層

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

因此，必須找到一種方法區(qū)分哪些MAC地址屬于同一個子網(wǎng)絡(luò)，哪些不是。如果是同一個子網(wǎng)絡(luò)，就采用廣播方式發(fā)送，否則就采用”路由”方式發(fā)送。這就導(dǎo)致了”網(wǎng)絡(luò)層”的誕生。它的作用是引進(jìn)一套新的地址，使得我們能夠區(qū)分不同的計算機(jī)是否屬于同一個子網(wǎng)絡(luò)。這套地址就叫做”網(wǎng)絡(luò)地址”，簡稱”網(wǎng)址”。

“網(wǎng)絡(luò)層”出現(xiàn)以后，每臺計算機(jī)有了兩種地址，一種是MAC地址，另一種是網(wǎng)絡(luò)地址。兩種地址之間沒有任何聯(lián)系，MAC地址是綁定在網(wǎng)卡上的，網(wǎng)絡(luò)地址則是網(wǎng)絡(luò)管理員分配的。網(wǎng)絡(luò)地址幫助我們確定計算機(jī)所在的子網(wǎng)絡(luò)，MAC地址則將數(shù)據(jù)包送到該子網(wǎng)絡(luò)中的目標(biāo)網(wǎng)卡。因此，從邏輯上可以推斷，必定是先處理網(wǎng)絡(luò)地址，然后再處理MAC地址。

規(guī)定網(wǎng)絡(luò)地址的協(xié)議，叫做IP協(xié)議。它所定義的地址，就被稱為IP地址。目前，廣泛采用的是IP協(xié)議第四版，簡稱IPv4。IPv4這個版本規(guī)定，網(wǎng)絡(luò)地址由32個二進(jìn)制位組成，我們通常習(xí)慣用分成四段的十進(jìn)制數(shù)表示IP地址，從0.0.0.0一直到255.255.255.255。

根據(jù)IP協(xié)議發(fā)送的數(shù)據(jù)，就叫做IP數(shù)據(jù)包。IP數(shù)據(jù)包也分為”標(biāo)頭”和”數(shù)據(jù)”兩個部分：”標(biāo)頭”部分主要包括版本、長度、IP地址等信息，”數(shù)據(jù)”部分則是IP數(shù)據(jù)包的具體內(nèi)容。IP數(shù)據(jù)包的”標(biāo)頭”部分的長度為20到60字節(jié)，整個數(shù)據(jù)包的總長度最大為65535字節(jié)。

傳輸層

有了MAC地址和IP地址，我們已經(jīng)可以在互聯(lián)網(wǎng)上任意兩臺主機(jī)上建立通信。但問題是同一臺主機(jī)上會有許多程序都需要用網(wǎng)絡(luò)收發(fā)數(shù)據(jù)，比如QQ和瀏覽器這兩個程序都需要連接互聯(lián)網(wǎng)并收發(fā)數(shù)據(jù)，我們?nèi)绾螀^(qū)分某個數(shù)據(jù)包到底是歸哪個程序的呢？也就是說，我們還需要一個參數(shù)，表示這個數(shù)據(jù)包到底供哪個程序（進(jìn)程）使用。這個參數(shù)就叫做”端口”（port），它其實是每一個使用網(wǎng)卡的程序的編號。每個數(shù)據(jù)包都發(fā)到主機(jī)的特定端口，所以不同的程序就能取到自己所需要的數(shù)據(jù)。

“端口”是0到65535之間的一個整數(shù)，正好16個二進(jìn)制位。0到1023的端口被系統(tǒng)占用，用戶只能選用大于1023的端口。有了IP和端口我們就能實現(xiàn)唯一確定互聯(lián)網(wǎng)上一個程序，進(jìn)而實現(xiàn)網(wǎng)絡(luò)間的程序通信。

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

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

應(yīng)用層

應(yīng)用程序收到”傳輸層”的數(shù)據(jù)，接下來就要對數(shù)據(jù)進(jìn)行解包。由于互聯(lián)網(wǎng)是開放架構(gòu)，數(shù)據(jù)來源五花八門，必須事先規(guī)定好通信的數(shù)據(jù)格式，否則接收方根本無法獲得真正發(fā)送的數(shù)據(jù)內(nèi)容。”應(yīng)用層”的作用就是規(guī)定應(yīng)用程序使用的數(shù)據(jù)格式，例如我們TCP協(xié)議之上常見的Email、HTTP、FTP等協(xié)議，這些協(xié)議就組成了互聯(lián)網(wǎng)協(xié)議的應(yīng)用層。

如下圖所示，發(fā)送方的HTTP數(shù)據(jù)經(jīng)過互聯(lián)網(wǎng)的傳輸過程中會依次添加各層協(xié)議的標(biāo)頭信息，接收方收到數(shù)據(jù)包之后再依次根據(jù)協(xié)議解包得到數(shù)據(jù)。

socket編程

Socket是BSD UNIX的進(jìn)程通信機(jī)制，通常也稱作”套接字”，用于描述IP地址和端口，是一個通信鏈的句柄。Socket可以理解為TCP/IP網(wǎng)絡(luò)的API，它定義了許多函數(shù)或例程，程序員可以用它們來開發(fā)TCP/IP網(wǎng)絡(luò)上的應(yīng)用程序。電腦上運行的應(yīng)用程序通常通過”套接字”向網(wǎng)絡(luò)發(fā)出請求或者應(yīng)答網(wǎng)絡(luò)請求。

socket圖解

Socket是應(yīng)用層與TCP/IP協(xié)議族通信的中間軟件抽象層。在設(shè)計模式中，Socket其實就是一個門面模式，它把復(fù)雜的TCP/IP協(xié)議族隱藏在Socket后面，對用戶來說只需要調(diào)用Socket規(guī)定的相關(guān)函數(shù)，讓Socket去組織符合指定的協(xié)議數(shù)據(jù)然后進(jìn)行通信。

Go語言實現(xiàn)TCP通信

TCP協(xié)議

TCP/IP(Transmission Control Protocol/Internet Protocol) 即傳輸控制協(xié)議/網(wǎng)間協(xié)議，是一種面向連接（連接導(dǎo)向）的、可靠的、基于字節(jié)流的傳輸層（Transport layer）通信協(xié)議，因為是面向連接的協(xié)議，數(shù)據(jù)像水流一樣傳輸，會存在黏包問題。

TCP服務(wù)端

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

TCP服務(wù)端程序的處理流程：

• 監(jiān)聽端口
• 接收客戶端請求建立鏈接
• 創(chuàng)建goroutine處理鏈接。

我們使用Go語言的net包實現(xiàn)的TCP服務(wù)端代碼如下：

// tcp/server/main.go
// TCP server端
// 處理函數(shù)
func process(conn net.Conn) {
	defer conn.Close() // 關(guān)閉連接
	for {
		reader := bufio.NewReader(conn)
		var buf [128]byte
		n, err := reader.Read(buf[:]) // 讀取數(shù)據(jù)
		if err != nil {
			fmt.Println("read from client failed, err:", err)
			break
		}
		recvStr := string(buf[:n])
		fmt.Println("收到client端發(fā)來的數(shù)據(jù)：", recvStr)
		conn.Write([]byte(recvStr)) // 發(fā)送數(shù)據(jù)
	}
}
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可執(zhí)行文件。

TCP客戶端

一個TCP客戶端進(jìn)行TCP通信的流程如下：

• 建立與服務(wù)端的鏈接
• 進(jìn)行數(shù)據(jù)收發(fā)
• 關(guān)閉鏈接

使用Go語言的net包實現(xiàn)的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() // 關(guān)閉連接
	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)) // 發(fā)送數(shù)據(jù)
		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可執(zhí)行文件，先啟動server端再啟動client端，在client端輸入任意內(nèi)容回車之后就能夠在server端看到client端發(fā)送的數(shù)據(jù)，從而實現(xiàn)TCP通信。

TCP黏包

黏包示例

服務(wù)端代碼如下：

// 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發(fā)來的數(shù)據(jù)：", 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))
	}
}

將上面的代碼保存后，分別編譯。先啟動服務(wù)端再啟動客戶端，可以看到服務(wù)端輸出結(jié)果如下：

收到client發(fā)來的數(shù)據(jù)： 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發(fā)來的數(shù)據(jù)： 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發(fā)來的數(shù)據(jù)： Hello, Hello. How are you?Hello, Hello. How are you?
收到client發(fā)來的數(shù)據(jù)： Hello, Hello. How are you?Hello, Hello. How are you?Hello, Hello. How are you?
收到client發(fā)來的數(shù)據(jù)： Hello, Hello. How are you?Hello, Hello. How are you?

客戶端分10次發(fā)送的數(shù)據(jù)，在服務(wù)端并沒有成功的輸出10次，而是多條數(shù)據(jù)“粘”到了一起。

為什么會出現(xiàn)粘包

主要原因就是tcp數(shù)據(jù)傳遞模式是流模式，在保持長連接的時候可以進(jìn)行多次的收和發(fā)。

“粘包”可發(fā)生在發(fā)送端也可發(fā)生在接收端：

• 由Nagle算法造成的發(fā)送端的粘包：Nagle算法是一種改善網(wǎng)絡(luò)傳輸效率的算法。簡單來說就是當(dāng)我們提交一段數(shù)據(jù)給TCP發(fā)送時，TCP并不立刻發(fā)送此段數(shù)據(jù)，而是等待一小段時間看看在等待期間是否還有要發(fā)送的數(shù)據(jù)，若有則會一次把這兩段數(shù)據(jù)發(fā)送出去。
• 接收端接收不及時造成的接收端粘包：TCP會把接收到的數(shù)據(jù)存在自己的緩沖區(qū)中，然后通知應(yīng)用層取數(shù)據(jù)。當(dāng)應(yīng)用層由于某些原因不能及時的把TCP的數(shù)據(jù)取出來，就會造成TCP緩沖區(qū)中存放了幾段數(shù)據(jù)。

解決辦法

出現(xiàn)”粘包”的關(guān)鍵在于接收方不確定將要傳輸?shù)臄?shù)據(jù)包的大小，因此我們可以對數(shù)據(jù)包進(jìn)行封包和拆包的操作。

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

我們可以自己定義一個協(xié)議，比如數(shù)據(jù)包的前4個字節(jié)為包頭，里面存儲的是發(fā)送的數(shù)據(jù)的長度。

// socket_stick/proto/proto.go
package proto
import (
	"bufio"
	"bytes"
	"encoding/binary"
)
// Encode 將消息編碼
func Encode(message string) ([]byte, error) {
	// 讀取消息的長度，轉(zhuǎn)換成int32類型（占4個字節(jié)）
	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個字節(jié)的數(shù)據(jù)
	lengthBuff := bytes.NewBuffer(lengthByte)
	var length int32
	err := binary.Read(lengthBuff, binary.LittleEndian, &length)
	if err != nil {
		return "", err
	}
	// Buffered返回緩沖中現(xiàn)有的可讀取的字節(jié)數(shù)。
	if int32(reader.Buffered()) < length+4 {
		return "", err
	}
	// 讀取真正的消息數(shù)據(jù)
	pack := make([]byte, int(4+length))
	_, err = reader.Read(pack)
	if err != nil {
		return "", err
	}
	return string(pack[4:]), nil
}

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

服務(wù)端代碼如下：

// 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發(fā)來的數(shù)據(jù)：", 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語言實現(xiàn)UDP通信

UDP協(xié)議

UDP協(xié)議（User Datagram Protocol）中文名稱是用戶數(shù)據(jù)報協(xié)議，是OSI（Open System Interconnection，開放式系統(tǒng)互聯(lián)）參考模型中一種無連接的傳輸層協(xié)議，不需要建立連接就能直接進(jìn)行數(shù)據(jù)發(fā)送和接收，屬于不可靠的、沒有時序的通信，但是UDP協(xié)議的實時性比較好，通常用于視頻直播相關(guān)領(lǐng)域。

UDP服務(wù)端

使用Go語言的net包實現(xiàn)的UDP服務(wù)端代碼如下：

// 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[:]) // 接收數(shù)據(jù)
		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) // 發(fā)送數(shù)據(jù)
		if err != nil {
			fmt.Println("write to udp failed, err:", err)
			continue
		}
	}
}

UDP客戶端

使用Go語言的net包實現(xiàn)的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("連接服務(wù)端失敗，err:", err)
		return
	}
	defer socket.Close()
	sendData := []byte("Hello server")
	_, err = socket.Write(sendData) // 發(fā)送數(shù)據(jù)
	if err != nil {
		fmt.Println("發(fā)送數(shù)據(jù)失敗，err:", err)
		return
	}
	data := make([]byte, 4096)
	n, remoteAddr, err := socket.ReadFromUDP(data) // 接收數(shù)據(jù)
	if err != nil {
		fmt.Println("接收數(shù)據(jù)失敗，err:", err)
		return
	}
	fmt.Printf("recv:%v addr:%v count:%v\n", string(data[:n]), remoteAddr, n)
}

以上就是Go語言基礎(chǔ)之網(wǎng)絡(luò)編程全面教程示例的詳細(xì)內(nèi)容，更多關(guān)于Go語言網(wǎng)絡(luò)編程的資料請關(guān)注腳本之家其它相關(guān)文章！

最新評論