主頁 > 後端開發 > Go網路編程

Go網路編程

2020-09-16 00:44:34 後端開發

目錄

  • 概述
    • 網路協議
    • 典型協議
    • 分層模型
      • 網路分層架構
      • 層與協議
      • 協議功能
        • 鏈路層
        • 網路層
        • 傳輸層
        • 應用層
    • 通信程序
  • Socket編程
    • 什么是Socket
    • 網路應用程式設計模式
      • C/S模式
      • B/S模式
      • 優缺點
    • TCP的C/S架構
    • 簡單的C/S模型通信
      • Server端
      • Client端
    • 并發的C/S模型通信
      • 并發Server
      • 并發Client
    • TCP通信
      • 三次握手
      • 四次揮手
    • UDP通信
      • UDP服務器
      • UDP客戶端
      • 并發
      • UDP與TCP的差異

概述

網路協議

從應用的角度出發，協議可理解為“規則”，是資料傳輸和資料的解釋的規則，假設，A、B雙方欲傳輸檔案，規定：

  • 第一次，傳輸檔案名，接收方接收到檔案名，應答OK給傳輸方；
  • 第二次，發送檔案的尺寸，接收方接收到該資料再次應答一個OK；
  • 第三次，傳輸檔案內容，同樣，接收方接收資料完成后應答OK表示檔案內容接收成功，

由此，無論A、B之間傳遞何種檔案，都是通過三次資料傳輸來完成，A、B之間形成了一個最簡單的資料傳輸規則，雙方都按此規則發送、接收資料，A、B之間達成的這個相互遵守的規則即為協議，

這種僅在A、B之間被遵守的協議稱之為原始協議，

當此協議被更多的人采用，不斷的增加、改進、維護、完善，最終形成一個穩定的、完整的檔案傳輸協議，被廣泛應用于各種檔案傳輸程序中，該協議就成為一個標準協議，最早的ftp協議就是由此衍生而來，

典型協議

應用層: 常見的協議有HTTP協議，FTP協議，

傳輸層: 常見協議有TCP/UDP協議，

網路層: 常見協議有IP協議、ICMP協議、IGMP協議，

網路介面層: 常見協議有ARP協議、RARP協議，

各個協議用途簡述:

IP協議是因特網互聯協議（Internet Protocol）

TCP傳輸控制協議（Transmission Control Protocol）是一種面向連接的、可靠的、基于位元組流的傳輸層通信協議，

UDP用戶資料報協議（User Datagram Protocol）是OSI參考模型中一種無連接的傳輸層協議，提供面向事務的簡單不可靠資訊傳送服務，

ICMP協議是Internet控制報文協議（Internet Control Message Protocol）它是TCP/IP協議族的一個子協議，用于在IP主機、路由器之間傳遞控制訊息，

IGMP協議是 Internet 組管理協議（Internet Group Management Protocol），是因特網協議家族中的一個組播協議，該協議運行在主機和組播路由器之間，

ARP協議是正向地址決議協議（Address Resolution Protocol），通過已知的IP，尋找對應主機的MAC地址，

RARP是反向地址轉換協議，通過MAC地址確定IP地址，

分層模型

網路分層架構

為了減少協議設計的復雜性，大多數網路模型均采用分層的方式來組織，每一層都有自己的功能，就像建筑物一樣，每一層都靠下一層支持，每一層利用下一層提供的服務來為上一層提供服務，本層服務的實作細節對上層屏蔽，

造車比喻(協議分層)

減少復雜度，解耦

越下面的層，越靠近硬體；越上面的層，越靠近用戶，至于每一層叫什么名字，對應編程而言不重要，但面試的時候，面試官可能會問每一層的名字，

業內普遍的分層方式有兩種，OSI七層模型 和TCP/IP四層模型，可以通過背誦兩個口訣來快速記憶：

OSI七層模型: 應、表、會、傳、網、數、物

TCP/IP四層模型: 應、傳、網、鏈

物理層: 主要定義物理設備標準，如網線的介面型別、光纖的介面型別、各種傳輸介質的傳輸速率等，它的主要作用是傳輸位元流（就是由1、0轉化為電流強弱來進行傳輸，到達目的地后再轉化為1、0，也就是我們常說的數模轉換與模數轉換），這一層的資料叫做位元，

資料鏈路層： 定義了如何讓格式化資料以幀為單位進行傳輸，以及如何讓控制對物理介質的訪問，這一層通常還提供錯誤檢測和糾正，以確保資料的可靠傳輸，如：串口通信中使用到的115200、8、N、1

網路層: 在位于不同地理位置的網路中的兩個主機系統之間提供連接和路徑選擇，Internet的發展使得從世界各站點訪問資訊的用戶數大大增加，而網路層正是管理這種連接的層，

傳輸層: 定義了一些傳輸資料的協議和埠號（WWW埠80等），如：TCP（傳輸控制協議，傳輸效率低，可靠性強，用于傳輸可靠性要求高，資料量大的資料），UDP（用戶資料報協議，與TCP特性恰恰相反，用于傳輸可靠性要求不高，資料量小的資料，如QQ聊天資料就是通過這種方式傳輸的）， 主要是將從下層接收的資料進行分段和傳輸，到達目的地址后再進行重組，常常把這一層資料叫欄位，

會話層: 通過傳輸層(埠號：傳輸埠與接收埠)建立資料傳輸的通路，主要在你的系統之間發起會話或者接受會話請求（設備之間需要互相認識可以是IP也可以是MAC或者是主機名），

應用層: 是最靠近用戶的OSI層，這一層為用戶的應用程式（例如電子郵件、檔案傳輸和終端仿真）提供網路服務，

層與協議

每一層都是為了完成一種功能，為了實作這些功能，就需要大家都遵守共同的規則，大家都遵守這規則，就叫做“協議”（protocol），

網路的每一層，都定義了很多協議，這些協議的總稱，叫“TCP/IP協議”，TCP/IP協議是一個大家族，不僅僅只有TCP和IP協議，它還包括其它的協議，如下圖：

協議功能

鏈路層

