如何理解Go語言基礎之網絡編程

本篇內容主要講解“如何理解Go語言基礎之網絡編程”，感興趣的朋友不妨來看看。本文介紹的方法操作簡單快捷，實用性強。下面就讓小編來帶大家學習“如何理解Go語言基礎之網絡編程”吧!

socker編程

我們所學的TCP和UDP，統稱為Socker編程，也叫做套接字編程。

多臺機器要實現互相通訊，其實是一個非常復雜的過程，底層從鋪設網線，網線接口，交換機，路由器，在到規定各種協議。

再到應用層QQ，微信等軟件。

如果沒有一套標準，每次使用都要自己去實現，可能每個程序員都不是掉頭發那么簡單了!

有了Socker之后，Socker會在應用層之前，將各種繁瑣的的底層操作隱藏，我們可能只需要Socker.TCP就實現了TCP協議的通訊。

Go語言TCP

TCP屬于穩定的，可靠的長連接，

既然要涉及通訊，必然有兩個終端，最起碼一個是服務端，一個是客戶端，就像我們的淘寶，我們每次打開淘寶，都要去鏈接它，當然，淘寶可不直接是TCP。

服務端

在Go中實現服務端，并且在服務端并發很簡單，只需要將每個連接讓一個協程處理即可!

代碼

