生命不止，繼續 go go go !!!

今天跟大家分享的是如何在golang中使用redis資料庫。

何為redis

Redis is an in-memory database open-source software project implementing a networked, in-memory key-value store with optional durability.
Redis是一個開源的、使用C語言編寫的、支援網路互動的、可基於記憶體也可持久化的Key-Value資料庫。

Redis 優勢
效能極高 – Redis能讀的速度是110000次/s,寫的速度是81000次/s 。

豐富的資料型別 – Redis支援二進位制案例的 Strings, Lists, Hashes, Sets 及 Ordered Sets 資料型別操作。

原子 – Redis的所有操作都是原子性的，同時Redis還支援對幾個操作全並後的原子性執行。

豐富的特性 – Redis還支援 publish/subscribe, 通知, key 過期等等特性。

Redis與其他key-value儲存有什麼不同？
Redis有著更為複雜的資料結構並且提供對他們的原子性操作，這是一個不同於其他資料庫的進化路徑。Redis的資料型別都是基於基本資料結構的同時對程式設計師透明，無需進行額外的抽象。

Redis執行在記憶體中但是可以持久化到磁碟，所以在對不同資料集進行高速讀寫時需要權衡記憶體，因為資料量不能大於硬體記憶體。在記憶體資料庫方面的另一個優點是，相比在磁碟上相同的複雜的資料結構，在記憶體中操作起來非常簡單，這樣Redis可以做很多內部複雜性很強的事情。同時，在磁碟格式方面他們是緊湊的以追加的方式產生的，因為他們並不需要進行隨機訪問。

windows安裝redis

這裡只簡單介紹一下Windows上redis的安裝：
在官網中可以看到這樣的描述：
Windows
The Redis project does not officially support Windows. However, the Microsoft Open Tech group develops and maintains this Windows port targeting Win64

這裡可以下載msi檔案和zip檔案，兩者區別就是msi檔案是安裝檔案，安裝的過程中會幫助我們配好環境變數，所以推薦。

這裡需要提示一下安裝過程中，如果修改了埠號，一定要記住：
圖1

啟動服務端
安裝成功後，通過終端鍵入如下命令：

redis-server.exe redis.windows.conf

一切沒問題會出現下面的提示:
[11368] 13 Jul 10:10:31.487 # Creating Server TCP listening socket 127.0.0.1:6379: bind: No error

啟動客戶端
新開啟一個終端，啟動redis客戶端，鍵入命令：

redis-cli.exe -h 127.0.0.1 -p 6379

測試：

127.0.0.1:6379> set mykey abc
OK
127.0.0.1:6379> get mykey
"abc"

開源庫redigo的使用

獲取：

go get github.com/garyburd/redigo/redis

連線redis

package main
import (
    "fmt"
    "github.com/garyburd/redigo/redis"
)

func main() {
    c, err := redis.Dial("tcp", "127.0.0.1:6379")
    if err != nil {
        fmt.Println("Connect to redis error", err)
        return
    }
    defer c.Close()
}

讀寫
這裡寫入的值永遠不會過期

package main

import (
    "fmt"

    "github.com/garyburd/redigo/redis"
)

func main() {
    c, err := redis.Dial("tcp", "127.0.0.1:6379")
    if err != nil {
        fmt.Println("Connect to redis error", err)
        return
    }
    defer c.Close()

    _, err = c.Do("SET", "mykey", "superWang")
    if err != nil {
        fmt.Println("redis set failed:", err)
    }

    username, err := redis.String(c.Do("GET", "mykey"))
    if err != nil {
        fmt.Println("redis get failed:", err)
    } else {
        fmt.Printf("Get mykey: %v \n", username)
    }
}

如何設定過期呢，可以使用SET的附加引數：

package main

import (
    "fmt"
    "time"

    "github.com/garyburd/redigo/redis"
)

func main() {
    c, err := redis.Dial("tcp", "127.0.0.1:6379")
    if err != nil {
        fmt.Println("Connect to redis error", err)
        return
    }
    defer c.Close()

    _, err = c.Do("SET", "mykey", "superWang", "EX", "5")
    if err != nil {
        fmt.Println("redis set failed:", err)
    }

    username, err := redis.String(c.Do("GET", "mykey"))
    if err != nil {
        fmt.Println("redis get failed:", err)
    } else {
        fmt.Printf("Get mykey: %v \n", username)
    }

    time.Sleep(8 * time.Second)

    username, err = redis.String(c.Do("GET", "mykey"))
    if err != nil {
        fmt.Println("redis get failed:", err)
    } else {
        fmt.Printf("Get mykey: %v \n", username)
    }
}

輸出：
Get mykey: superWang
redis get failed: redigo: nil returned

批量寫入讀取

MGET key [key …]
MSET key value [key value …]

批量寫入讀取物件(Hashtable)
HMSET key field value [field value …]
HMGET key field [field …]

檢測值是否存在
EXISTS key

package main

import (
    "fmt"

    "github.com/garyburd/redigo/redis"
)

func main() {
    c, err := redis.Dial("tcp", "127.0.0.1:6379")
    if err != nil {
        fmt.Println("Connect to redis error", err)
        return
    }
    defer c.Close()

    _, err = c.Do("SET", "mykey", "superWang")
    if err != nil {
        fmt.Println("redis set failed:", err)
    }

    is_key_exit, err := redis.Bool(c.Do("EXISTS", "mykey1"))
    if err != nil {
        fmt.Println("error:", err)
    } else {
        fmt.Printf("exists or not: %v \n", is_key_exit)
    }

}

輸出：
exists or not: false

刪除
DEL key [key …]

package main

import (
    "fmt"

    "github.com/garyburd/redigo/redis"
)