以太網規定，連入網路的所有設備，都必須具有“網卡”介面，資料包必須是從一塊網卡，傳送到另一塊網卡，通過網卡能夠使不同的計算機之間連接，從而完成資料通信等功能，網卡的地址——MAC 地址，就是資料包的物理發送地址和物理接收地址，

網卡對應到協議里面就是與鏈路層ARP協議相關的

每個網卡有自己唯一的Mac地址

ARP可以幫助借助IP獲取Mac地址

RARP可以借助Mac地址獲取IP，

網路層

網路層的作用是引進一套新的地址，使得我們能夠區分不同的計算機是否屬于同一個子網路，這套地址就叫做“網路地址”，這是我們平時所說的IP地址，這個IP地址好比我們的手機號碼，通過手機號碼可以得到用戶所在的歸屬地，

網路地址幫助我們確定計算機所在的子網路，MAC 地址則將資料包送到該子網路中的目標網卡，網路層協議包含的主要資訊是源IP和目的IP，

于是，“網路層”出現以后，每臺計算機有了兩種地址，一種是 MAC 地址，另一種是網路地址，兩種地址之間沒有任何聯系，MAC 地址是系結在網卡上的，網路地址則是管理員分配的，它們只是隨機組合在一起，

網路地址幫助我們確定計算機所在的子網路，MAC 地址則將資料包送到該子網路中的目標網卡，因此，從邏輯上可以推斷，必定是先處理網路地址，然后再處理 MAC 地址，

IP地址本質:2進制數，----點分十進制IP地址（string)

傳輸層

當我們一邊聊QQ，一邊聊微信，當一個資料包從互聯網上發來的時候，我們怎么知道，它是來自QQ的內容，還是來自微信的內容？

也就是說，我們還需要一個引數，表示這個資料包到底供哪個程式（行程）使用，這個引數就叫做“埠”（port），它其實是每一個使用網卡的程式的編號，每個資料包都發到主機的特定埠，所以不同的程式就能取到自己所需要的資料，

埠就是在傳輸層指定的，

port -- 在一臺主機上唯一標識一個行程

埠特點:

  • 對于同一個埠，在不同系統中對應著不同的行程
  • 對于同一個系統，一個埠只能被一個行程擁有

常用協議:TCP、UDP

應用層

應用程式收到“傳輸層”的資料，接下來就要進行解讀，由于互聯網是開放架構，資料來源五花八門，必須事先規定好格式，否則根本無法解讀，“應用層”的作用，就是規定應用程式的資料格式，

FTP、HTTP、或自定義協議
對資料進行封裝、解封裝

通信程序

資料通信程序

封裝: 應用層 ----------------- 傳輸層 ---------------- 網路層 ----------- 鏈路層

解封裝: 鏈路層 ------------- 網路層 ------------- 傳輸層 ------------ 應用層

Socket編程

什么是Socket

Socket，英文含義是【插座、插孔】，一般稱之為套接字，用于描述IP地址和埠，可以實作不同程式間的資料通信，

Socket起源于Unix，而Unix基本哲學之一就是“一切皆檔案”，都可以用“打開open –> 讀寫write/read –> 關閉close”模式來操作，Socket就是該模式的一個實作，網路的Socket資料傳輸是一種特殊的I/O，Socket也是一種檔案描述符，Socket也具有一個類似于打開檔案的函式呼叫：Socket()，該函式回傳一個整型的Socket描述符，隨后的連接建立、資料傳輸等操作都是通過該Socket實作的，

套接字的內核實作較為復雜，不宜在學習初期深入學習，了解到如下結構足矣，

在TCP/IP協議中，“IP地址+TCP或UDP埠號”唯一標識網路通訊中的一個行程，“IP地址+埠號”就對應一個socket，欲建立連接的兩個行程各自有一個socket來標識，那么這兩個socket組成的socket pair就唯一標識一個連接，因此可以用Socket來描述網路連接的一對一關系，

常用的Socket型別有兩種：流式Socket（SOCK_STREAM）和資料報式Socket（SOCK_DGRAM），流式是一種面向連接的Socket，針對于面向連接的TCP服務應用；資料報式Socket是一種無連接的Socket，對應于無連接的UDP服務應用，

Socket是典型的雙向全雙工

網路應用程式設計模式

C/S模式

傳統的網路應用設計模式，客戶機(client)/服務器(server)模式，需要在通訊兩端各自部署客戶機和服務器來完成資料通信，

B/S模式

瀏覽器(Browser)/服務器(Server)模式，只需在一端部署服務器，而另外一端使用每臺PC都默認配置的瀏覽器即可完成資料的傳輸，

優缺點

對于C/S模式來說，其優點明顯，客戶端位于目標主機上可以保證性能，將資料快取至客戶端本地，從而提高資料傳輸效率，且，一般來說客戶端和服務器程式由一個開發團隊創作，所以他們之間所采用的協議相對靈活，可以在標準協議的基礎上根據需求裁剪及定制，例如，騰訊所采用的通信協議，即為ftp協議的修改剪裁版，

? 因此，傳統的網路應用程式及較大型的網路應用程式都首選C/S模式進行開發，如，知名的網路游戲魔獸世界，3D畫面，資料量龐大，使用C/S模式可以提前在本地進行大量資料的快取處理，從而提高觀感，

? C/S模式的缺點也較突出，由于客戶端和服務器都需要有一個開發團隊來完成開發，作業量將成倍提升，開發周期較長，另外，從用戶角度出發，需要將客戶端安插至用戶主機上，對用戶主機的安全性構成威脅，這也是很多用戶不愿使用C/S模式應用程式的重要原因，

? B/S模式相比C/S模式而言，由于它沒有獨立的客戶端，使用標準瀏覽器作為客戶端，其作業開發量較小，只需開發服務器端即可，另外由于其采用瀏覽器顯示資料，因此移植性非常好，不受平臺限制，如早期的偷菜游戲，在各個平臺上都可以完美運行，

? B/S模式的缺點也較明顯，由于使用第三方瀏覽器，因此網路應用支持受限，另外，沒有客戶端放到對方主機上，快取資料不盡如人意，從而傳輸資料量受到限制，應用的觀感大打折扣，第三，必須與瀏覽器一樣，采用標準http協議進行通信，協議選擇不靈活，

