一篇文章帶你了解Go語言基礎之網絡編程
作者：Go進階者
本次章節我們講述了什么是TCP，什么是UDP。并且編寫了代碼如何實現TCP服務端，TCP客戶端，UDP服務端，UDP客戶端。講述了為什么會出現粘包，該怎么解決粘包。
前言
Hi，大家好呀，我是碼農，星期八，我們身處21世紀，我們的世界已經在不知不覺中，就像很多網一樣在互聯互通。
互聯網是一個統稱，目前比較常用的有TCP，UDP協議。
當然，還有很多其他的協議，但是本次主要講最常用的TCP和UDP協議。
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))
- }
- }
執行結果
總結
本次章節我們講述了什么是TCP，什么是UDP。
并且編寫了代碼如何實現TCP服務端，TCP客戶端，UDP服務端，UDP客戶端。
講述了為什么會出現粘包，該怎么解決粘包。
逆水行舟，不進則退!
責任編輯：姜華
來源：
Go語言進階學習
