前言
Redis 是一个基于内存的非关系型数据库，在项目开发中使用非常广泛，在go语言中，有着一些封装的组件库操作redis,go-redis也是一个比较优秀的操作redis的三方库，封装了一堆非常方便的api供开发者调用
go-redis操作redis
依赖安装
使用下面的命令安装go-redis三方库依赖
go get -u github.com/go-redis/redis
go-redis操作redis
redis-go连接redis
package main
import (
"fmt"
"github.com/go-redis/redis"
)
// 声明一个全局的redisDb变量
var redisDb *redis.Client
// 根据redis配置初始化一个客户端
func init() {
redisDb = redis.NewClient(&redis.Options{
Addr: "127.0.0.0:6379", // redis地址
Password: "123456", // redis密码，没有则留空
DB: 0, // 默认数据库，默认是0
})
_, err := redisDb.Ping().Result()
if err != nil {
fmt.Println("连接redis异常", err)
return
}
fmt.Println("连接redis成功")
}
func main() {
}
Set和Get
使用Set和Get可以操作String
package main
import (
"fmt"
"github.com/go-redis/redis"
"time"
)
// 声明一个全局的redisDb变量
var redisDb *redis.Client
// 根据redis配置初始化一个客户端
func init() {
redisDb = redis.NewClient(&redis.Options{
Addr: "127.0.0.1:6379", // redis地址
Password: "123456", // redis密码，没有则留空
DB: 0, // 默认数据库，默认是0
})
_, err := redisDb.Ping().Result()
if err != nil {
fmt.Println("连接redis异常", err)
return
}
fmt.Println("连接redis成功")
}
func main() {
redisDb.Set("aa1", "aa", 0)
time.Sleep(10 * time.Second)
fmt.Println(redisDb.Get("aa1"))
}
Set方法中，如果想要键值不过期，那么就设置0，要想键值过期的话
package main
import (
"fmt"
"github.com/go-redis/redis"
"time"
)
// 声明一个全局的redisDb变量
var redisDb *redis.Client
// 根据redis配置初始化一个客户端
func init() {
redisDb = redis.NewClient(&redis.Options{
Addr: "127.0.0.1:6379", // redis地址
Password: "123456", // redis密码，没有则留空
DB: 0, // 默认数据库，默认是0
})
_, err := redisDb.Ping().Result()
if err != nil {
fmt.Println("连接redis异常", err)
return
}
fmt.Println("连接redis成功")
}
func main() {
redisDb.Set("aa1", "aa", 3*time.Second)
time.Sleep(5 * time.Second)
fmt.Println(redisDb.Get("aa1"))
}
输出
SetNX使用
package main
import (
"fmt"
"github.com/go-redis/redis"
)
// 声明一个全局的redisDb变量
var redisDb *redis.Client
// 根据redis配置初始化一个客户端
func init() {
redisDb = redis.NewClient(&redis.Options{
Addr: "127.0.0.1:6379", // redis地址
Password: "123456", // redis密码，没有则留空
DB: 0, // 默认数据库，默认是0
})
_, err := redisDb.Ping().Result()
if err != nil {
fmt.Println("连接redis异常", err)
return
}
fmt.Println("连接redis成功")
}
func main() {
a, err := redisDb.SetNX("test1", "aaa", 0).Result()
if err != nil {
fmt.Println("错误信息为:", err)
return
}
fmt.Println(a)
fmt.Println("设置成功")
}
如果键值存在，会返回false，不存在会返回true，第三个参数可以设置过期时间
GetSet方法
给定 key 的值设为 value ，并返回 key 的旧值，如果key值不存在，会返回错误值
package main
import (
"fmt"
"github.com/go-redis/redis"
)
// 声明一个全局的redisDb变量
var redisDb *redis.Client
// 根据redis配置初始化一个客户端
func init() {
redisDb = redis.NewClient(&redis.Options{
Addr: "127.0.0.1:6379", // redis地址
Password: "123456", // redis密码，没有则留空
DB: 0, // 默认数据库，默认是0
})
_, err := redisDb.Ping().Result()
if err != nil {
fmt.Println("连接redis异常", err)
return
}
fmt.Println("连接redis成功")
}
func main() {
a, err := redisDb.GetSet("aa111111", "aaa1").Result()
if err != nil {
fmt.Println("错误信息为:", err)
return
}
fmt.Println(a)
fmt.Println("设置成功")
}
Incr计数器
package main
import (
"fmt"
"github.com/go-redis/redis"
)
// 声明一个全局的redisDb变量
var redisDb *redis.Client
// 根据redis配置初始化一个客户端
func init() {
redisDb = redis.NewClient(&redis.Options{
Addr: "127.0.0.1:6379", // redis地址
Password: "123456", // redis密码，没有则留空
DB: 0, // 默认数据库，默认是0
})
_, err := redisDb.Ping().Result()
if err != nil {
fmt.Println("连接redis异常", err)
return
}
fmt.Println("连接redis成功")
}
func main() {
//Incr
result, err := redisDb.Incr("count1").Result()
if err != nil {
fmt.Println("错误信息为:", err)
return
}
fmt.Println(result)
fmt.Println("设置成功")
}
Decr递减计数器
package main
import (
"fmt"
"github.com/go-redis/redis"
)
// 声明一个全局的redisDb变量
var redisDb *redis.Client
// 根据redis配置初始化一个客户端
func init() {
redisDb = redis.NewClient(&redis.Options{
Addr: "127.0.0.1:6379", // redis地址
Password: "123456", // redis密码，没有则留空
DB: 0, // 默认数据库，默认是0
})
_, err := redisDb.Ping().Result()
if err != nil {
fmt.Println("连接redis异常", err)
return
}
fmt.Println("连接redis成功")
}
func main() {
//Incr
result, err := redisDb.Decr("count1").Result()
if err != nil {
fmt.Println("错误信息为:", err)
return
}
fmt.Println(result)
fmt.Println("设置成功")
}
del删除键值
package main
import (
"fmt"
"github.com/go-redis/redis"
)
// 声明一个全局的redisDb变量
var redisDb *redis.Client
// 根据redis配置初始化一个客户端
func init() {
redisDb = redis.NewClient(&redis.Options{
Addr: "127.0.0.1:6379", // redis地址
Password: "123456", // redis密码，没有则留空
DB: 0, // 默认数据库，默认是0
})
_, err := redisDb.Ping().Result()
if err != nil {
fmt.Println("连接redis异常", err)
return
}
fmt.Println("连接redis成功")
}
func main() {
result, err := redisDb.Del("aaa").Result()
if err != nil {
fmt.Println("错误信息为:", err)
return
}
fmt.Println(result)
fmt.Println("设置成功")
}
redis-go操作list
lPush和LRange使用
package main
import (
"fmt"
"github.com/go-redis/redis"
)
// 声明一个全局的redisDb变量
var redisDb *redis.Client
// 根据redis配置初始化一个客户端
func init() {
redisDb = redis.NewClient(&redis.Options{
Addr: "127.0.0.1:6379", // redis地址
Password: "123456", // redis密码，没有则留空
DB: 0, // 默认数据库，默认是0
})
_, err := redisDb.Ping().Result()
if err != nil {
fmt.Println("连接redis异常", err)
return
}
fmt.Println("连接redis成功")
}
func main() {
redisDb.LPush("list2", "aa", "bb")
// 返回从0开始到-1位置之间的数据，意思就是返回全部数据
list1, err := redisDb.LRange("list2", 0, -1).Result()
if err != nil {
fmt.Println("取出异常:", err)
return
}
fmt.Println(list1)
}
RPush使用
package main
import (
"fmt"
"github.com/go-redis/redis"
)
// 声明一个全局的redisDb变量
var redisDb *redis.Client
// 根据redis配置初始化一个客户端
func init() {
redisDb = redis.NewClient(&redis.Options{
Addr: "127.0.0.1:6379", // redis地址
Password: "ut123456", // redis密码，没有则留空
DB: 0, // 默认数据库，默认是0
})
_, err := redisDb.Ping().Result()
if err != nil {
fmt.Println("连接redis异常", err)
return
}
fmt.Println("连接redis成功")
}
func main() {
redisDb.RPush("list2", "aa1", "bb1")
// 返回从0开始到-1位置之间的数据，意思就是返回全部数据
list1, err := redisDb.LRange("list2", 0, -1).Result()
if err != nil {
fmt.Println("取出异常:", err)
return
}
fmt.Println(list1)
}
LPushX使用
LPushX只有当key值存在才能插入
package main
import (
"fmt"
"github.com/go-redis/redis"
)
// 声明一个全局的redisDb变量
var redisDb *redis.Client
// 根据redis配置初始化一个客户端
func init() {
redisDb = redis.NewClient(&redis.Options{
Addr: "127.0.0.1:6379", // redis地址
Password: "123456", // redis密码，没有则留空
DB: 0, // 默认数据库，默认是0
})
_, err := redisDb.Ping().Result()
if err != nil {
fmt.Println("连接redis异常", err)
return
}
fmt.Println("连接redis成功")
}
func main() {
redisDb.LPushX("list3", "aa1")
// 返回从0开始到-1位置之间的数据，意思就是返回全部数据
list1, err := redisDb.LRange("list3", 0, -1).Result()
if err != nil {
fmt.Println("取出异常:", err)
return
}
fmt.Println(list1)
}
输出
RPushX使用
RPushX只有当key值存在才能插入
package main
import (
"fmt"
"github.com/go-redis/redis"
)
// 声明一个全局的redisDb变量
var redisDb *redis.Client
// 根据redis配置初始化一个客户端
func init() {
redisDb = redis.NewClient(&redis.Options{
Addr: "127.0.0.1:6379", // redis地址
Password: "123456", // redis密码，没有则留空
DB: 0, // 默认数据库，默认是0
})
_, err := redisDb.Ping().Result()
if err != nil {
fmt.Println("连接redis异常", err)
return
}
fmt.Println("连接redis成功")
}
func main() {
redisDb.RPushX("list3", "aa1")
// 返回从0开始到-1位置之间的数据，意思就是返回全部数据
list1, err := redisDb.LRange("list3", 0, -1).Result()
if err != nil {
fmt.Println("取出异常:", err)
return
}
fmt.Println(list1)
}
LPop和RPop使用
LPop从左边取值，RPop从右边取值
package main
import (
"fmt"
"github.com/go-redis/redis"
)
// 声明一个全局的redisDb变量
var redisDb *redis.Client
// 根据redis配置初始化一个客户端
func init() {
redisDb = redis.NewClient(&redis.Options{
Addr: "127.0.0.1:6379", // redis地址
Password: "123456", // redis密码，没有则留空
DB: 0, // 默认数据库，默认是0
})
_, err := redisDb.Ping().Result()
if err != nil {
fmt.Println("连接redis异常", err)
return
}
fmt.Println("连接redis成功")
}
func main() {
redisDb.RPushX("list2", "aa1")
fmt.Println(redisDb.LPop("list2"))
fmt.Println(redisDb.RPop("list2"))
}
set操作
SAdd和SMembers
SADD往set添加元素，SMembers取出set所有元素
package main
import (
"fmt"
"github.com/go-redis/redis"
)
// 声明一个全局的redisDb变量
var redisDb *redis.Client
// 根据redis配置初始化一个客户端
func init() {
redisDb = redis.NewClient(&redis.Options{
Addr: "127.0.0.1:6379", // redis地址
Password: "123456", // redis密码，没有则留空
DB: 0, // 默认数据库，默认是0
})
_, err := redisDb.Ping().Result()
if err != nil {
fmt.Println("连接redis异常", err)
return
}
fmt.Println("连接redis成功")
}
func main() {
redisDb.SAdd("set1", "aa1", "aa1", "aa2")
//返回名称为集合中的所有元素
rs, err := redisDb.SMembers("set1").Result()
if err != nil {
panic(err)
}
fmt.Println(rs)
}
SCard使用
SCard用于统计set数量
package main
import (
"fmt"
"github.com/go-redis/redis"
)
// 声明一个全局的redisDb变量
var redisDb *redis.Client
// 根据redis配置初始化一个客户端
func init() {
redisDb = redis.NewClient(&redis.Options{
Addr: "192.168.69.166:6379", // redis地址
Password: "ut123456", // redis密码，没有则留空
DB: 0, // 默认数据库，默认是0
})
_, err := redisDb.Ping().Result()
if err != nil {
fmt.Println("连接redis异常", err)
return
}
fmt.Println("连接redis成功")
}
func main() {
redisDb.SAdd("set1", "aa1", "aa1", "aa2")
//返回名称为集合中的所有元素
rs, err := redisDb.SMembers("set1").Result()
if err != nil {
panic(err)
}
fmt.Println(rs)
count := redisDb.SCard("set1")
fmt.Println(count)
}
SRem删除数组元素
使用SRem删除Set数组某个元素
package main
import (
"fmt"
"github.com/go-redis/redis"
)
// 声明一个全局的redisDb变量
var redisDb *redis.Client
// 根据redis配置初始化一个客户端
func init() {
redisDb = redis.NewClient(&redis.Options{
Addr: "192.168.69.166:6379", // redis地址
Password: "ut123456", // redis密码，没有则留空
DB: 0, // 默认数据库，默认是0
})
_, err := redisDb.Ping().Result()
if err != nil {
fmt.Println("连接redis异常", err)
return
}
fmt.Println("连接redis成功")
}
func main() {
redisDb.SAdd("set1", "aa1", "aa1", "aa2")
//返回名称为集合中的所有元素
rs, err := redisDb.SMembers("set1").Result()
if err != nil {
panic(err)
}
fmt.Println(rs)
redisDb.SRem("set1", "aa1")
//返回名称为集合中的所有元素
rs1, err1 := redisDb.SMembers("set1").Result()
if err1 != nil {
panic(err1)
}
fmt.Println(rs1)
count := redisDb.SCard("set1")
fmt.Println(count)
}
go-redis操作hash
HSet和HGet使用
HSet设置hash值，HGet获取值
package main
import (
"fmt"
"github.com/go-redis/redis"
)
// 声明一个全局的redisDb变量
var redisDb *redis.Client
// 根据redis配置初始化一个客户端
func init() {
redisDb = redis.NewClient(&redis.Options{
Addr: "192.168.69.166:6379", // redis地址
Password: "ut123456", // redis密码，没有则留空
DB: 0, // 默认数据库，默认是0
})
_, err := redisDb.Ping().Result()
if err != nil {
fmt.Println("连接redis异常", err)
return
}
fmt.Println("连接redis成功")
}
func main() {
err := redisDb.HSet("hash1", "aa", "aa").Err()
if err != nil {
panic(err)
}
aa, err := redisDb.HGet("hash1", "aa").Result()
if err != nil {
panic(err)
}
fmt.Println(aa)
}
HDel删除值
package main
import (
"fmt"
"github.com/go-redis/redis"
)
// 声明一个全局的redisDb变量
var redisDb *redis.Client
// 根据redis配置初始化一个客户端
func init() {
redisDb = redis.NewClient(&redis.Options{
Addr: "127.0.0.1:6379", // redis地址
Password: "123456", // redis密码，没有则留空
DB: 0, // 默认数据库，默认是0
})
_, err := redisDb.Ping().Result()
if err != nil {
fmt.Println("连接redis异常", err)
return
}
fmt.Println("连接redis成功")
}
func main() {
err := redisDb.HSet("hash1", "aa", "aa").Err()
if err != nil {
panic(err)
}
redisDb.HDel("hash1", "aa")
aa, err := redisDb.HGet("hash1", "aa").Result()
if err != nil {
panic(err)
}
fmt.Println(aa)
}
输出
HExists使用
HExists判断值是否存在
package main
import (
"fmt"
"github.com/go-redis/redis"
)
// 声明一个全局的redisDb变量
var redisDb *redis.Client
// 根据redis配置初始化一个客户端
func init() {
redisDb = redis.NewClient(&redis.Options{
Addr: "127.0.0.1:6379", // redis地址
Password: "123456", // redis密码，没有则留空
DB: 0, // 默认数据库，默认是0
})
_, err := redisDb.Ping().Result()
if err != nil {
fmt.Println("连接redis异常", err)
return
}
fmt.Println("连接redis成功")
}
func main() {
err := redisDb.HSet("hash1", "aa", "aa").Err()
if err != nil {
panic(err)
}
redisDb.HDel("hash1", "aa")
aa, err := redisDb.HExists("hash1", "aa").Result()
if err != nil {
panic(err)
}
fmt.Println(aa)
}
go-redis操作ZSET有序集合
ZADD和ZRangeByScore使用
package main
import (
"fmt"
"github.com/go-redis/redis"
)
// 声明一个全局的redisDb变量
var redisDb *redis.Client
// 根据redis配置初始化一个客户端
func init() {
redisDb = redis.NewClient(&redis.Options{
Addr: "127.0.0.1:6379", // redis地址
Password: "123456", // redis密码，没有则留空
DB: 0, // 默认数据库，默认是0
})
_, err := redisDb.Ping().Result()
if err != nil {
fmt.Println("连接redis异常", err)
return
}
fmt.Println("连接redis成功")
}
func main() {
result := []redis.Z{
{Score: 1.0, Member: "aaa"},
{Score: 2.0, Member: "bbb"},
}
err := redisDb.ZAdd("zset1", result...).Err()
if err != nil {
panic(err)
}
op := redis.ZRangeBy{
Min: "0", // 最小分数
Max: "100", // 最大分数
Offset: 0, // 开始偏移量
Count: 10, // 一次返回多少数据
}
values, err1 := redisDb.ZRangeByScore("zset1", op).Result()
if err1 != nil {
panic(err)
}
for _, val := range values {
fmt.Println(val)
}
}
ZCard返回集合中成员的个数
package main
import (
"fmt"
"github.com/go-redis/redis"
)
// 声明一个全局的redisDb变量
var redisDb *redis.Client
// 根据redis配置初始化一个客户端
func init() {
redisDb = redis.NewClient(&redis.Options{
Addr: "127.0.0.1:6379", // redis地址
Password: "123456", // redis密码，没有则留空
DB: 0, // 默认数据库，默认是0
})
_, err := redisDb.Ping().Result()
if err != nil {
fmt.Println("连接redis异常", err)
return
}
fmt.Println("连接redis成功")
}
func main() {
result := []redis.Z{
{Score: 1.0, Member: "aaa"},
{Score: 2.0, Member: "bbb"},
}
err := redisDb.ZAdd("zset1", result...).Err()
if err != nil {
panic(err)
}
op := redis.ZRangeBy{
Min: "0", // 最小分数
Max: "100", // 最大分数
Offset: 0, // 类似sql的limit, 表示开始偏移量
Count: 10, // 一次返回多少数据
}
values, err1 := redisDb.ZRangeByScore("zset1", op).Result()
if err1 != nil {
panic(err)
}
for _, val := range values {
fmt.Println(val)
}
fmt.Println(redisDb.ZCard("zset1").Val())
}
ZRemRangeByScore移除元素
根据Score大小移除元素
package main
import (
"fmt"
"github.com/go-redis/redis"
)
// 声明一个全局的redisDb变量
var redisDb *redis.Client
// 根据redis配置初始化一个客户端
func init() {
redisDb = redis.NewClient(&redis.Options{
Addr: "127.0.0.1:6379", // redis地址
Password: "123456", // redis密码，没有则留空
DB: 0, // 默认数据库，默认是0
})
_, err := redisDb.Ping().Result()
if err != nil {
fmt.Println("连接redis异常", err)
return
}
fmt.Println("连接redis成功")
}
func main() {
result := []redis.Z{
{Score: 1.0, Member: "aaa"},
{Score: 2.0, Member: "bbb"},
}
err := redisDb.ZAdd("zset1", result...).Err()
if err != nil {
panic(err)
}
fmt.Println(redisDb.ZRemRangeByScore("zset1", "0", "1").Val())
op := redis.ZRangeBy{
Min: "0", // 最小分数
Max: "100", // 最大分数
Offset: 0, // 类似sql的limit, 表示开始偏移量
Count: 10, // 一次返回多少数据
}
values, err1 := redisDb.ZRangeByScore("zset1", op).Result()
if err1 != nil {
panic(err)
}
for _, val := range values {
fmt.Println(val)
}
fmt.Println(redisDb.ZCard("zset1").Val())
}
总结
go-redis提供了丰富的api供开发使用，提高开发效率，但是go提供操作redis的三方库很多，因人而异，看个人开发效率选择