? 因此在開發程序中，模式的選擇由上述各自的特點決定，根據實際需求選擇應用程式設計模式，

TCP的C/S架構

服務器首先啟動一個net.Listen()，這個net.Listen()從名字上看好像是啟動一個監聽，實際上這是由于套接字socket最早期設計的原因，在Go語言設計的時候還是沿用了Unix當初設計的思想，直接把函式名拿過來了，這個函式初學的同學都會有一個誤解，認為它是監聽，實際上它不是，這個listen()函式不是真正的監聽客戶端，要監聽的話監聽什么？要監聽客戶端和我的連接，但是這個Listen不是監聽客戶端，而是我設定服務器監聽的資源(IP、埠)，Accept()才是真正監聽的，那言外之意，監聽嘛，我等著你對我進行訪問吧，那就是說，你沒訪問我之前是不是應該一直處于等待狀態，一會兒我們寫程式看一下，是在Listen()的時候等著還是在Accept的時候等著，所以Accept是表示接受的意思，當它Accpet呼叫起來以后，它就等著客戶端和我建立連接，比方說，圖示上已經說了，它會阻塞等待用戶建立連接，那言外之意，我沒有用戶建立連接之前它就一直阻塞在那里等待著，實際上監聽是在Accept的時候才發起的，當然Accept不是無源之水，它必要Listen設定好了連接方式(tcp還是udp)、IP地址以及埠以后才能阻塞去監聽，當有一個客戶端和服務器發起請求之后，我調Accept()函式完成了，那就說明我服務器和客戶端之間的連接建立好了，接來下干什么呢？進行資料傳輸，我建立好連接的目的就是為了進行資料傳遞，我們這里假定那一般實際上也是這樣，客戶端主動找服務器建立連接，連接建立好了，客戶端先發送資料給服務器，服務器被動的接受客戶端發來的請求，被動接受客戶端請求資料，接受到了請求以后，服務器進行相應的分析處理，處理完以后把你要請求的資料回寫回去，服務端Read()是讀取客戶端發送過來的請求，Write()是我把你的請求處理完之后再給你寫回去，當這些都做完了，說明我們跟客戶端的一次通信就完成了，那這個時候我們就可以關閉連接，當然如果你還想后續繼續通信的話，這個close()關閉就要延遲，

客戶端這個流程很簡單，因為服務器先要站出來在那兒等著客戶端和我建立連接，所以說，服務器就得先啟動，客戶端相當于是我得等你服務器啟動起來以后你都準備好了，我在給你發送訪問請求，客戶端發送訪問請求，也是呼叫一個函式，叫做net.Dail()函式，這個Dail()函式會對阻塞的Accept()發送一個請求，如果服務器準備好，Accept()回傳的時候，Dail也回傳，咱們就說客戶端和服務器建立好了連接，客戶端先發送資料，所以客戶端先是一個寫操作，發送完資料，服務器那邊讀到客戶端請求進行處理，處理完之后寫回來，客戶端再Read()讀取服務器寫回來的資料，讀完以后客戶端也可以做簡單處理，比方說我讀到了以后，列印顯示，完成了寫，完成了讀，一次跟網路端的通信也就完成了，客戶端可以關閉連接，大致的流程就是這樣，

前面說過，socket通信，既然要通信，至少得是一對，如上圖所示，Accpet()和Dail()成功后都會回傳一個socket，

其實Listen()的時候也會創建一個socket，但是這個socket不是用于通信的，只是創建用于通信的socket,系結IP地址和埠設定監聽的

簡單的C/S模型通信

Server端

Listen函式:

network: 選用的協議:TCP、UDP 如: "tcp"或"udp"

address：IP地址+埠號 如: "127.0.0.1:8000"或":8000"

Listener介面:

Conn介面:

參看 https://studygolang.com/pkgdoc 中文幫助檔案中的demo：

TCP服務器端代碼:

package main

import (
	"fmt"
	"net"
)

func main() {
	//指定服務器 通信協議,IP地址,port. 創建一個用戶監聽的socket
	listener, err := net.Listen("tcp", "127.0.0.1:8000")
	if err != nil {
		fmt.Printf("服務器設定監聽失敗,原因是:%v\n", err)
		return
	}
	defer listener.Close()

	fmt.Println("服務器等待客戶端建立連接...")
	//阻塞監聽客戶端連接請求,成功建立連接,回傳用于通信的socket
	conn, err := listener.Accept()
	if err != nil {
		fmt.Printf("服務器監聽失敗,原因是:%v\n", err)
	}
	defer conn.Close()

	fmt.Println("服務器與客戶端成功建立連接!!!")
	//讀取客戶端發送的資料
	buf := make([]byte, 1024)
	n, err := conn.Read(buf)
	if err != nil {
		fmt.Printf("Conn Read()錯誤,原因是:%v\n", err)
	}

	//處理資料 -- 列印
	fmt.Println("服務器讀到資料:", string(buf[:n]))
}

運行代碼

利用nc模式客戶端請求

再次查看運行的終端，可以發現已經成功建立了連接

我們用nc連接后，還可以發送資料

再次查看運行的終端

如圖，在整個通信程序中，服務器端有兩個socket參與進來，但用于通信的只有 conn 這個socket，它是由 listener創建的，隸屬于服務器端，

Client端

Dial函式:

network: 選用的協議:TCP、UDP 如: "tcp"或"udp"

address：IP地址+埠號 如: "127.0.0.1:8000"或":8000"

Conn介面:

客戶端代碼:

package main

import (
	"fmt"
	"net"
)

func main() {

	//指定服務器IP+port創建 通信套接字
	conn, err := net.Dial("tcp", "127.0.0.1:8000")
	if err != nil {
		fmt.Printf("net.Dial err:%v\n", err)
		return
	}
	defer conn.Close()

	//主動寫資料給服務器
	_, err = conn.Write([]byte("Are you ready?"))
	if err != nil {
		fmt.Printf("conn.Write err:%v\n", err)
		return
	}

	buf := make([]byte, 1024)
	//接受服務器回發的資料
	n, err := conn.Read(buf)
	if err != nil {
		fmt.Printf("conn.Read err:%v\n", err)
		return
	}

	fmt.Printf("服務器回發的資料為:%v\n", string(buf[:n]))
}

