Go实战--golang中使用redis(redigo和go-redis/redis)

go get github.com/alphazero/Go-Redis
go get github.com/simonz05/godis
go get github.com/garyburd/redigo
go get github.com/gosexy/redis
go get cgl.tideland.biz/redis

目前这五种

开源库redigo的使用

github地址：
https://github.com/garyburd/redigo

文档地址：
http://godoc.org/github.com/garyburd/redigo/redis

获取：

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)
        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,"superWang","EX","5")
    if err != nil {
        fmt.Println("redis set failed:",username)
    }

    time.Sleep(8 * time.Second)

    username,err = redis.String(c.Do("GET",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)
    }

    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,username)
    }

    _,err = c.Do("DEL","mykey")
    if err != nil {
        fmt.Println("redis delelte failed:",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)
        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",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 = c.Do("lpush","runoobkey","redis")
    if err != nil {
        fmt.Println("redis set failed:",err)
    }

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

    values,_ := redis.Values(c.Do("lrange","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的使用

github地址：
https://github.com/go-redis/redis

文档地址：
https://godoc.org/github.com/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

（编辑：李大同）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!