func main() {
    c, err := redis.Dial("tcp", "127.0.0.1:6379")
    if err != nil {
        fmt.Println("Connect to redis error", err)
        return
    }
    defer c.Close()

    _, err = c.Do("SET", "mykey", "superWang")
    if err != nil {
        fmt.Println("redis set failed:", err)
    }

    username, err := redis.String(c.Do("GET", "mykey"))
    if err != nil {
        fmt.Println("redis get failed:", err)
    } else {
        fmt.Printf("Get mykey: %v \n", username)
    }

    _, err = c.Do("DEL", "mykey")
    if err != nil {
        fmt.Println("redis delelte failed:", err)
    }

    username, err = redis.String(c.Do("GET", "mykey"))
    if err != nil {
        fmt.Println("redis get failed:", err)
    } else {
        fmt.Printf("Get mykey: %v \n", username)
    }
}

輸出：
Get mykey: superWang
redis get failed: redigo: nil returned

讀寫json到redis

package main

import (
    "encoding/json"
    "fmt"

    "github.com/garyburd/redigo/redis"
)

func main() {
    c, err := redis.Dial("tcp", "127.0.0.1:6379")
    if err != nil {
        fmt.Println("Connect to redis error", err)
        return
    }
    defer c.Close()

    key := "profile"
    imap := map[string]string{"username": "666", "phonenumber": "888"}
    value, _ := json.Marshal(imap)

    n, err := c.Do("SETNX", key, value)
    if err != nil {
        fmt.Println(err)
    }
    if n == int64(1) {
        fmt.Println("success")
    }

    var imapGet map[string]string

    valueGet, err := redis.Bytes(c.Do("GET", key))
    if err != nil {
        fmt.Println(err)
    }

    errShal := json.Unmarshal(valueGet, &imapGet)
    if errShal != nil {
        fmt.Println(err)
    }
    fmt.Println(imapGet["username"])
    fmt.Println(imapGet["phonenumber"])
}

設定過期時間
EXPIRE key seconds

// 設定過期時間為24小時  
n, _ := rs.Do("EXPIRE", key, 24*3600)  
if n == int64(1) {  
    fmt.Println("success")  
}  

列表操作
命令：

redis 127.0.0.1:6379> LPUSH runoobkey redis
(integer) 1
redis 127.0.0.1:6379> LPUSH runoobkey mongodb
(integer) 2
redis 127.0.0.1:6379> LPUSH runoobkey mysql
(integer) 3
redis 127.0.0.1:6379> LRANGE runoobkey 0 10

1) "mysql"
2) "mongodb"
3) "redis"

程式碼實現：

package main

import (
    "fmt"

    "github.com/garyburd/redigo/redis"
)

func main() {
    c, err := redis.Dial("tcp", "127.0.0.1:6379")
    if err != nil {
        fmt.Println("Connect to redis error", err)
        return
    }
    defer c.Close()

    _, err = c.Do("lpush", "runoobkey", "redis")
    if err != nil {
        fmt.Println("redis set failed:", err)
    }

    _, err = c.Do("lpush", "runoobkey", "mongodb")
    if err != nil {
        fmt.Println("redis set failed:", err)
    }
    _, err = c.Do("lpush", "runoobkey", "mysql")
    if err != nil {
        fmt.Println("redis set failed:", err)
    }

    values, _ := redis.Values(c.Do("lrange", "runoobkey", "0", "100"))

    for _, v := range values {
        fmt.Println(string(v.([]byte)))
    }
}

輸出：
mysql
mongodb
redis

管道

請求/響應服務可以實現持續處理新請求，即使客戶端沒有準備好讀取舊響應。這樣客戶端可以傳送多個命令到伺服器而無需等待響應，最後在一次讀取多個響應。這就是管道化(pipelining)，這個技術在多年就被廣泛使用了。距離，很多POP3協議實現已經支援此特性，顯著加速了從伺服器下載新郵件的過程。
Redis很早就支援管道化，所以無論你使用任何版本，你都可以使用管道化技術

連線支援使用Send()，Flush()，Receive()方法支援管道化操作

Send(commandName string, args ...interface{}) error
Flush() error
Receive() (reply interface{}, err error)

Send向連線的輸出緩衝中寫入命令。Flush將連線的輸出緩衝清空並寫入伺服器端。Recevie按照FIFO順序依次讀取伺服器的響應。下例展示了一個簡單的管道：

c.Send("SET", "foo", "bar")
c.Send("GET", "foo")
c.Flush()
c.Receive() // reply from SET
v, err = c.Receive() // reply from GET

Do方法組合了Send,Flush和 Receive方法。Do方法先寫入命令，然後清空輸出buffer，最後接收全部掛起響應包括Do方發出的命令的結果。如果任何響應中包含一個錯誤，Do返回錯誤。如果沒有錯誤，Do方法返回最後一個響應。

開源庫go-redis/redis的使用

獲取：

go get -u github.com/go-redis/redis

應用：

package main

import (
    "fmt"

    "github.com/go-redis/redis"
)

func main() {
    client := redis.NewClient(&redis.Options{
        Addr:     "127.0.0.1:6379",
        Password: "", // no password set
        DB:       0,  // use default DB
    })

    pong, err := client.Ping().Result()
    fmt.Println(pong, err)

    err = client.Set("key", "value", 0).Err()
    if err != nil {
        panic(err)
    }

    val, err := client.Get("key").Result()
    if err != nil {
        panic(err)
    }
    fmt.Println("key", val)

    val2, err := client.Get("key2").Result()
    if err == redis.Nil {
        fmt.Println("key2 does not exists")
    } else if err != nil {
        panic(err)
    } else {
        fmt.Println("key2", val2)
    }
}

輸出：
PONG
key value
key2 does not exists