由于我們想要服務器端回寫內容，所以需要修改一下之前的服務端代碼

更新服務器端代碼:

package main

import (
    "fmt"
    "net"
)

func main() {
    //指定服務器 通信協議,IP地址,port. 創建一個用戶監聽的socket
    listener, err := net.Listen("tcp", "127.0.0.1:8000")
    if err != nil {
        fmt.Printf("服務器設定監聽失敗,原因是:%v\n", err)
        return
    }
    defer listener.Close()

    fmt.Println("服務器等待客戶端建立連接...")
    //阻塞監聽客戶端連接請求,成功建立連接,回傳用于通信的socket
    conn, err := listener.Accept()
    if err != nil {
        fmt.Printf("服務器監聽失敗,原因是:%v\n", err)
    }
    defer conn.Close()

    fmt.Println("服務器與客戶端成功建立連接!!!")
    //讀取客戶端發送的資料
    buf := make([]byte, 1024)
    n, err := conn.Read(buf)
    if err != nil {
        fmt.Printf("Conn Read()錯誤,原因是:%v\n", err)
    }

    //處理資料 -- 回寫給客戶端
    if string(buf[:n]) == "Are you ready?" {
        conn.Write([]byte("I am ready!!!"))
    } else {
        conn.Write([]byte("I don`t know what you say!!!"))
    }
}

并發的C/S模型通信

并發Server

現在已經完成了客戶端與服務端的通信，但是服務端只能接收一個用戶發送過來的資料，怎樣接收多個客戶端發送過來的資料，實作一個高效的并發服務器呢？

Accept()函式的作用是等待客戶端的鏈接，如果客戶端沒有鏈接，該方法會阻塞，如果有客戶端鏈接，那么該方法回傳一個Socket負責與客戶端進行通信，所以，每來一個客戶端，該方法就應該回傳一個Socket與其通信，因此，可以使用一個死回圈，將Accept()呼叫程序包裹起來，

需要注意的是，實作并發處理多個客戶端資料的服務器，就需要針對每一個客戶端連接，單獨產生一個Socket，并創建一個單獨的goroutine與之完成通信，

func main() {

    //創建監聽套接字
    listener, err := net.Listen("tcp", "127.0.0.1:8000")
    if err != nil {
        fmt.Printf("net.Listen() err:%v\n", err)
        return
    }
    defer listener.Close()

    //監聽客戶端連接請求
    for {
        fmt.Println("服務器等待客戶端連接...")
        conn, err := listener.Accept()
        if err != nil {
            fmt.Printf("listener.Accept() err:%v\n", err)
            return
        }
        //具體完成服務器和客戶端的資料通信
        go HandleConnect(conn)
    }
}

將客戶端的資料處理作業封裝到HandleConn方法中，需將Accept()回傳的Socket傳遞給該方法，變數conn的型別為：net.Conn，可以使用conn.RemoteAddr()來獲取成功與服務器建立連接的客戶端IP地址和埠號：

客戶端可能持續不斷的發送資料，因此接收資料的程序可以放在for回圈中，服務端也持續不斷的向客戶端回傳處理后的資料，

func HandleConnect(conn net.Conn) {
	defer conn.Close()
	//獲取連接的客戶端 Addr

	addr := conn.RemoteAddr()
	fmt.Println(addr, "客戶端成功連接!")
	//回圈讀取客戶端發送資料
	buf := make([]byte, 1024)
	for {
		//注意，read讀取時，會將命令列里的換行符也給讀取了，在*Unix上換行符是\n,在Windows上時\r\n
		n, err := conn.Read(buf)
		if err != nil {
			if err == io.EOF {
				fmt.Println("客戶端退出了!!!")
				break
			} else {
				fmt.Printf("conn.Read() err:%v\n", err)
				return
			}
		}
		fmt.Printf("服務器讀到資料:%v", string(buf[:n]))
		//小寫轉大寫,回發給客戶端
		conn.Write(bytes.ToUpper(buf[:n]))
	}
}

并發Client

客戶端不僅需要持續的向服務端發送資料，同時也要接收從服務端回傳的資料，因此可將發送和接收放到不同的協程中，

主協程回圈接收服務器回發的資料（該資料應已轉換為大寫），并列印至螢屏；子協程回圈從鍵盤讀取用戶輸入資料，寫給服務器，讀取鍵盤輸入可使用 os.Stdin.Read(str)，定義切片str，將讀到的資料保存至str中，

這樣，客戶端也實作了多任務，

客戶端代碼:

package main

import (
	"fmt"
	"io"
	"net"
	"os"
)

func main() {

	//發起連接請求
	conn, err := net.Dial("tcp", "127.0.0.1:8000")
	if err != nil {
		fmt.Printf("net.Dial() err:%v\n", err)
		return
	}
	defer conn.Close()

	//獲取用戶鍵盤輸入(os.Stdin),并將輸入資料發送給服務器
	go func() {
		str := make([]byte, 1024)
		for {
			n, err := os.Stdin.Read(str)
			if err != nil {
				fmt.Printf("os.Stdin.Read() err:%v\n", err)
				continue
			}
			//寫給服務器,讀多少,寫多少
			conn.Write(str[:n])
		}
	}()

	for {
		buf := make([]byte, 1024)
		n, err := conn.Read(buf)
		if err != nil {
			if err == io.EOF {
				fmt.Println("服務端退出了!!!")
				return
			} else {
				fmt.Printf("conn.Read() err:%v\n", err)
				continue
			}
		}
		fmt.Printf("客戶端讀到服務器回發資料:%s",buf[:n])
	}
}

TCP通信

下圖是一次TCP通訊的時序圖，TCP連接建立斷開，包含大家熟知的三次握手和四次揮手，

