Golang与Redis

文章目录

1. 知识储备

知道Redis是个啥?

知道Redis的基础命令怎么操作

测试的环境中安装了Redis的服务端(无论是win还Linux环境)

Go语言基础知识

Redis命令参考

2. 安装redis客户端

Go语言的Redi客户端包很多,我们只取最常见的Redis包.

如下我们列出Redis常见的包,这些包在github都可以查询到,如下列出的两个包更新较快,功能齐全

包名 github地址参考文档

go-redis/redis https://github.com/go-redis/redis https://godoc.org/github.com/go-redis/redis

gomodule/redigo https://github.com/gomodule/redigo https://godoc.org/github.com/gomodule/redigo/redis

我们选择安装其中一个包即可,此处选择是go-redis这个包
go get -u github.com/go-redis/redis

包名	github地址	参考文档
go-redis/redis	https://github.com/go-redis/redis	https://godoc.org/github.com/go-redis/redis
gomodule/redigo	https://github.com/gomodule/redigo	https://godoc.org/github.com/gomodule/redigo/redis

3. 常见的全局命令

全局命令是对任意类型的键都有效果的

代码中展示的只是部分命令的使用

package main

import (
	"fmt"
	"github.com/go-redis/redis"
	"time"
)
// 定义一组常量
const (
	REDIS_IP   = "127.0.0.1"
	REDIS_PORT = "6379"
	REDIS_PWD  = ""
	REDIS_DB   = 0
)
// 定义一个redis.client类型的变量
var client *redis.Client
// 初始化函数
func init() {
	// 实例化一个redis客户端
	client = redis.NewClient(&redis.Options{
        Addr:     REDIS_IP + ":" + REDIS_PORT, // ip:port
		Password: REDIS_PWD,				   // redis连接密码
		DB:       REDIS_DB,					   // 选择的redis库
		PoolSize: 20,						   // 设置连接数,默认是10个连接
	})
}
func main() {
	// redis 全局命令
	// 获取redis所有的键,返回包含所有键的slice
	keys := client.Keys("*").Val()
	fmt.Println(keys)
	// 获取redis中的有多少个键,返回整数
	size := client.DbSize().Val()
	fmt.Println(size)
	// 判断一个键是否存在,有一个存在返回整数1,有两个存在返回整数2...
	exist := client.Exists("age","name").Val()
	fmt.Println(exist)
	// 删除键,删除成功返回删除的数,删除失败返回0
	del := client.Del("unknownKey").Val()
	fmt.Println(del)
	// 查看键的有效时间
	ttl := client.TTL("age").Val()
	fmt.Println(ttl)
	// 给键设置有效时间,设置成功返回true,失败返回false
	expire := client.Expire("age",time.Second*86400).Val()
	fmt.Println(expire)
	// 查看键的类型(string,hash,list,set,zset...)
	Rtype := client.Type("store:finish:bill:list").Val()
	fmt.Println(Rtype)
	// 给键重命令,成功返回true,失败false
	Rname := client.RenameNX("age","newAge").Val()
	fmt.Println(Rname)
	// 从redis中随机返回一个键
	key := client.RandomKey().Val()
	fmt.Println(key)

}

4. Redis的string类型操作

package main

import (
	"fmt"
	"github.com/go-redis/redis"
	"time"
)

// 定义一组常量
const (
	REDIS_IP   = "127.0.0.1"
	REDIS_PORT = "6379"
	REDIS_PWD  = ""
	REDIS_DB   = 0
)

// 定义一个redis.client类型的变量
var client *redis.Client