package main  import (     "bufio"     "fmt"     "net" )  func process(conn net.Conn) {     defer conn.Close()     for {         reader := bufio.NewReader(conn)         buf := make([]byte， 128)         n， err := reader.Read(buf)         if err != nil {             fmt.Println("數據讀取失敗"， err)             return         }         recvStr := string(buf[:n])         fmt.Println("客戶端發送過來的值:"， recvStr) }  } func main() {     lister， err := net.Listen("tcp"， "0.0.0.0:8008")     if err != nil {         fmt.Println("連接失敗"， err) }     for {         fmt.Println("等待建立連接，此時會阻塞住")         conn， err := lister.Accept() //等待建立連接         fmt.Println("連接建立成功，繼續")         if err != nil {             fmt.Println("建立連接失敗"， err)             //繼續監聽下次鏈接             continue         }         go process(conn) } }

客戶端

客戶端就很簡單了，相對來說是不需要并發的，只需要連接就行。

代碼

package main  import (     "bufio"     "fmt"     "net"     "os" )  //客戶端 func main() {     conn， err := net.Dial("tcp"， "192.168.10.148:8008")     if err != nil {         fmt.Println("連接服務器失敗"，err) }     defer conn.Close()     inputReader:=bufio.NewReader(os.Stdin)     for{         fmt.Println(":")         input，_:=inputReader.ReadString('\n')         _， err = conn.Write([]byte(input))         if err != nil {             fmt.Println("發送成功")         } } }

執行結果

就這樣，我們實現了服務端并發的處理所有客戶端的請求。

粘包

我們先看一下什么是粘包。

服務端

package main  import (     "bufio"     "fmt"     "io"     "net" )  func process(conn net.Conn) {     defer conn.Close()     reader := bufio.NewReader(conn)     buf := make([]byte， 1024)     for {         n， err := reader.Read(buf)         //讀完了         if err == io.EOF {             fmt.Println("讀完了")             break         }         //讀錯了         if err != nil {             fmt.Println("數據讀取失敗"， err)             return         }         recvStr := string(buf[:n])         fmt.Println("客戶端發送過來的值:"， recvStr) }  } func main() {     lister， err := net.Listen("tcp"， "0.0.0.0:8008")     if err != nil {         fmt.Println("連接失敗"， err)         return }     defer lister.Close()     for {         fmt.Println("等待建立連接，此時會阻塞住")         conn， err := lister.Accept() //等待建立連接         fmt.Println("連接建立成功，繼續")         if err != nil {             fmt.Println("建立連接失敗"， err)             //繼續監聽下次鏈接             continue         }         go process(conn) } }

客戶端

package main  import (     "fmt"     "net" )  //客戶端 func main() {     conn， err := net.Dial("tcp"， "192.168.10.148:8008")     if err != nil {         fmt.Println("連接服務器失敗"， err) }     defer conn.Close()     for i := 0; i < 10; i++ {         sendStr := "hello world ads asdf asd fads fadsf ads ads asd asd ads "         conn.Write([]byte(sendStr))         time.Sleep(time.Second) } }

注意:18行代碼睡眠了1s

執行結果

如果我注釋了第18行代碼

執行結果

直接都淦到一行了，what?這是啥情況，不應該跟原來一樣嗎???

每發送一個值，那邊就接收一下，這怎么整到一塊了!!!

原因

主要原因是因為我們是應用層軟件，是跑在操作系統之上的軟件，當我們向服務器發送一個數據時，是調用操作系統的相關接口發送的，操作系統再經過各種復雜的操作，發送到對方機器

但是操作系統有一個發送數據緩沖區，默認情況如果緩沖區是有大小的，如果緩沖區沒滿，是不會發送數據的，所以上述客戶端在發送數據時，系統的緩沖區都沒滿，一直壓在了操作系統的緩沖區中，最后發現沒數據了，才一次都發送到服務端

但是為什么sleep(1)又管用了呢?這是因為緩沖區不止一個程序在用，1s的時間足夠其他程序將緩沖區打滿，然后各自發各自的數據，這也是為什么第一次操作沒問題，第二次有問題，因為第二次全部都是我們客戶端打滿的

解決粘包

工具函數

我們將解包封包的函數封裝一下

socker_sitck/stick.go

package socker_stick  import (     "bufio"     "bytes"     "encoding/binary"     "fmt" )  //Encode 將消息編碼 func Encode(message string) ([]byte， error) {     length := int32(len(message))     var pkg = new(bytes.Buffer)     //寫入消息頭     err := binary.Write(pkg， binary.LittleEndian， length)     if err != nil {         fmt.Println("寫入消息頭失敗"， err)         return nil， err }     //寫入消息實體     err = binary.Write(pkg， binary.LittleEndian， []byte(message))     if err != nil {         fmt.Println("寫入消息實體失敗"， err)         return nil， err }     return pkg.Bytes()， nil }  //Decode解碼消息 func Decode(reader *bufio.Reader) (string， error) {     //讀取信息長度     lengthByte， _ := reader.Peek(4)     lengthBuff := bytes.NewBuffer(lengthByte)     var length int32     err := binary.Read(lengthBuff， binary.LittleEndian， &length)     if err != nil {         return ""， err }     //BuffRead 返回緩沖區現有的可讀的字節數     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 }

服務端

package main  import (     "a3_course/socker_stick"     "bufio"     "fmt"     "io"     "net" )  func process(conn net.Conn) {     defer conn.Close()     reader := bufio.NewReader(conn)      for {         msg， err := socker_stick.Decode(reader)         //讀完了         if err == io.EOF {             fmt.Println("讀完了")             break         }         //讀錯了         if err != nil {             fmt.Println("數據讀取失敗"， err)             return         }          fmt.Println("客戶端發送過來的值:"， msg) }  } func main() {     lister， err := net.Listen("tcp"， "0.0.0.0:8008")     if err != nil {         fmt.Println("連接失敗"， err)         return }     defer lister.Close()     for {         fmt.Println("等待建立連接，此時會阻塞住")         conn， err := lister.Accept() //等待建立連接         fmt.Println("連接建立成功，繼續")         if err != nil {             fmt.Println("建立連接失敗"， err)             //繼續監聽下次鏈接             continue         }         go process(conn) } }

客戶端

package main  import (     "a3_course/socker_stick"     "fmt"     "net" )  //客戶端 func main() {     conn， err := net.Dial("tcp"， "192.168.10.148:8008")     if err != nil {         fmt.Println("連接服務器失敗"， err) }     defer conn.Close()     for i := 0; i < 10; i++ {         sendStr := "hello world ads asdf asd fads fadsf ads ads asd asd ads "         data， err := socker_stick.Encode(sendStr)         if err != nil {             fmt.Println("編碼失敗"，err)             return         }         conn.Write(data)         //time.Sleep(time.Second) } }

執行結果

這次真的不管執行幾次，都是這樣的結果

對了，只有TCP才有粘包

Go語言UDP

UDP是一個無連接協議，客戶端不會在乎服務端有沒有問題，客戶端只管發，通常用于實時性比較高的領域

例如直播行業

服務端

package main  import (     "fmt"     "net" )  func main() {     listen， err := net.ListenUDP("udp"， &net.UDPAddr{         IP:   net.IPv4(0， 0， 0， 0)，         Port: 8009， })     if err != nil {         panic(fmt.Sprintf("udp啟動失敗，err:%v"， err)) }     defer listen.Close()     for{         var data = make([]byte，1024)         n， addr， err := listen.ReadFromUDP(data)         if err != nil {             panic(fmt.Sprintf("讀取數據失敗，err:%v"， err))         }         fmt.Println(string(data[:n])，addr，n) } }

客戶端

package main  import (     "fmt"     "net" )  func main() {     socker， err := net.DialUDP("udp"， nil， &net.UDPAddr{         IP:   net.IPv4(0， 0， 0， 0)，         Port: 8009， })     if err != nil {         panic(fmt.Sprintf("連接服務器失敗，err:%v"， err)) }     defer socker.Close()     sendStr:="你好呀"     _， err = socker.Write([]byte(sendStr))     if err != nil {         panic(fmt.Sprintf("數據發送失敗，err:%v"， err)) } }

執行結果

到此，相信大家對“如何理解Go語言基礎之網絡編程”有了更深的了解，不妨來實際操作一番吧！這里是億速云網站，更多相關內容可以進入相關頻道進行查詢，關注我們，繼續學習！