在這個例子中，首先客戶端主動發起連接、發送請求，然后服務器端回應請求，然后客戶端主動關閉連接，兩條豎線表示通訊的兩端，從上到下表示時間的先后順序，注意，資料從一端傳到網路的另一端也需要時間，所以圖中的箭頭都是斜的，

三次握手

所謂三次握手（Three-Way Handshake）即建立TCP連接，就是指建立一個TCP連接時，需要客戶端和服務端總共發送3個包以確認連接的建立，好比兩個人在打電話：

Client: "喂，你能聽得到嗎？"

Server: "我聽得到，你聽得到我嗎？"

Client: "我能聽到你，今天balabala..."

建立連接(三次握手)的程序:

  1. 客戶端發送一個帶SYN標志的TCP報文到服務器，這是上圖中三次握手程序中的段1，客戶端發出SYN位表示連接請求，序號是1000，這個序號在網路通訊中用作臨時的地址，每發一個資料位元組，這個序號要加1，這樣在接收端可以根據序號排出資料包的正確順序，也可以發現丟包的情況，
    另外，規定SYN位和FIN位也要占一個序號，這次雖然沒發資料，但是由于發了SYN位，因此下次再發送應該用序號1001，
    mss表示最大段尺寸，如果一個段太大，封裝成幀后超過了鏈路層的最大長度，就必須在IP層分片，為了避免這種情況，客戶端宣告自己的最大段尺寸，建議服務器端發來的段不要超過這個長度，
  2. 服務器端回應客戶端，是三次握手中的第2個報文段，同時帶ACK標志和SYN標志，表示對剛才客戶端SYN的回應；同時又發送SYN給客戶端，詢問客戶端是否準備好進行資料通訊，
    服務器發出段2，也帶有SYN位，同時置ACK位表示確認，確認序號是1001，表示“我接收到序號1000及其以前所有的段，請你下次發送序號為1001的段”，也就是應答了客戶端的連接請求，同時也給客戶端發出一個連接請求，同時宣告最大尺寸為1024，
  3. 客戶必須再次回應服務器端一個ACK報文，這是報文段3，
    客戶端發出段3，對服務器的連接請求進行應答，確認序號是8001，在這個程序中，客戶端和服務器分別給對方發了連接請求，也應答了對方的連接請求，其中服務器的請求和應答在一個段中發出，

因此一共有三個段用于建立連接，稱為“三方握手”，在建立連接的同時，雙方協商了一些資訊，例如，雙方發送序號的初始值、最大段尺寸等，

資料傳輸的程序:

  1. 客戶端發出段4，包含從序號1001開始的20個位元組資料，
  2. 服務器發出段5，確認序號為1021，對序號為1001-1020的資料表示確認收到，同時請求發送序號1021開始的資料，服務器在應答的同時也向客戶端發送從序號8001開始的10個位元組資料，
  3. 客戶端發出段6，對服務器發來的序號為8001-8010的資料表示確認收到，請求發送序號8011開始的資料，

在資料傳輸程序中，ACK和確認序號是非常重要的，應用程式交給TCP協議發送的資料會暫存在TCP層的發送緩沖區中，發出資料包給對方之后，只有收到對方應答的ACK段才知道該資料包確實發到了對方，可以從發送緩沖區中釋放掉了，如果因為網路故障丟失了資料包或者丟失了對方發回的ACK段，經過等待超時后TCP協議自動將發送緩沖區中的資料包重發，

四次揮手

所謂四次揮手（Four-Way-Wavehand）即終止TCP連接，就是指斷開一個TCP連接時，需要客戶端和服務端總共發送4個包以確認連接的斷開，在socket編程中，這一程序由客戶端或服務器任一方執行close來觸發，好比兩個人打完電話要掛斷：

Client: "我要說的事情都說完了，我沒事了，掛啦？"

Server: "等下，我還有一個事兒，Balabala…"

Server: "好了，我沒事兒了，掛了啊，"

Client: "ok！拜拜"

關閉連接(四次握手)的程序:

由于TCP連接是全雙工的，因此每個方向都必須單獨進行關閉，這原則是當一方完成它的資料發送任務后就能發送一個FIN來終止這個方向的連接，收到一個 FIN只意味著這一方向上沒有資料流動，一個TCP連接在收到一個FIN后仍能發送資料，首先進行關閉的一方將執行主動關閉，而另一方執行被動關閉，

  1. 客戶端發出段7，FIN位表示關閉連接的請求，
  2. 服務器發出段8，應答客戶端的關閉連接請求，
  3. 服務器發出段9，其中也包含FIN位，向客戶端發送關閉連接請求，
  4. 客戶端發出段10，應答服務器的關閉連接請求，

建立連接的程序是三次握手，而關閉連接通常需要4個段，服務器的應答和關閉連接請求通常不合并在一個段中，因為有連接半關閉的情況，這種情況下客戶端關閉連接之后就不能再發送資料給服務器了，但是服務器還可以發送資料給客戶端，直到服務器也關閉連接為止，

下圖是TCP狀態轉換圖

UDP通信

在之前的案例中，我們一直使用的是TCP協議來撰寫Socket的客戶端與服務端，其實也可以使用UDP協議來撰寫Socket的客戶端與服務端，

UDP服務器