// 初始化函数
func init() {
	// 实例化一个redis客户端
	client = redis.NewClient(&redis.Options{
		Addr:     REDIS_IP + ":" + REDIS_PORT, // ip_port
		Password: REDIS_PWD,                   // redis连接密码
		DB:       REDIS_DB,                    // 选择的redis库
		PoolSize: 20,                          // 设置连接数,默认是10个连接
	})
}
func main() {
	defer client.Close()
	defer func() {
		if err := recover(); err != nil {
			fmt.Println(err)
		}
	}()
	// 设置一组键值对,并社会有效期
	set1 := client.Set("age", 10, time.Hour*24).Val()
	fmt.Println(set1) // OK
	//设置一组键值对,设置的键不存在的时候才能设置成功
	set2 := client.SetNX("age", "20", time.Hour*12).Val()
	fmt.Println(set2) // false
	//设置一组键值对,设置的键必须存在的时候才能设置成功
	set3 := client.SetXX("age", "30", time.Second*86400).Val()
	fmt.Println(set3) // true
	// 批量设置
	set4 := client.MSet("age1", "40", "age2", "50").Val()
	fmt.Println(set4) // OK
	// 获取一个键的值
	get1 := client.Get("age2").Val()
	fmt.Println(get1) // 50
	// 批量获取,获取成功返回slice类型的结果数据
	get2 := client.MGet("age", "age1", "age2").Val()
	fmt.Println(get2) // [30 40 50]
	// 对指定的键进行自增操作
	incr1 := client.Incr("age").Val()
	fmt.Println(incr1) // 31
	// 对指定键进行自减操作
	decr1 := client.Decr("age1").Val()
	fmt.Println(decr1) //39
	// 自增指定的值
	incr2 := client.IncrBy("age", 10).Val()
	fmt.Println(incr2) // 41
	// 自减指定的值
	decr2 := client.DecrBy("age1", 10).Val()
	fmt.Println(decr2) // 29
	// 在key后面追加指定的值,返回字符串的长度
	append1 := client.Append("age2", "abcd").Val()
	fmt.Println(append1) // 6
	// 获取一个键的值得长度
	strlen1 := client.StrLen("age2").Val()
	fmt.Println(strlen1) //6
	// 设置一个键的值,并返回原有的值
	getset1 := client.GetSet("age2", "hello golang").Val()
	fmt.Println(getset1) // 50abcd
	// 设置键的值,在指定的位置
	_ = client.SetRange("age2", 0, "H")
	fmt.Println(client.Get("age2").Val()) // Hello golang
	// 截取一个键的值的部分,返回截取的部分
	newStr := client.GetRange("age2", 6, 11).Val()
	fmt.Println(newStr) //golang
}

5. Redis的hash类型操作

package main

import (
	"fmt"
	"github.com/go-redis/redis"
)

// 定义一组常量
const (
	REDIS_IP   = "127.0.0.1"
	REDIS_PORT = "6379"
	REDIS_PWD  = ""
	REDIS_DB   = 0
)

// 定义一个redis.client类型的变量
var client *redis.Client

// 初始化函数
func init() {
	// 实例化一个redis客户端
	client = redis.NewClient(&redis.Options{
		Addr:     REDIS_IP + ":" + REDIS_PORT, // ip_port
		Password: REDIS_PWD,                   // redis连接密码
		DB:       REDIS_DB,                    // 选择的redis库
		PoolSize: 20,                          // 设置连接数,默认是10个连接
	})
}
func main() {
	defer client.Close()
	defer func() {
		if err := recover(); err != nil {
			fmt.Println(err)
		}
	}()
	key := "account"
	field1 := "name"
	fields := map[string]interface{}{
		"addr":"beijing",
		"age":99,
		"skills":"golang",
		"demo1":"aaa",
		"demo2":"bbb",
	}
	//hash 设置一个键的field
	_ = client.HSet(key,field1,"zhangsan")
	// hash 批量设置 ,第二个参数是map类型
	status := client.HMSet(key,fields).Val()
	fmt.Println(status) //ok
	// hash 删除键的field,返回删除field的个数
	 _ = client.HDel(key,"demo2").Val()
	 //hash 获取field的值
	name := client.HGet(key,"name").Val()
	fmt.Println(name) //zhangsan
	//hash 获取多个field值,返回slice
	values := client.HMGet(key,"name","age").Val()
	fmt.Println(values)//[zhangsan 99]
	//hash 获取所有的值 返回map
	valueAll := client.HGetAll(key).Val()
	fmt.Println(valueAll) //map[addr:beijing age:99 demo1:aaa name:zhangsan skills:golang]
	// hash 获取所有field 返回slice
	fs := client.HKeys(key).Val()
	fmt.Println(fs) //[name addr age skills demo1]
	// hash 获取所有filed的值 返回slice
	vs := client.HVals(key).Val()
	fmt.Println(vs) //[zhangsan beijing 99 golang aaa]
	// 判断一个filed是否存在 返回bool
	e := client.HExists(key,"skills").Val()
	fmt.Println(e) //true
	// hash field自增
	n := client.HIncrBy(key,"age",1).Val()
	fmt.Println(n) //100
}

