go语言和redis数据库

1通过go语言和redis数据库进行交互

安装命令

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

安装完成后，回到家目录创建test.go,把下面代码复制到test.go里面，编译执行test.go，之后在redis中查找到键c1值为hello，说明安装成功

package main
import ( "github.com/gomodule/redigo/redis")
func main(){
        conn,_ := redis.Dial("tcp", ":6379")
        defer conn.Close()
        conn.Do("set", "c1", "hello")
}
1
2
3
4
5
6
7

2操作方法

Go操作redis文档https://godoc.org/github.com/gomodule/redigo/redis
1

连接数据库

Dial(network, address string)（conn,err）
1

执行数据库操作命令

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

Send函数发出指令，flush将连接的输出缓冲区刷新到服务器，Receive接收服务器返回的数据
例如：

c.Send("SET", "foo", "bar")
c.Send("GET", "foo")
c.Flush()//把缓冲区命令发到服务器
c.Receive() // 接收set请求返回的数据
v, err = c.Receive() // 接收get请求传输的数据
1
2
3
4
5

示例

//连接数据库
	conn, err := redis.Dial("tcp", "127.0.0.1:6379")
	if err != nil {
		c.Ctx.WriteString("连接redis")
		logs.Info("redis err", err)
		return
	}
	defer conn.Close()
	//执行操作数据库语句 send放到缓冲区
	err = conn.Send("set", "ca", "xxxx")
	if err != nil {
		logs.Info("send 发送失败", err)
		return
	}

	err = conn.Flush() //把缓冲区命令发到服务器 刷缓冲器
	if err != nil {
		logs.Info("Flush 缓冲失败", err)
		return
	}
	receive, err := conn.Receive()  接收set请求返回的数据
	if err != nil {
		logs.Info("Receive 返回失败", err)
		return
	}
	logs.Info(receive)
	//返回结果
	c.Ctx.WriteString("执行成功")
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

另外一种执行数据库操作命令

Do(commandName string, args ...interface{}) (reply interface{}, err error)
1

reply helper functions（回复助手函数）

Bool，Int，Bytes，map，String，Strings和Values函数将回复转换为特定类型的值。为了方便地包含对连接Do和Receive方法的调用，这些函数采用了类型为error的第二个参数。如果错误是非nil，则辅助函数返回错误。如果错误为nil，则该函数将回复转换为指定的类型：

exists, err := redis.Bool(c.Do("EXISTS", "foo"))
if err != nil {
//处理错误代码
}
reflect.TypeOf(exists)//打印exists类型
1
2
3
4
5

Scan函数

func Scan(src [] interface {},dest ... interface {})([] interface {},error)
1

Scan函数从src复制到dest指向的值。
Dest参数的值必须是整数，浮点数，布尔值，字符串，[]byte，interface{}或这些类型的切片。Scan使用标准的strconv包将批量字符串转换为数字和布尔类型。
示例代码

var value1 int
var value2 string
reply, err := redis.Values(c.Do("MGET", "key1", "key2"))
if err != nil {
    //处理错误代码
}
 if _, err := redis.Scan(reply, &value1, &value2); err != nil {
    // 处理错误代码
}
1
2
3
4
5
6
7
8
9

示例

//连接数据库
	conn, err := redis.Dial("tcp", "127.0.0.1:6379")
	if err != nil {
		c.Ctx.WriteString("连接redis")
		logs.Info("redis err", err)
		return
	}

	do, err := conn.Do("get", "chengpeng")
	if err != nil {
		return
	}

	//回复助手函数
	string, err := redis.String(do, err)
	if err != nil {
		c.Ctx.WriteString("获取内容出错")
		logs.Info("Strings", err)
		return
	}
	//返回结果
	c.Ctx.WriteString(string)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

案例结合

序列化与反序列化
序列化(字节化)

var buffer bytes.Buffer//容器
enc :=gob.NewEncoder(&buffer)//编码器
err:=enc.Encode(dest)//编码
1
2
3

反序列化（反字节化）

