2. 程式人生 > >Go語言8-socket和redis

Go語言8-socket和redis

阿新 • • 發佈：2018-11-19

socket 程式設計

在Go裡為我們提供了net包。
下面這篇貌似是官方文件的翻譯：
https://blog.csdn.net/chenbaoke/article/details/42782571
上面的轉載，上面的頁面在IE下瀏覽貌似有點問題：
https://studygolang.com/articles/3600

Package net provides a portable interface for network I/O, including TCP/IP, UDP, domain name resolution, and Unix domain sockets.

net包對於網路I/O提供了行動式介面，包括TCP/IP,UDP，域名解析以及Unix Socket。

Although the package provides access to low-level networking primitives, most clients will need only the basic interface provided by the Dial, Listen, and Accept functions and the associated Conn and Listener interfaces. The crypto/tls package uses the same interfaces and similar Dial and Listen functions.

儘管net包提供了大量訪問底層的介面，但是大多數情況下，客戶端僅僅只需要最基本的介面，例如Dial，LIsten，Accepte以及分配的conn連線和listener介面。 crypto/tls包使用相同的介面以及類似的Dial和Listen函式。

服務端

服務端的處理流程：

  1. 監聽埠
  2. 接收客戶端的連線
  3. 建立goroutine，處理連線

服務端程式碼：

package main

import (
    "fmt"
    "net"
)

func main() {
    fmt.Println("準備開啟Server...")
    listen, err := net.Listen("tcp", "0.0.0.0:8080")
    if err != nil {
        fmt.Println("監聽埠ERROR:", err)
        return
    }
    for {
        conn, err := listen.Accept()
        if err != nil {
            fmt.Println("接收連線ERROR:", err)
        }
        go process(conn)
    }
}

func process(conn net.Conn) {
    defer conn.Close()
    for {
        buf := make([]byte, 512)
        n, err := conn.Read(buf)
        fmt.Println(n)  // 這個應該是讀取到的資料的長度
        if err != nil {
            fmt.Println("讀取資料ERROR:", err)
            return
        }
        fmt.Println("READ:", string(buf))
    }
}

測試，暫時還沒有客戶端，可以先用windows的telnet工具來測試一下：

>telnet 127.0.0.1 8080

進入telnet後按任意鍵盤，server端會做出反應，但是效果不是很友好。
修改一下服務端的process函式如下：

func process(conn net.Conn) {
    defer conn.Close()
    for {
        buf := make([]byte, 10)  // 這次一次只收10個
        _, err := conn.Read(buf)  // 接收的長度就不看了
        if err != nil {
            fmt.Println("讀取資料ERROR:", err)
            return
        }
        fmt.Printf("%v\n", buf)  // 檢視buf的字元型別
    }
}

conn.Read用於讀取收到的資料，把資料存到變數buf裡。buf切片裡的型別應該是字元型別預設就是0，從輸出裡看到其他後面都是0。
conn.Read 返回的第一個引數是接收的長度，那麼可以對buf進行切片，只把收到的資料打印出來：

package main

import (
    "fmt"
    "net"
)

func main() {
    fmt.Println("準備開啟Server...")
    listen, err := net.Listen("tcp", "0.0.0.0:8080")
    if err != nil {
        fmt.Println("監聽埠ERROR:", err)
        return
    }
    for {
        conn, err := listen.Accept()
        if err != nil {
            fmt.Println("接收連線ERROR:", err)
        }
        go process(conn)
    }
}

func process(conn net.Conn) {
    defer conn.Close()
    for {
        buf := make([]byte, 512)
        n, err := conn.Read(buf)
        if err != nil {
            fmt.Println("讀取資料ERROR:", err)
            return
        }
        fmt.Printf(string(buf[0:n]))  // 接收了n個字元，就只打印前n個
    }
}

上面的程式碼，在telnet連線後，鍵盤輸入任何內容，都會在server端打印出來。這裡也能傳中文，但是接收到的的是亂碼，這個主要是telnet的問題（有編碼的問題，一箇中文字元佔2個長度，如果是utf-8是長度3。而且會把中文的2段編碼拆開發出去。不深究了。），後面用上客戶端就好了。