6. Redis的list类型操作

package main

import (
	"fmt"
	"github.com/go-redis/redis"
	"strconv"
)

// 定义一组常量
const (
	REDIS_IP   = "127.0.0.1"
	REDIS_PORT = "6379"
	REDIS_PWD  = ""
	REDIS_DB   = 0
)

// 定义一个redis.client类型的变量
var client *redis.Client

// 初始化函数
func init() {
	// 实例化一个redis客户端
	client = redis.NewClient(&redis.Options{
		Addr:     REDIS_IP + ":" + REDIS_PORT, // ip_port
		Password: REDIS_PWD,                   // redis连接密码
		DB:       REDIS_DB,                    // 选择的redis库
		PoolSize: 20,                          // 设置连接数,默认是10个连接
	})
}
func main() {
	defer client.Close()
	defer func() {
		if err := recover(); err != nil {
			fmt.Println(err)
		}
	}()
	key := "demo"
	client.Del(key)
	for i := 0; i < 5; i++ {
		client.LPush(key, "e-"+strconv.Itoa(i))
	}
	// 获取list 长度
	length := client.LLen(key).Val()
	fmt.Println(length) //5
	// 获取指定下标元素
	value1 := client.LIndex(key, 0).Val()
	fmt.Println(value1) //e-4
	// 获取所有元素
	vs := client.LRange(key, 0, -1).Val()
	fmt.Println(vs) //[e-4 e-3 e-2 e-1 e-0]
	// 修改指定下标的元素值
	status := client.LSet(key, 0, "golang").Val()
	fmt.Println(status) //ok
	// 从右边插入元素
	client.RPush(key, "e-right")
	// 从左边插入元素
	client.LPush(key, "e-left")
	// 从list最右边弹出元素
	v1 := client.RPop(key).Val()
	fmt.Println(v1) // e-right
	// 从list最左边弹出元素
	v2 := client.LPop(key).Val()
	fmt.Println(v2) // e-left
	// 删除指定元素
	n := client.LRem(key, 0, "e-3").Val()
	fmt.Println(n) //1
	status1 := client.LTrim(key, 0, 1).Val()
	fmt.Println(status1) //ok

}

7. Redis的set类型操作

package main

import (
	"fmt"
	"github.com/go-redis/redis"
	"strconv"
)

// 定义一组常量
const (
	REDIS_IP   = "127.0.0.1"
	REDIS_PORT = "6379"
	REDIS_PWD  = ""
	REDIS_DB   = 0
)

// 定义一个redis.client类型的变量
var client *redis.Client

// 初始化函数
func init() {
	// 实例化一个redis客户端
	client = redis.NewClient(&redis.Options{
		Addr:     REDIS_IP + ":" + REDIS_PORT, // ip_port
		Password: REDIS_PWD,                   // redis连接密码
		DB:       REDIS_DB,                    // 选择的redis库
		PoolSize: 20,                          // 设置连接数,默认是10个连接
	})
}
func main() {
	defer client.Close()
	defer func() {
		if err := recover(); err != nil {
			fmt.Println(err)
		}
	}()
	key := "sdemo"
	key1 := "sdemo1"
	client.Del(key)
	client.Del(key1)
	for i := 0; i < 6; i++ {
		// set 类型添加元素
		client.SAdd(key, "ele-"+strconv.Itoa(i))
	}
	for i := 3; i < 9; i++ {
		// set 类型添加元素
		client.SAdd(key1, "ele-"+strconv.Itoa(i))
	}
	// 计算key中的元素个数
	n1 := client.SCard(key).Val()
	fmt.Println(n1) //5
	// 判断元素是否在集合中
	e1 := client.SIsMember(key, "ele-0").Val()
	fmt.Println(e1) // true
	// 随机从集合中返回一个元素
	v1 := client.SRandMember(key).Val()
	fmt.Println(v1)
	// 随机返回指定个数的元素,返回包含元素的slice
	v2 := client.SRandMemberN(key, 3).Val()
	fmt.Println(v2)
	// 获取集合中的所有元素,无序的slice
	v3 := client.SMembers(key).Val()
	fmt.Println(v3) //[ele-1 ele-0 ele-3 ele-2 ele-4]
	// 从集合中随机弹出一个元素
	v4 := client.SPop(key).Val()
	fmt.Println(v4)
	// 从集合中删除元素
	n2 := client.SRem(key, "ele-5").Val()
	fmt.Println(n2) //1
	// 求多个集合的交集
	s1 := client.SInter(key, key1).Val()
	fmt.Println(s1) // [ele-3 ele-4]
	//求多个集合的并集
	s2 := client.SUnion(key, key1).Val()
	fmt.Println(s2) // [ele-3 ele-5 ele-1 ele-2 ele-4 ele-8 ele-6 ele-0 ele-7]
	// 求多个集合的差集
	s3 := client.SDiff(key, key1).Val()
	fmt.Println(s3) // [ele-0 ele-1]
	// 将多个交集结果存为一个新的集合
	s4 := client.SInterStore("sdemo2", key, key1).Val()
	fmt.Println(s4)                              //2
	fmt.Println(client.SMembers("sdemo2").Val()) // [ele-4 ele-3]
	// 将多个交集的并集结果存为新的集合
	s5 := client.SUnionStore("sdemo3", key, key1).Val()
	fmt.Println(s5)                              //8
	fmt.Println(client.SMembers("sdemo3").Val()) // [ele-3 ele-5 ele-1 ele-4 ele-7 ele-8 ele-6 ele-0]
	// 将多个差集的结果存为新的集合
	s6 := client.SDiffStore("sdemo4", key, key1).Val()
	fmt.Println(s6)                              //2
	fmt.Println(client.SMembers("sdemo4").Val()) // [ele-0 ele-1]
}