dec := gob.NewDecoder(bytes.NewReader(buffer.bytes()))//解码器
dec.Decode(&src)//解码
1
2

简单案例

//获取文章类型
	var types []models.ArticleType
	_, err = newOrm.QueryTable("ArticleType").All(&types)
	if err != nil {
		logs.Info("获取文章类型失败", err)
		return
	}
	//连接
	conn, err := redis.Dial("tcp", ":6379")
	if err != nil {
		logs.Info("redis连接失败", err)
		return
	}

	defer conn.Close()
	//编码操作
	var buffer1 bytes.Buffer            //容器
	encoder := gob.NewEncoder(&buffer1) //返回的是编码器 获取编码器

	err = encoder.Encode(types) //编码
	if err != nil {
		logs.Info("编码错误", err)
		return
	} //编码
	//操作数据 存入到redis
	_, err = conn.Do("set", "types", buffer1.Bytes())
	if err != nil {
		logs.Info("redis 存储失败", err)
		return
	}
	//没有相应的转换助手函数 获取数据
	resp, err := conn.Do("get", "types")
	if err != nil {
		logs.Info("获取失败", err)
		return
	}
	//助手函数
	data, err := redis.Bytes(resp, err)
	if err != nil {
		logs.Info("Bytes 获取失败", err)
		return
	}
	//解码
	newEncoder := gob.NewDecoder(bytes.NewReader(data)) //获取解码器
	var types2 []models.ArticleType
	err = newEncoder.Decode(&types2)
	if err != nil {
		logs.Info("解码失败", err)
		return
	}
	logs.Info("chengpeng", types2)
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

分析

//连接
conn, err := redis.Dial("tcp", ":6379")
if err != nil {
	logs.Info("redis连接失败", err)
	return
}

defer conn.Close()

var types []models.ArticleType
//var types2 []models.ArticleType

//没有相应的转换助手函数 获取数据
resp, err := conn.Do("get", "types")
if err != nil { //redis是否有数据
	//logs.Info("chengpengziye2222")
	//logs.Info("获取失败", err)
	//获取文章类型
	_, err = newOrm.QueryTable("ArticleType").All(&types)
	if err != nil {
		logs.Info("获取文章类型失败", err)
		return
	}
	//编码操作
	var buffer bytes.Buffer            //容器
	encoder := gob.NewEncoder(&buffer) //返回的是编码器 获取编码器

	err = encoder.Encode(types) //编码
	if err != nil {
		logs.Info("编码错误", err)
		return
	}
	//操作数据 存入到redis
	_, err = conn.Do("set", "types", buffer.Bytes())
	if err != nil {
		logs.Info("redis 存储失败", err)
		return
	}
} else {
	//logs.Info("chengpengziye")
	//助手函数
	data, err := redis.Bytes(resp, err)
	if err != nil {
		logs.Info("Bytes 获取失败", err)
		return
	}
	//解码
	newEncoder := gob.NewDecoder(bytes.NewReader(data)) //获取解码器
	err = newEncoder.Decode(&types)
	if err != nil {
		logs.Info("解码失败", err)
		return
	}
}
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
52
53
54

go语言redis-cluster开源客户端
安装：

go get github.com/gitstliu/go-redis-cluster
1

示例代码

func (this*ClusterController)Get(){
	cluster, _ := redis.NewCluster(
		&redis.Options{
			StartNodes: []string{"192.168.110.37:7000", "192.168.110.37:7001", "192.168.110.37:7002","192.168.110.38:7003","192.168.110.38:7004","192.168.110.38:7005"},
			ConnTimeout: 50 * time.Millisecond,
			ReadTimeout: 50 * time.Millisecond,
			WriteTimeout: 50 * time.Millisecond,
			KeepAlive: 16,
			AliveTime: 60 * time.Second,
		})
	cluster.Do("set","name","itheima")

	name,_ := redis.String(cluster.Do("get","name"))
	beego.Info(name)
	this.Ctx.WriteString("集群创建成功")
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

后续上传到代码上地址在上一篇上