客戶端

客戶端的處理流程：

  1. 建立與服務端的連線
  2. 進行資料收發
  3. 關閉連線

客戶端程式碼：

package main

import (
    "bufio"
    "fmt"
    "net"
    "os"
    "strings"
)

func main() {
    conn, err := net.Dial("tcp", "127.0.0.1:8080")
    if err != nil {
        fmt.Println("建立連線ERROR:", err)
        return
    }
    fmt.Println("建立連線成功")
    defer conn.Close()  // 這裡一定記得要關閉
    inputReader := bufio.NewReader(os.Stdin)
    for {
        input, err := inputReader.ReadString('\n')
        input = strings.TrimSpace(input)
        if err != nil {
            fmt.Println("終端輸入ERROR:", err)
        }

        if input == "Q" {
            fmt.Println("退出...")
            return
        }
        _, err = conn.Write([]byte(input))  // 第一個引數是傳送的字元數
        if err != nil {
            fmt.Println("傳送資料ERROR:", err)
            return
        }
    }
}

傳送http請求

這裡需要一點基礎，你得知道Web服務的本質。
這裡只用HTTP/1.1來做個示例，預設：Connection:keep-alive，示例裡設定為：Connection:close。接收的資料的內容會有區別，Connection:close收到的資料會比較簡單（Connection:keep-alive應該是比較新的標準，預設是返回這樣的格式）。
傳送http請求的程式碼：

package main

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

func main() {
    conn, err := net.Dial("tcp", "edu.51cto.com:80")
    if err != nil {
        fmt.Println("建立連線ERROR:", err)
        return
    }
    defer conn.Close()
    // 設定請求頭
    msg := "GET / HTTP/1.1\r\n"
    msg += "Host:edu.51cto.com\r\n"
    msg += "Connection:close\r\n"
    msg += "\r\n"  // 請求頭結束
    _, err = io.WriteString(conn, msg)  // 傳送請求
    if err != nil {
        fmt.Println("傳送資料ERROR:", err)
        return
    }
    buf := make([]byte, 1024)
    fmt.Println("接收資料...")
    for {
        n, err := conn.Read(buf)
        fmt.Println(string(buf[0:n]))
        if err != nil {
            if err == io.EOF{
                fmt.Println("接收完畢...")
                break
            } else {
                fmt.Println("接收資料ERROR:", err)
                os.Exit(0)
            }
        }
    }
}

Redis

本篇主要是講go如何使用Redis，就是一些簡單的程式碼示例。關於Redis的基礎知識可以看下面這篇的第一章節。
Redis安裝和基礎知識：http://blog.51cto.com/steed/2057706
Redis是一個開源的高效能的key-value的記憶體資料庫，可以把它當成遠端的資料結構。
支援的value型別很多，比如：string、list（連結串列）、set（集合）、hash表等
Redis的效能非常高，單機能夠達到15w qps，通常用來做快取。

使用第三方開源的redis庫：https://github.com/gomodule/redigo
安裝第三方庫：

go get github.com/gomodule/redigo/redis

連線 Redis

package main

import (
    "fmt"
    "github.com/gomodule/redigo/redis"
)

func main() {
    conn, err := redis.Dial("tcp", "192.168.3.108:6379")
    if err != nil {
        fmt.Println("連線Redis ERROR:", err)
        return
    }
    fmt.Println("連線Redis 成功:", conn)
    defer conn.Close()
}

Set 和 Get

上面的連線沒問題的，接下來就可以通過Redis存（Set）取(Get)資料了。這裡還有個坑，
正常啟動Redis的命令：

$ redis-server

redis預設是以保護模式啟動的，只能本機連。本機以外可能連不上，或者只能連不能改。就不要那麼麻煩再去整配置檔案了，這裡以學習測試為主，推薦這麼啟動：

$ redis-server --protected-mode no

現在Redis可以用了，使用Set和Get進行存取的程式碼：