8. Redis的zset类型操作

package main

import (
	"fmt"
	"github.com/go-redis/redis"
	"math/rand"
	"strconv"
)

// 定义一组常量
const (
	REDIS_IP   = "127.0.0.1"
	REDIS_PORT = "6379"
	REDIS_PWD  = ""
	REDIS_DB   = 0
)

// 定义一个redis.client类型的变量
var client *redis.Client

// 初始化函数
func init() {
	// 实例化一个redis客户端
	client = redis.NewClient(&redis.Options{
		Addr:     REDIS_IP + ":" + REDIS_PORT, // ip_port
		Password: REDIS_PWD,                   // redis连接密码
		DB:       REDIS_DB,                    // 选择的redis库
		PoolSize: 20,                          // 设置连接数,默认是10个连接
	})
}
func randString(n int) string {
	s := "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
	b := make([]byte, n)
	for i := range b {
		b[i] = s[rand.Intn(len(s))]
	}
	return string(b)
}
func main() {
	defer client.Close()
	defer func() {
		if err := recover(); err != nil {
			fmt.Println(err)
		}
	}()
	key := "zdemo"
	key1 := "zdemo1"
	client.Del(key)
	client.Del(key1)
	for i := 0; i < 10; i++ {
		score := float64(rand.Intn(100) - 50)
		member := "golang-" + strconv.Itoa(i)
		data := &redis.Z{
			score,
			member,
		}
		// 向有序集合中添加成员
		client.ZAdd(key, data).Val()
	}
	for i := 0; i < 5; i++ {
		score := float64(rand.Intn(100) - 50)
		member := "golang-" + strconv.Itoa(i)
		data := &redis.Z{
			score,
			member,
		}
		// 向有序集合中添加成员
		client.ZAdd(key1, data).Val()
	}
	// 计算成员个数
	n1 := client.ZCard(key).Val()
	fmt.Println(n1) //10
	// 获取成员分数
	s1 := client.ZScore(key, "golang-6").Val()
	fmt.Println(s1) // -25
	// 修改成员分数
	v1 := client.ZIncrBy(key, 60.00, "golang-6").Val()
	fmt.Println(v1)
	// 从低到高返回排名
	s2 := client.ZRank(key, "golang-6").Val()
	fmt.Println(s2) //8
	// 从高到低返回排名
	s3 := client.ZRevRank(key, "golang-6").Val()
	fmt.Println(s3) //1
	// 获取指定范围的成员排名,从低到高排名
	s4 := client.ZRange(key, 0, n1-5).Val()
	fmt.Println(s4) //[golang-9 golang-5 golang-7 golang-2 golang-8 golang-3]
	// 获取指定范围的成员排名,从高到低排名
	s5 := client.ZRevRange(key, 0, n1-5).Val()
	fmt.Println(s5) //[golang-1 golang-6 golang-4 golang-0 golang-3 golang-8]
	// 删除成员
	v2 := client.ZRem(key, "golang-6").Val()
	fmt.Println(v2) //1
	// 计算两个有序集合的交集
	key2 := "zdemo2"
	kslice := []string{key, key1}
	wslice := []float64{1.00, 1.00}
	z := &redis.ZStore{
		kslice,
		wslice,
		"SUM",
	}
	r1 := client.ZInterStore(key2, z).Val()
	fmt.Println(r1) //5
	// 计算两个有序集合的并集
	key3 := "zdemo3"
	r2 := client.ZUnionStore(key3,z).Val()
	fmt.Println(r2) // 9

}

