Go连接redis

发表于 更新于 分类于 ，

Go使用redis

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

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

获取:

1
go get github.com/garyburd/redigo/redis

连接redis:

1
2
3
4
5
6
7
8
9
10
func connectRedis() {
	// 连接redis
	conn, err := redis.Dial("tcp", "127.0.0.1:6379")
	if err != nil {
		fmt.Printf("connect redis error:%s\n", err)
		return
	}
	defer conn.Close()
}

读写:

这里写入的值不会过期

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

func readWriteRedis() {
	// 链接redis
	conn, err := redis.Dial("tcp", "127.0.0.1:6379")
	if err != nil {
		fmt.Printf("connect redis error:%s\n", err)
	}
	defer conn.Close()
	// 写入一个key为“mykey”,value为10的键值对 这里写入的键值对永远不会过期
	_, err = conn.Do("SET", "mykey", 10)
	if err != nil {
		fmt.Printf("redis set failed:%s\n", err)
		return
	}
	v, err := redis.Int(conn.Do("GET", "mykey"))
	if err != nil {
		fmt.Printf("redis get failed:%s\n", err)
		return
	}
	fmt.Printf("get mykey value:%d\n", v)
}

func main() {
	readWriteRedis()
}
---------------------
get mykey value:10

如何设置过期呢，可以使用SET的附加参数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
func readWriteRedisEx() {
	// 链接redis
	conn, err := redis.Dial("tcp", "127.0.0.1:6379")
	if err != nil {
		fmt.Printf("connect redis error:%s\n", err)
	}
	defer conn.Close()
	// 写入一个Key并设置它的过期时间
	_, err = conn.Do("SET", "extime", 5, "EX", "5")
	if err != nil {
		fmt.Printf("redis set failed:%s\n", err)
		return
	}
	v, err := redis.Int(conn.Do("GET", "extime"))
	if err != nil {
		fmt.Printf("redis get failed:%s\n", err)
		return
	}
	fmt.Printf("get mykey value:%d\n", v)
	// 睡眠5秒再次读取
	time.Sleep(time.Second * 6)

	v, err = redis.Int(conn.Do("GET", "extime"))
	if err != nil {
		// 由于key设置了超时时间是5秒  这里无法读到key的值
		fmt.Printf("redis get failed:%s\n", err)
		return
	}
	fmt.Printf("get mykey value:%d\n", v)
}

func main() {
	readWriteRedisEx()
}

---------------------------------
get mykey value:5
redis get failed:redigo: nil returned

批量写入 读取

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
func batchReadWriteRedis() {
	conn, err := redis.Dial("tcp", "127.0.0.1:6379")
	if err != nil {
		fmt.Printf("connect redis error:%s\n", err)
		return
	}
	defer conn.Close()
	// 批量设置key
	_, err = conn.Do("MSET", "mykey1", "key1", "mykey2", "key2", "mykey3", "key3")
	if err != nil {
		fmt.Printf("redis mset failed:%s\n", err)
		return
	}
	// 批量读取
	v, err := redis.Strings(conn.Do("MGET", "mykey1", "mykey2", "mykey3"))
	if err != nil {
		fmt.Printf("redis mget faild:%s\n", err)
		return
	}
	for index, val := range v {
		fmt.Printf("the %d value is:%s\n", index, val)
	}
}

func main() {
	batchReadWriteRedis()
}
-------------------------------------
the 0 value is:key1
the 1 value is:key2
the 2 value is:key3

使用redis连接池，EXISTS检测值是否存在

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
import (
	"encoding/json"
	"fmt"
	"time"

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

var pool *redis.Pool

func init() {
	pool = &redis.Pool{
		// 最大空闲连接数
		MaxIdle: 16,
		//池在给定时间分配的最大连接数。当为零时，池中的连接数没有限制。
		MaxActive: 0,
		//在此期间保持空闲后关闭连接。 如果该值为零，则不关闭空闲连接。 应用程序应将超时设置为小于服务器超时的值。
		IdleTimeout: 300,
		// Dial是应用程序提供的功能，用于创建和配置连接。 从Dial返回的连接不能处于特殊状态（订阅pubsub通道，事务已启动，...）。
		Dial: func() (redis.Conn, error) {
			return redis.Dial("tcp", "127.0.0.1:6379")
		},
	}
}

// 使用连接池
func existsKey() {
	// 从连接池中获取连接
	conn := pool.Get()
	// 用完后把连接放回连接池
	defer conn.Close()
	b, err := redis.Bool(conn.Do("EXISTS", "mykey"))
	if err != nil {
		fmt.Printf("redis exists error:%s\n", err)
		return
	}
	if b {
		fmt.Println("key exist")
	} else {
		fmt.Println("Key does not exist")
	}
}

func main() {
	existsKey()
}
----------------------------
key exist

把json写到redis

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
import (
	"encoding/json"
	"fmt"
	"time"

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

var pool *redis.Pool

func init() {
	pool = &redis.Pool{
		// 最大空闲连接数
		MaxIdle: 16,
		//池在给定时间分配的最大连接数。当为零时，池中的连接数没有限制。
		MaxActive: 0,
		//在此期间保持空闲后关闭连接。 如果该值为零，则不关闭空闲连接。 应用程序应将超时设置为小于服务器超时的值。
		IdleTimeout: 300,
		// Dial是应用程序提供的功能，用于创建和配置连接。 从Dial返回的连接不能处于特殊状态（订阅pubsub通道，事务已启动，...）。
		Dial: func() (redis.Conn, error) {
			return redis.Dial("tcp", "127.0.0.1:6379")
		},
	}
}

// 把json写到redis
func jsonToRedis() {
	key := "stu01"
	imap := map[string]string{"username": "张三", "age": "10", "phone": "13773943000"}
	value, err := json.Marshal(imap)
	if err != nil {
		fmt.Println("map to json error")
		return
	}
	conn := pool.Get()
	defer conn.Close()
	_, err = conn.Do("SET", key, value)
	if err != nil {
		fmt.Println("set key error")
		return
	}

	v, err := redis.String(conn.Do("GET", key))
	if err != nil {
		fmt.Println("get key error")
		return
	}
	fmt.Println("value is:", v)
}
------------------------------
value is: {"age":"10","phone":"13773943000","username":"张三"}

为已存在的key设置过期时间

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
import (
	"encoding/json"
	"fmt"
	"time"

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

var pool *redis.Pool

func init() {
	pool = &redis.Pool{
		// 最大空闲连接数
		MaxIdle: 16,
		//池在给定时间分配的最大连接数。当为零时，池中的连接数没有限制。
		MaxActive: 0,
		//在此期间保持空闲后关闭连接。 如果该值为零，则不关闭空闲连接。 应用程序应将超时设置为小于服务器超时的值。
		IdleTimeout: 300,
		// Dial是应用程序提供的功能，用于创建和配置连接。 从Dial返回的连接不能处于特殊状态（订阅pubsub通道，事务已启动，...）。
		Dial: func() (redis.Conn, error) {
			return redis.Dial("tcp", "127.0.0.1:6379")
		},
	}
}

func setExpire() {
	conn := pool.Get()
	defer conn.Close()
	// 这里单位是秒
	_, err := conn.Do("EXPIRE", "mykey", 5)
	if err != nil {
		fmt.Println("redus expire error")
		return
	}
}

func main() {
	setExpire()
}