package main

import (
    "fmt"
    "github.com/gomodule/redigo/redis"
)

func main() {
    conn, err := redis.Dial("tcp", "192.168.3.108:6379")
    if err != nil {
        fmt.Println("連線Redis ERROR:", err)
        return
    }
    fmt.Println("連線Redis 成功:", conn)
    defer conn.Close()

    resSet, err := conn.Do("Set", "age", 18)  // 這裡存字串或數值到Redis裡都是一樣的
    if err != nil {
        fmt.Println("Set Redis ERROR:", err)
        return
    }
    fmt.Println("Redis Set:", resSet)

    resGet, err := redis.Int(conn.Do("Get", "age"))
    if err != nil {
        fmt.Println("Get Redis ERROR:", err)
        return
    }
    fmt.Println("Redis Get:", resGet)
}

/* 執行結果
PS H:\Go\src\go_dev\day9\redis\connect> go run main.go
連線Redis 成功: &{{0 0} 0 <nil> 0xc042004030 0 0xc04203a120 0 0xc042036180 [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0] [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0]}
Redis Set: OK
Redis Get: 18
PS H:\Go\src\go_dev\day9\redis\connect>
*/

批量Set

批量Set是redis原生就支援的功能，這裡就是呼叫新的方法 MSet 和 MGet ，進行批量的操作：

package main

import (
    "fmt"
    "github.com/gomodule/redigo/redis"
)

func main() {
    conn, err := redis.Dial("tcp", "192.168.3.108:6379")
    if err != nil {
        fmt.Println("連線Redis ERROR:", err)
        return
    }
    fmt.Println("連線Redis 成功:", conn)
    defer conn.Close()

    resSet, err := conn.Do("MSet", "k1", "v1", "k2", "v2", "k3", "v3")
    if err != nil {
        fmt.Println("Set Redis ERROR:", err)
        return
    }
    fmt.Println("Redis MSet:", resSet)

    resGet, err := redis.Strings(conn.Do("MGet", "k1", "k2", "k3"))
    if err != nil {
        fmt.Println("Get Redis ERROR:", err)
        return
    }
    fmt.Println("Redis MGet:", resGet)
    for _, v := range resGet {
        fmt.Println(v)
    }
}

Hash 操作

package main

import (
    "fmt"
    "github.com/gomodule/redigo/redis"
)

func main() {
    conn, err := redis.Dial("tcp", "192.168.3.108:6379")
    if err != nil {
        fmt.Println("連線Redis ERROR:", err)
        return
    }
    fmt.Println("連線Redis 成功:", conn)
    defer conn.Close()

    resSet, err := conn.Do("HSet", "student", "age", 18)
    if err != nil {
        fmt.Println("Set Redis ERROR:", err)
        return
    }
    fmt.Println("Redis Set:", resSet)

    resGet, err := redis.Int(conn.Do("HGet", "student", "age"))
    if err != nil {
        fmt.Println("Get Redis ERROR:", err)
        return
    }
    fmt.Println("Redis Get:", resGet)
}

設定超時時間

超時時間是對key進行設定的。預設是沒有超時時間的，永不過期。這裡的示例是在設定好key-value之後再對key設定超時時間：

package main

import (
    "fmt"
    "github.com/gomodule/redigo/redis"
)

func main() {
    conn, err := redis.Dial("tcp", "192.168.3.108:6379")
    if err != nil {
        fmt.Println("連線Redis ERROR:", err)
        return
    }
    fmt.Println("連線Redis 成功:", conn)
    defer conn.Close()

    // 假設之前已經設定了name這個key值，設定後name會在10秒後過期
    resSet, err := conn.Do("expire", "name", 10)
    if err != nil {
        fmt.Println("Set Redis ERROR:", err)
        return
    }
    fmt.Println("Redis Set:", resSet)
    if int(resSet.(int64)) == 1 {
        fmt.Println("設定超時時間成功")
    }
}

在Set的時候，就可以加一個引數，其中就有超時時間。這裡的例子是對已有的key重新設定一個超時時間。如果key存在，則返回1，如果key不存在，Redis會返回0。

