Go語言基礎之網絡編程

時間  2020-02-11
標籤 語言 基礎 網絡 編程 欄目 系統網絡 简体版
原文   原文鏈接

如今咱們幾乎天天都在使用互聯網，咱們前面已經學習瞭如何編寫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地址，就能夠定位網卡和數據包的路徑了。socket

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

網絡層

按照以太網協議的規則咱們能夠依靠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服務端程序的處理流程：

  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可執行文件。

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通訊。

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數據傳遞模式是流模式，在保持長鏈接的時候能夠進行屢次的收和發。

「粘包」可發生在發送端也可發生在接收端：

  1. 由Nagle算法形成的發送端的粘包：Nagle算法是一種改善網絡傳輸效率的算法。簡單來講就是當咱們提交一段數據給TCP發送時，TCP並不馬上發送此段數據，而是等待一小段時間看看在等待期間是否還有要發送的數據，如有則會一次把這兩段數據發送出去。
  2. 接收端接收不及時形成的接收端粘包：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)
}

 

轉載自李文周博客

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程