9. Redis简单的订阅/发布

订阅多频道的demo

subscription.go

package main

import (
	"fmt"
	"github.com/go-redis/redis"
)

// 定义一组常量
const (
	REDIS_IP   = "127.0.0.1"
	REDIS_PORT = "6379"
	REDIS_PWD  = ""
	REDIS_DB   = 0
)

// 定义一个redis.client类型的变量
var client *redis.Client

// 初始化函数
func init() {
	// 实例化一个redis客户端
	client = redis.NewClient(&redis.Options{
		Addr:     REDIS_IP + ":" + REDIS_PORT, // ip_port
		Password: REDIS_PWD,                   // redis连接密码
		DB:       REDIS_DB,                    // 选择的redis库
		PoolSize: 20,                          // 设置连接数,默认是10个连接
	})
}
func main() {
	defer client.Close()
	defer func() {
		if err := recover(); err != nil {
			fmt.Println(err)
		}
	}()
	// 订阅多个频道
	sub := client.PSubscribe("news", "it", "sports", "shopping")
	_, err := sub.Receive()
	if err != nil {
		fmt.Println(err)
	}
	// 消息通道
	ch := sub.Channel()
	//  从通道中读取消息
	for message := range ch {
		fmt.Println(message.Channel, message.Payload)
	}
}

go run subscription.go

发布信息到不同频道的demo

publish.go

package main

import (
	"fmt"
	"github.com/go-redis/redis"
	"math/rand"
)

// 定义一组常量
const (
	REDIS_IP   = "127.0.0.1"
	REDIS_PORT = "6379"
	REDIS_PWD  = ""
	REDIS_DB   = 0
)

// 定义一个redis.client类型的变量
var client *redis.Client

// 初始化函数
func init() {
	// 实例化一个redis客户端
	client = redis.NewClient(&redis.Options{
		Addr:     REDIS_IP + ":" + REDIS_PORT, // ip_port
		Password: REDIS_PWD,                   // redis连接密码
		DB:       REDIS_DB,                    // 选择的redis库
		PoolSize: 20,                          // 设置连接数,默认是10个连接
	})
}

// 生成指定长度的随机字符串
func randString(n int) string {
	s := "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890"
	b := make([]byte, n)
	for i := range b {
		b[i] = s[rand.Intn(len(s))]
	}
	return string(b)
}
func main() {
	defer client.Close()
	defer func() {
		if err := recover(); err != nil {
			fmt.Println(err)
		}
	}()
	var data string
	var channels []string = []string{"news", "it", "sports", "shopping"}
	for {
		fmt.Printf("please input some data:")
		fmt.Scanln(&data)
		// 退出
		if data == "quit" {
			break
		}
		channel := channels[rand.Intn(4)]
		// 向一个频道发布消息
		result := client.Publish(channel, data+randString(10)).Val()
		if result == 1 {
			fmt.Println("send info to", channel,"success")
		}
	}
}

go run publish.go

测试

在发布消息的代码执行窗口,输入任意的消息

please input some data:asjdasd
send info to it success
please input some data:asdasd
send info to shopping success
please input some data:iii
send info to news success

在订阅代码的执行窗口接收消息

it asdasdpLnfgDsc3W
it asjdasdpLnfgDsc3W
shopping asdasd9F3qNfHK6a
news iii5jjJkwzDkh

文章目录

1. 知识储备

2. 安装redis客户端

3. 常见的全局命令

4. Redis的string类型操作

5. Redis的hash类型操作

6. Redis的list类型操作

7. Redis的set类型操作

8. Redis的zset类型操作

9. Redis简单的订阅/发布

Go Modules基礎

Golang與變量

Golang操作MySql

Go語言入門教程-小案例-基礎排序程序

Golang結構體struct

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結