由于UDP是“無連接”的，所以，服務器端不需要額外創建監聽套接字，只需要指定好IP和port，然后監聽該地址，等待客戶端與之建立連接，即可通信，

  1. 創建監聽地址

    func ResolveUDPAddr(network, address string) (*UDPAddr, error)

    ResolveUDPAddr將addr作為UDP地址決議并回傳，引數addr格式為"host:port"或"[ipv6-host%zone]:port"，決議得到網路名和埠名；net必須是"udp"、"udp4"或"udp6"，
    IPv6地址字面值/名稱必須用方括號包起來，如"[::1]:80"、"[ipv6-host]:http"或"[ipv6-host%zone]:80"，

  2. 創建用于通信的socket

    func ListenUDP(network string, laddr *UDPAddr) (*UDPConn, error)

    ListenUDP創建一個接收目的地是本地地址laddr的UDP資料包的網路連接，net必須是"udp"、"udp4"、"udp6"；如果laddr埠為0，函式將選擇一個當前可用的埠，可以用Listener的Addr方法獲得該埠，回傳的*UDPConn的ReadFrom和WriteTo方法可以用來發送和接收UDP資料包（每個包都可獲得來源地址或設定目標地址），

  3. 接受UDP資料

    func (c *UDPConn) ReadFromUDP(b []byte) (n int, addr *UDPAddr, err error)

    ReadFromUDP從c讀取一個UDP資料包，將有效負載拷貝到b，回傳拷貝位元組數和資料包來源地址，

    ReadFromUDP方法會在超過一個固定的時間點之后超時，并回傳一個錯誤，

  4. 寫出資料到UDP

    func (c *UDPConn) WriteToUDP(b []byte, addr *UDPAddr) (int, error)

    WriteToUDP通過c向地址addr發送一個資料包，b為包的有效負載，回傳寫入的位元組，

    WriteToUDP方法會在超過一個固定的時間點之后超時，并回傳一個錯誤，在面向資料包的連接上，寫入超時是十分罕見的，

服務器端代碼:

package main

import (
    "fmt"
    "net"
)

func main() {

    //0.本應從步驟1開始,但是在寫步驟1的時候發現,步驟1還需要*UDPAddr型別的引數,所以需要先創建一個*DUPAddr
    //組織一個udp地址結構,指定服務器的IP+port
    udpAddr, err := net.ResolveUDPAddr("udp", "127.0.0.1:8000")
    if err != nil {
        fmt.Printf("net.ResolveUDPAddr()函式執行出錯,錯誤為:%v\n", err)
        return
    }
    fmt.Printf("UDP服務器地址結構創建完成!!!\n")

    //1.創建用戶通信的socket
    //由于ListenUDP需要一個*UDPAddr型別的引數,所以我們還需要先創建一個監聽地址
    udpConn, err := net.ListenUDP("udp", udpAddr)
    if err != nil {
        fmt.Printf("net.ListenUDP()函式執行出錯,錯誤為:%v\n", err)
        return
    }
    defer udpConn.Close()
    fmt.Printf("UDP服務器通信socket創建完成!!!\n")

    //2.讀取客戶端發送的資料(阻塞發生在ReadFromUDP()方法中)
    buf := make([]byte, 4096)
    //ReadFromUDP()方法回傳三個值,分別是讀取到的位元組數,客戶端的地址,error
    n, clientUDPAddr, err := udpConn.ReadFromUDP(buf)
    if err != nil {
        fmt.Printf("*UDPAddr.ReadFromUDP()方法執行出錯,錯誤為:%v\n", err)
        return
    }
    //3.模擬處理資料
    fmt.Printf("服務器讀到%v的資料:%s",clientUDPAddr, buf[:n])

    //4.回寫資料給客戶端
    _, err = udpConn.WriteToUDP([]byte("I am OK!"), clientUDPAddr)
    if err != nil {
        fmt.Printf("*UDPAddr.WriteToUDP()方法執行出錯,錯誤為:%v\n", err)
        return
    }
}

運行代碼

通過nc請求測驗

服務端讀取請求資料，并回寫"I am OK!"

UDP客戶端

udp客戶端的撰寫與TCP客戶端的撰寫，基本上是一樣的，只是將協議換成udp.代碼如下：

package main

import (
    "fmt"
    "net"
)

func main() {
    conn, err := net.Dial("udp", "127.0.0.1:8000")
    if err != nil {
        fmt.Printf("net.Dial()函式執行出錯,錯誤為:%v\n", err)
        return
    }
    defer conn.Close()

    conn.Write([]byte("hello, I`m a client in UDP!"))

    buf := make([]byte, 4096)
    n, err := conn.Read(buf)
    if err != nil {
        fmt.Printf("Conn.Read()方法執行出錯,錯誤為:%v\n", err)
        return
    }
    fmt.Printf("服務器發來資料:%s\n", buf[:n])
}

并發

其實對于UDP而言，服務器不需要并發，只要回圈處理客戶端資料即可，客戶端也等同于TCP通信并發的客戶端，

服務器:

package main

import (
    "fmt"
    "net"
)

func main() {

    //0.本應從步驟1開始,但是在寫步驟1的時候發現,步驟1還需要*UDPAddr型別的引數,所以需要先創建一個*DUPAddr
    //組織一個udp地址結構,指定服務器的IP+port
    udpAddr, err := net.ResolveUDPAddr("udp", "127.0.0.1:8000")
    if err != nil {
        fmt.Printf("net.ResolveUDPAddr()函式執行出錯,錯誤為:%v\n", err)
        return
    }
    fmt.Printf("UDP服務器地址結構創建完成!!!\n")

    //1.創建用戶通信的socket
    //由于ListenUDP需要一個*UDPAddr型別的引數,所以我們還需要先創建一個監聽地址
    udpConn, err := net.ListenUDP("udp", udpAddr)
    if err != nil {
        fmt.Printf("net.ListenUDP()函式執行出錯,錯誤為:%v\n", err)
        return
    }
    defer udpConn.Close()
    fmt.Printf("UDP服務器通信socket創建完成!!!\n")

    for {
        //2.讀取客戶端發送的資料(阻塞發生在ReadFromUDP()方法中)
        buf := make([]byte, 4096)
        //ReadFromUDP()方法回傳三個值,分別是讀取到的位元組數,客戶端的地址,error
        n, clientUDPAddr, err := udpConn.ReadFromUDP(buf)
        if err != nil {
            fmt.Printf("*UDPAddr.ReadFromUDP()方法執行出錯,錯誤為:%v\n", err)
            continue
        }
        //3.模擬處理資料
        fmt.Printf("服務器讀到%v的資料:%s\n",clientUDPAddr, buf[:n])

        //4.回寫資料給客戶端
        _, err = udpConn.WriteToUDP([]byte("I am OK!"), clientUDPAddr)
        if err != nil {
            fmt.Printf("*UDPAddr.WriteToUDP()方法執行出錯,錯誤為:%v\n", err)
            continue
        }
    }
}

客戶端:

package main

import (
    "fmt"
    "net"
    "os"
)

func main() {
    conn, err := net.Dial("udp", "127.0.0.1:8000")
    if err != nil {
        fmt.Printf("net.Dial()函式執行出錯,錯誤為:%v\n", err)
        return
    }
    defer conn.Close()

    go func() {
        buf := make([]byte, 4096)
        for {
            //從鍵盤讀取內容,放入buf
            n, err := os.Stdin.Read(buf)
            if err != nil {
                fmt.Printf("os.Stdin.Read()執行出錯,錯誤為:%v\n", err)
                return
            }
            //給服務器發送
            conn.Write(buf[:n])
        }
    }()
    for {
        buf := make([]byte, 4096)
        n, err := conn.Read(buf)
        if err != nil {
            fmt.Printf("Conn.Read()方法執行出錯,錯誤為:%v\n", err)
            return
        }
        fmt.Printf("服務器發來資料:%s\n", buf[:n])
    }
}

UDP與TCP的差異

TCP UDP
面向連接 面向無連接
要求系統資源較多 要求系統資源較少
TCP程式結構復雜 UDP程式結構比較簡單
使用流式 使用資料包式
保證資料準確性 不保證資料準確性
保證資料順序 不保證資料順序
通訊速度較慢 通訊速度較快

使用場景

TCP: 對資料傳輸安全性、穩定性要求高的場合，網路檔案傳輸，下載、上傳，

UDP: 對資料實時傳輸要求較高的場合，視頻直播、在線電話會議，游戲

相關文章:

http請求是如何先建立的三次握手?

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

標籤：Go

上一篇：[系列] Go 如何決議 JSON 資料？

下一篇：升級安裝go1.13.5

標籤雲
其他(157675) Python(38076) JavaScript(25376) Java(17977) C(15215) 區塊鏈(8255) C＃(7972) AI(7469) 爪哇(7425) MySQL(7132) html(6777) 基礎類(6313) sql(6102) 熊猫(6058) PHP(5869) 数组(5741) R(5409) Linux(5327) 反应(5209) 腳本語言(PerlPython)(5129) 非技術區(4971) Android(4554) 数据框(4311) css(4259) 节点.js(4032) C語言(3288) json(3245) 列表(3129) 扑(3119) C++語言(3117) 安卓(2998) 打字稿(2995) VBA(2789) Java相關(2746) 疑難問題(2699) 细绳(2522) 單片機工控(2479) iOS(2429) ASP.NET(2402) MongoDB(2323) 麻木的(2285) 正则表达式(2254) 字典(2211) 循环(2198) 迅速(2185) 擅长(2169) 镖(2155) 功能(1967) .NET技术(1958) Web開發(1951) python-3.x(1918) HtmlCss(1915) 弹簧靴(1913) C++(1909) xml(1889) PostgreSQL(1872) .NETCore(1853) 谷歌表格(1846) Unity3D(1843) for循环(1842)