佇列操作

package main

import (
    "fmt"
    "github.com/gomodule/redigo/redis"
)

func main() {
    conn, err := redis.Dial("tcp", "192.168.3.108:6379")
    if err != nil {
        fmt.Println("連線Redis ERROR:", err)
        return
    }
    fmt.Println("連線Redis 成功:", conn)
    defer conn.Close()

    resPush, err := conn.Do("lpush", "names", "Clark", "Lois", "Kara")
    if err != nil {
        fmt.Println("Push Redis ERROR:", err)
        return
    }
    fmt.Println("Redis MSet:", resPush)

    for {
        resPop, err := redis.String(conn.Do("lpop", "names"))
        if err != nil {
            if err == redis.ErrNil {
                fmt.Println("佇列已經取完:", err)
                break
            } else {
                fmt.Println("Pop Redis ERROR:", err)
                return
            }
        }
        fmt.Println("Redis lpop:", resPop)
    }
}

使用連線池

使用場景：
對於一些大物件，或者初始化過程較長的可複用的物件，我們如果每次都new物件出來，那麼意味著會耗費大量的時間。我們可以將這些物件快取起來，當介面呼叫完畢後，不是銷燬物件，當下次使用的時候，直接從物件池中拿出來即可。
使用連線池操作Redis的步驟：

  • 首先建立連線池，可以在init函式裡建立。
  • 每次要連線的時候，就從池裡獲取一個連線。記得defer關閉連線。
  • 獲取到連線後的操作方法就一樣了

程式碼示例：

package main

import (
    "fmt"
    "github.com/gomodule/redigo/redis"
)

var pool redis.Pool

func init() {
    pool = redis.Pool {
        MaxIdle: 8,
        MaxActive: 0,
        IdleTimeout: 300,
        Dial: func() (redis.Conn, error) {
            return redis.Dial("tcp", "192.168.3.108:6379")
        },
    }
}

func main() {
    conn := pool.Get()  // 從池裡獲取一個連線使用
    defer conn.Close()  // 還是記得要關閉連線
    resCon, err := conn.Do("Set", "school", "SHHS")
    if err != nil {
        fmt.Println("Redis Set ERROR:", err)
        return
    }
    fmt.Println(resCon)  // 返回值是OK沒什麼用

    resGet, err := redis.String(conn.Do("Get", "school"))
    if err != nil {
        fmt.Println("Redis Get ERROR:", err)
        return
    }
    fmt.Println(resGet)
    pool.Close()  // 關閉pool
}

相關推薦

Go語言8-socket和redis

socket 程式設計 在Go裡為我們提供了net包。下面這篇貌似是官方文件的翻譯：https://blog.csdn.net/chenbaoke/article/details/42782571 上面的轉載，上面的頁面在IE下瀏覽貌似有點問題：https://studygolang.com/article

Go語言8-goroutine和channel

Goroutine Go語言從語言層面上就支援了併發，這與其他語言大不一樣。Go語言中有個概念叫做goroutine，這類似我們熟知的執行緒，但是更輕。 程序、執行緒、協程 程序和執行緒程序是程式在作業系統中的一次執行過程，系統進行資源分配和排程的一個獨立單位。執行緒是程序的一個執行實體，是CPU排程和

GO語言————8.1 MAP宣告、初始化和make

8.0 Mapmap 是一種特殊的資料結構：一種元素對（pair）的無序集合，pair 的一個元素是 key，對應的另一個元素是 value，所以這個結構也稱為關聯陣列或字典。這是一種快速尋找值的理想結構：給定 key，對應的 value 可以迅速定位。map 這種資料結構在

Go語言資源教程：Redis介紹安裝和使用

序列 lock 成員 允許 最大的 mem end 每一個 數據 Redis的操作和使用 在安裝好redis以後，我們這裏給大家講一下redis操作的一些知識。 Redis支持的數據類型：string，hash，list，set，sorted set 我們來練習一下red

Go語言學習-main和init

