go语言 Redis的使用和操作

Reids

Redis是一个开源的、使用C语言编写的、支持网络交互的、可基于内存也可持久化的Key-Value数据库。

Reids的特点

速度快，因为数据存在内存中，类似于HashMap，HashMap的优势就是查找和操作的时间复杂度都是O(1)
支持丰富数据类型，支持string，list，set，sorted set，hash
支持事务，操作都是原子性，所谓的原子性就是对数据的更改要么全部执行，要么全部不执行
丰富的特性：可用于缓存，消息，按key设置过期时间，过期后将会自动删除
可以对数据进行持久化和数据同步
Redis是单进程单线程的

golang操作Redis

redigo是GO语言的一个redis客户端实现。项目位于地址

安装

go get github.com/garyburd/redigo/redis

redigo的使用

连接

package main
import (
    "fmt"
    "github.com/garyburd/redigo/redis"
)
func main() {
    cnn, err := redis.Dial("tcp", "localhost:6379")
    if err != nil {
        fmt.Println("Connect to redis error", err)
        return
    }else {
        fmt.Println("连接成功")
    }
    defer cnn.Close()
}

命令

数据类型转换

go对应redis的数据类型

Go Type	Conversion
[]byte	Sent as is
string	Sent as is
int, int64	strconv.FormatInt(v)
float64	strconv.FormatFloat(v, 'g', -1, 64)
bool	true -> "1", false -> "0"
nil	""
all other types	fmt.Print(v)

Redis 命令响应会用以下Go类型表示：

Redis type	Go type
error	redis.Error
integer	int64
simple string	string
bulk string	[]byte or nil if value not present.
array	[]interface{} or nil if value not present.

可以使用GO的类型断言或者reply辅助函数将返回的interface{}转换为对应类型
Do方法组合了Send,Flush和 Receive方法。Do方法先写入命令，然后清空输出buffer，最后接收全部挂起响应包括Do方发出的命令的结果。如果任何响应中包含一个错误，Do返回错误。如果没有错误，Do方法返回最后一个响应。

读写

写入值永不过期

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

写入值10S后过期

_, err = c.Do("SET", "password", "123456", "EX", "10")
if err != nil {
fmt.Println("redis set failed:", err)
}

简单读

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

批量读写

批量读写

key:=make([]string,5)
value:=make([]string,5)
for i:=0;i<5 ;i++  {
    key=append(key,string(i) )
    value=append(value,string(i) )
}
_, err = cnn.Do("MSET", key,value)
if err != nil {
    fmt.Println("redis set failed:", err)
}
val,err:= cnn.Do("MGET",key)
if err != nil {
    fmt.Println("redis set failed:", err)
}

批量写入读取对象(Hashtable)

HMSET key field value [field value ...]
HMGET key field [field ...]

检测key值是否存在

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

删除key

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

设置过期时间

n, _ := rs.Do("EXPIRE", key, 24*3600)  
if n == int64(1) {  
    fmt.Println("success")  
}

管道

请求/响应服务可以实现持续处理新请求，即使客户端没有准备好读取旧响应。这样客户端可以发送多个命令到服务器而无需等待响应，最后在一次读取多个响应。这就是管道化(pipelining)，这个技术在多年就被广泛使用了。

c.Send("SET", "foo", "bar")//Send向连接的输出缓冲中写入命令
c.Send("GET", "foo")//
c.Flush()//Flush将连接的输出缓冲清空并写入服务器端
//Recevie按照FIFO顺序依次读取服务器的响应
c.Receive() // reply from SET
v, err = c.Receive() // reply from GET

Do方法组合了Send,Flush和 Receive方法。Do方法先写入命令，然后清空输出buffer，最后接收全部挂起响应包括Do方发出的命令的结果。如果任何响应中包含一个错误，Do返回错误。如果没有错误，Do方法返回最后一个响应。

并发

连接并不支持并发调用写入方法(Send,Flush)或者读取方法（Receive）。但是连接支持并发的读写。

因为Do方法组合了Send，Flush和Receive，Do不可以与其他方法并发执行

连接池

package main
import (
    "fmt"
    "github.com/garyburd/redigo/redis"
    "runtime"
    "sync"
    "time"
)
var w sync.WaitGroup
func newRdsPool(server, auth string) *redis.Pool {
    return &redis.Pool{
        //最大空闲
        MaxIdle:     100,
        //最大活动量
        MaxActive:   30,
        //空闲超时
        IdleTimeout: 60 * time.Second,
        Dial: func() (redis.Conn, error) {
            c, err := redis.Dial("tcp", server)
            if err != nil {
                return nil, err
            }
            if auth == "" {
                return c, err
            }
            if _, err := c.Do("AUTH", auth); err != nil {
                c.Close()
                return nil, err
            }
            return c, err
        },
        TestOnBorrow: func(c redis.Conn, t time.Time) error {
            _, err := c.Do("PING")
            return err
        },
    }
}
func main() {
    w.Add(2)
    runtime.GOMAXPROCS(runtime.NumCPU())
    var rc1 redis.Conn = newRdsPool(`127.0.0.1:6379`, ``).Get()
    defer rc1.Close()
}