熱門瀏覽
  • 【C++】Microsoft C++、C 和匯編程式檔案

    ......

    uj5u.com 2020-09-10 00:57:23 more
  • 例外宣告

    相比于斷言適用于排除邏輯上不可能存在的狀態，例外通常是用于邏輯上可能發生的錯誤。 例外宣告 Item 1：當函式不可能拋出例外或不能接受拋出例外時，使用noexcept 理由 如果不打算拋出例外的話，程式就會認為無法處理這種錯誤，并且應當盡早終止，如此可以有效地阻止例外的傳播與擴散。 示例 //不可 ......

    uj5u.com 2020-09-10 00:57:27 more
  • Codeforces 1400E Clear the Multiset(貪心 + 分治)

    鏈接：https://codeforces.com/problemset/problem/1400/E 來源：Codeforces 思路：給你一個陣列，現在你可以進行兩種操作，操作1：將一段沒有 0 的區間進行減一的操作，操作2：將 i 位置上的元素歸零。最終問：將這個陣列的全部元素歸零后操作的最少 ......

    uj5u.com 2020-09-10 00:57:30 more
  • UVA11610 【Reverse Prime】

    本人看到此題沒有翻譯，就附帶了一個自己的翻譯版本 思考 這一題，它的第一個要求是找出所有 $7$ 位反向質數及其質因數的個數。 我們應該需要質數篩篩選1~$10^{7}$的所有數，這里就不慢慢介紹了。但是，重讀題，我們突然發現反向質數都是 $7$ 位，而將它反過來后的數字卻是 $6$ 位數，這就說明 ......

    uj5u.com 2020-09-10 00:57:36 more
  • 統計區間素數數量

    1 #pragma GCC optimize(2) 2 #include <bits/stdc++.h> 3 using namespace std; 4 bool isprime[1000000010]; 5 vector<int> prime; 6 inline int getlist(int ......

    uj5u.com 2020-09-10 00:57:47 more
  • C/C++編程筆記：C++中的 const 變數詳解，教你正確認識const用法

    1、C中的const 1、區域const變數存放在堆疊區中，會分配記憶體（也就是說可以通過地址間接修改變數的值）。測驗代碼如下： 運行結果： 2、全域const變數存放在只讀資料段（不能通過地址修改，會發生寫入錯誤）， 默認為外部聯編，可以給其他源檔案使用（需要用extern關鍵字修飾） 運行結果： ......

    uj5u.com 2020-09-10 00:58:04 more
  • 【C++犯錯記錄】VS2019 MFC添加資源不懂如何修改資源宏ID

    1. 首先在資源視圖中，添加資源 2. 點擊新添加的資源，復制自動生成的ID 3. 在解決方案資源管理器中找到Resource.h檔案，編輯，使用整個專案搜索和替換的方式快速替換 宏宣告 4. Ctrl+Shift+F 全域搜索，點擊查找全部，然后逐個替換 5. 為什么使用搜索替換而不使用屬性視窗直 ......

    uj5u.com 2020-09-10 00:59:11 more
  • 【C++犯錯記錄】VS2019 MFC不懂的批量添加資源

    1. 打開資源頭檔案Resource.h，在其中預先定義好宏 ID（不清楚其實ID值應該設定多少，可以先新建一個相同的資源項，再在這個資源的ID值的基礎上遞增即可） 2. 在資源視圖中選中專案資源，按F7編輯資源檔案，按 ID 型別 相對路徑的形式添加 資源。（別忘了先把檔案拷貝到專案中的res檔案 ......

    uj5u.com 2020-09-10 01:00:19 more
  • C/C++編程筆記：關于C++的參考型別，專供新手入門使用

    今天要講的是C++中我最喜歡的一個用法——參考，也叫別名。 參考就是給一個變數名取一個變數名，方便我們間接地使用這個變數。我們可以給一個變數創建N個參考，這N + 1個變數共享了同一塊記憶體區域。(參考型別的變數會占用記憶體空間，占用的記憶體空間的大小和指標型別的大小是相同的。雖然參考是一個物件的別名，但 ......

    uj5u.com 2020-09-10 01:00:22 more
  • 【C/C++編程筆記】從頭開始學習C ++：初學者完整指南

    眾所周知，C ++的學習曲線陡峭，但是花時間學習這種語言將為您的職業帶來奇跡，并使您與其他開發人員區分開。您會更輕松地學習新語言，形成真正的解決問題的技能，并在編程的基礎上打下堅實的基礎。 C ++將幫助您養成良好的編程習慣（即清晰一致的編碼風格，在撰寫代碼時注釋代碼，并限制類內部的可見性），并且由 ......

    uj5u.com 2020-09-10 01:00:41 more
最新发布
  • Rust中的智能指標:Box<T> Rc<T> Arc<T> Cell<T> RefCell<T> Weak

    Rust中的智能指標是什么 智能指標（smart pointers）是一類資料結構，是擁有資料所有權和額外功能的指標。是指標的進一步發展 指標（pointer）是一個包含記憶體地址的變數的通用概念。這個地址參考，或 ” 指向”（points at）一些其 他資料 。參考以 & 符號為標志并借用了他們所 ......

    uj5u.com 2023-04-20 07:24:10 more
  • Java的值傳遞和參考傳遞

    值傳遞不會改變本身，參考傳遞（如果傳遞的值需要實體化到堆里）如果發生修改了會改變本身。 1.基本資料型別都是值傳遞 package com.example.basic; public class Test { public static void main(String[] args) { int ......

    uj5u.com 2023-04-20 07:24:04 more
  • [2]SpinalHDL教程——Scala簡單入門

    第一個 Scala 程式 shell里面輸入 $ scala scala> 1 + 1 res0: Int = 2 scala> println("Hello World!") Hello World! 檔案形式 object HelloWorld { /* 這是我的第一個 Scala 程式 * 以 ......

    uj5u.com 2023-04-20 07:23:58 more
  • 理解函式指標和回呼函式

    理解 函式指標 指向函式的指標。比如： 理解函式指標的偽代碼 void (*p)(int type, char *data); // 定義一個函式指標p void func(int type, char *data); // 宣告一個函式func p = func; // 將指標p指向函式func ......

    uj5u.com 2023-04-20 07:23:52 more
  • Django筆記二十五之資料庫函式之日期函式

    本文首發于公眾號：Hunter后端 原文鏈接：Django筆記二十五之資料庫函式之日期函式 日期函式主要介紹兩個大類，Extract() 和 Trunc() Extract() 函式作用是提取日期，比如我們可以提取一個日期欄位的年份，月份，日等資料 Trunc() 的作用則是截取，比如 2022-0 ......

    uj5u.com 2023-04-20 07:23:45 more
  • 一天吃透JVM面試八股文

    什么是JVM？ JVM，全稱Java Virtual Machine（Java虛擬機），是通過在實際的計算機上仿真模擬各種計算機功能來實作的。由一套位元組碼指令集、一組暫存器、一個堆疊、一個垃圾回收堆和一個存盤方法域等組成。JVM屏蔽了與作業系統平臺相關的資訊，使得Java程式只需要生成在Java虛擬機 ......

    uj5u.com 2023-04-20 07:23:31 more
  • 使用Java接入小程式訂閱訊息！

    更新完微信服務號的模板訊息之后，我又趕緊把微信小程式的訂閱訊息給實作了！之前我一直以為微信小程式也是要企業才能申請，沒想到小程式個人就能申請。 訊息推送平臺🔥推送下發【郵件】【短信】【微信服務號】【微信小程式】【企業微信】【釘釘】等訊息型別。 https://gitee.com/zhongfuch ......

    uj5u.com 2023-04-20 07:22:59 more
  • java -- 緩沖流、轉換流、序列化流

    緩沖流 緩沖流, 也叫高效流, 按照資料型別分類： 位元組緩沖流：BufferedInputStream，BufferedOutputStream 字符緩沖流：BufferedReader，BufferedWriter 緩沖流的基本原理，是在創建流物件時，會創建一個內置的默認大小的緩沖區陣列，通過緩沖 ......

    uj5u.com 2023-04-20 07:22:49 more
  • Java-SpringBoot-Range請求頭設定實作視頻分段傳輸

    老實說，人太懶了，現在基本都不喜歡寫筆記了，但是網上有關Range請求頭的文章都太水了 下面是抄的一段StackOverflow的代碼...自己大修改過的，寫的注釋挺全的，應該直接看得懂，就不解釋了 寫的不好...只是希望能給視頻網站開發的新手一點點幫助吧. 業務場景：視頻分段傳輸、視頻多段傳輸（理 ......

    uj5u.com 2023-04-20 07:22:42 more
  • Windows 10開發教程_編程入門自學教程_菜鳥教程-免費教程分享

    教程簡介 Windows 10開發入門教程 - 從簡單的步驟了解Windows 10開發，從基本到高級概念，包括簡介，UWP，第一個應用程式，商店，XAML控制元件，資料系結，XAML性能，自適應設計，自適應UI，自適應代碼，檔案管理，SQLite資料庫，應用程式到應用程式通信，應用程式本地化，應用程式 ......

    uj5u.com 2023-04-20 07:22:35 more

Copyright © 2010-2020 有解無憂