都是 函數 很多 學習 導入 同時 如果 ack 它的 main 函數和 init 函數Go裏面有兩個保留的函數： init 函數（能夠應用於所有的 package ）和 main 函數（只能應用於 package main ）。這兩個函數在定義時不能有任何的參數和返回值。

Go語言－切片和map

package pri code [] print UNC AR make 運行 實例 package main import ( "fmt" ) func main() { arr := make([]i

go語言爬蟲goquery和grequests的使用

gen times name lac like index htm syn stop /*下載工具*/ package main import ( "fmt" //go語言版本的jquery "github.com/Pue

Go語言學習--常量和變量

返回 編譯錯誤 必須 數字 編譯器 計算表達式 兩個 但是 長度 1. 常量 常量中的數據類型只可以是布爾型、數字型（整數型、浮點型和復數）和字符串型 定義格式： const identifier [type] = value, [type]可以省略，編譯器會根據變量的值

Go語言sync庫和WaitGroup的使用

%d 調用 如果 運行時 main函數 fmt package 信號量 計數 // code_041_sync_WaitGroup project main.go package main import ( "fmt" "sync" ) func mai

golang基礎學習---Go 語言 break 語句和continue語句

Go 語言 break 語句 Go 語言中 break 語句用於以下兩方面： 用於迴圈語句中跳出迴圈，並開始執行迴圈之後的語句。 break在switch（開關語句）中在執行一條case後跳出語句的作用。 示例 package main import "fmt" fu

Go語言10-http和mysql

http 程式設計 Go 原生支援http： import "net/http" Go 的http服務效能和nginx比較接近：就是說用Go寫的Web程式上線，程式前面不需要再部署nginx的Web伺服器，這裡省掉的是Web伺服器。如果伺服器上部署了多個Web應用，還是需要反向代理的，一般這也是ngin

go語言實現搜尋和為目標值的兩個數字

package main import "fmt" func main() { array := [10]int{1,2,3,4,5,6,7,8,9,20} target := 29 index,index2 := twoSum(a

Windows 平臺下 Go 語言的安裝和環境變數設定

1. Go 語言 SDK 安裝包下載和安裝 最新穩定版 1.5.3 安裝包 go1.5.3.windows-amd64.msi下載地址 https://golang.org/dl/，大小約 69 MB(作者上傳了一份該版本安裝包到 CSDN 資源，嫌國外網速慢可以去下載：h

go語言學習-iota和右移的用法

在go語言中iota比較特殊，是一個被編譯器修改的常量，在每一個const關鍵字出現時被重置為0，然後在下一個const出現之前，每出現一次iota，其所代表的數字就會自動加1 左移運算子”<<”是雙目運算子。左移n位就是乘以2的n次方。 其功能把

go語言時間型別和時間戳

時間型別 獲取當地時間 fmt.Println(time.Now()) fmt.Println(time.Now().Local()) fmt.Println(time.Now().UTC()) fmt.Println(time.Now().Location()) 執行結果

go語言--struct繼承和聚合

type person {name string sex int, age int, } type student {        person，     &nbs

Go實戰--通過httprouter和redis框架搭建restful api服務(github.com/julienschmidt/httprouter)

生命不止，繼續 go go go !!! httprouter HttpRouter is a lightweight high performance HTTP request router (also called multiplexer or ju

學習筆記（一） Go語言的介紹和編譯器安裝及環境配置

  Subject: Re: prog lang discussion   From: Rob 'Commander' Pike   Date: Tue, Sep 25, 2007 at 3:12 PM   To: Robert Griesemer, Ken Thompson   i had a co

Go語言的併發和並行

package main import ( "fmt" ) func loop(done chan bool) { for i := 0; i < 10; i++ { fmt.Print(i) } done <

go web 之socket 和 websocket 學習

socket 介紹 socket 是客戶端和伺服器連線的橋樑，socket 用於web瀏覽器和伺服器的通訊,socket是一種檔案描述符。 socket 分為兩種 流式socket 和 資料報式socket 1. 流式socket是一種面向連線的Socke