Go语言开发基础系列（四十八）redis开发使用教程

在go语言开发中，与redis进行交互的场景也非常多，所以这里我们也介绍下go语言开发中redis的使用。

这里使用的redis框架主要是：gopkg.in/redis.v4。所以在使用之前记得安装下依赖。下面介绍下详细使用。

一、创建redis客户端及连接池

go语言简单，操作redis的话，创建连接池也非常方便，示例代码如下：

func createRedisClient() *redis.Client {
    client := redis.NewClient(&redis.Options{
       Addr:     "192.168.1.249:6379", //redis地址和端口
       Password: "123456",             //redis密码
       DB:       0,                    //默认数据库0
       PoolSize: 10,                   //线程池大小
    })

    pong, err := client.Ping().Result()
    if err != nil {
       panic(err)
    }
    fmt.Println(pong)
    return client
}

最后在main函数里面直接使用即可：

func main() {

    client := createRedisClient()
    defer client.Close()

}

二、操作redis string相关的命令

这里主要是普通的set get，示例代码如下：

/*
*
普通set-value数据
*/
func setValue(key string, value string, expireTime int, client *redis.Client) (result bool) {
    err := client.Set(key, value, time.Duration(expireTime)).Err()
    if err != nil {
       panic(err)
    }
    return true
}

/*
*
普通get数据，根据key查询数据
*/
func getValue(key string, client *redis.Client) (result any) {
    s, err := client.Get(key).Result()
    if err != nil {
       panic(err)
    }
    return s
}

/*
*
getset数据，给key设置一个新值，并且返回就值
*/
func getSetValue(key string, newvalue string, client *redis.Client) (result any) {
    s, err := client.GetSet(key, newvalue).Result()
    if err != nil {
       panic(err)
    }
    return s
}

/*
*
increKey，自增加一
*/
func increKey(key string, client *redis.Client) (result any) {

    incr := client.Incr(key)
    return incr
}

/*
*
decreKey，自增加一
*/
func decreKey(key string, client *redis.Client) (result any) {

    decr := client.Decr(key)
    return decr
}

/*
*
setNX 如果key不存在，则设置这个key的值
*/
func setNX(key string, value string, expirTime int, client *redis.Client) (result bool) {
    err := client.SetNX(key, value, time.Duration(expirTime)).Err()
    if err != nil {
       panic(err)
    }
    return true
}

/*
*
批量一次获取多个key的值
*/
func getMgetValue(client *redis.Client, keys ...string) (result any) {
    s, err := client.MGet(keys...).Result()
    if err != nil {
       panic(err)
    }
    return s
}

/*
*
批量设置key-value
*/
func mSetValue(keys map[string]interface{}, client *redis.Client) (result bool) {
    err := client.MSet(keys).Err()
    if err != nil {
       panic(err)
    }
    return true
}

三、操作redis hash相关的命令

操作hash主要是操作对象，示例代码如下：

/*
*
hash 向某个hash中添加字段和值
*/
func hashSet(key string, field string, value string, client *redis.Client) (result bool) {
    err := client.HSet(key, field, value).Err()
    if err != nil {
       panic(err)
    }
    return true
}

/*
*
hash 向某个hash中map对象
*/
func hashSet(key string, m map[string]string, client *redis.Client) (result bool) {
    err := client.HMSet(key, m).Err()
    if err != nil {
       panic(err)
    }
    return true
}

/*
*
hash 从某个hash中读取字段和值
*/
func hashGet(key string, field string, client *redis.Client) (result any) {
    s, err := client.HGet(key, field).Result()
    if err != nil {
       panic(err)
    }
    return s
}

/*
*
hash 获取某个hash中的字段有多少个
*/
func hashLen(key string, client *redis.Client) (result any) {
    s, err := client.HLen(key).Result()
    if err != nil {
       panic(err)
    }
    return s
}

/*
*
hash 删除某个hash中的某个字段
*/
func hashDel(key string, field string, client *redis.Client) (result any) {
    s, err := client.HDel(key, field).Result()
    if err != nil {
       panic(err)
    }
    return s
}

四、操作redis list相关的命令

list一般用于队列来使用，示例代码如下：

/*
*
lpush list操作左边入队
*/
func lpush(key string, value string, client *redis.Client) (result bool) {
    err := client.LPush(key, value).Err()
    if err != nil {
       panic(err)
    }
    return true
}

/*
*
rpush list操作右边入队
*/
func rpush(key string, value string, client *redis.Client) (result bool) {

    err := client.RPush(key, value).Err()
    if err != nil {
       panic(err)
    }
    return true
}

/*
*
lpop list操作左边出队
*/
func lpop(key string, client *redis.Client) (result any) {
    s, err := client.LPop(key).Result()
    if err != nil {
       panic(err)
    }
    return s
}

/*
*
rpop list操作左边出队
*/
func rpop(key string, client *redis.Client) (result any) {
    s, err := client.RPop(key).Result()
    if err != nil {
       panic(err)
    }
    return s
}

五、操作redis set相关的命令

set主要是集合，数据不能重复，示例代码如下：

/*
*
set操作 sadd添加
*/
func sadd(key string, value string, client *redis.Client) (result bool) {

    err := client.SAdd(key, value).Err()
    if err != nil {
       panic(err)
    }
    return true
}

/*
*
set操作 srem移除某个元素，不存在的元素会被忽略掉
*/
func srem(key string, value string, client *redis.Client) (result bool) {
    err := client.SRem(key, value).Err()
    if err != nil {
       panic(err)
    }
    return true
}

/*
*
set操作 获取指定集合的所有元素
*/
func smembers(key string, client *redis.Client) (result []string) {
    s, err := client.SMembers(key).Result()
    if err != nil {
       panic(err)
    }
    return s
}

/*
*
set操作 获取两个set集合的交集
*/
func sintersection(key1 string, key2 string, client *redis.Client) (result any) {
    s, err := client.SInter(key1, key2).Result()
    if err != nil {
       panic(err)
    }
    return s
}

/*
*
set操作 判断某个元素是否在set集合中
*/
func sIsMem(key string, value string, client *redis.Client) (result any) {
    s, err := client.SIsMember(key, value).Result()
    if err != nil {
       panic(err)
    }
    return s
}

六、操作redis sorted set相关的命令

带有排序性质的集合，示例代码如下：

/*
*
sorted set，使用zadd添加一个元素到集合，如果元素已经存在，则更新分数。
*/
func sortedsetZadd(key string, value string, score float64, client *redis.Client) (result bool) {
    err := client.ZAddCh(key, redis.Z{Score: score, Member: value}).Err()
    if err != nil {
       panic(err)
    }
    return true
}

/*
*
sorted set 移除某个元素
*/
func sortedsetZrem(key string, value string, client *redis.Client) (result bool) {
    err := client.ZRem(key, value).Err()
    if err != nil {
       panic(err)
    }
    return true
}

/*
*
sorted set 查询集合中元素个数
*/
func sortedsetZcard(key string, client *redis.Client) (result bool) {
    err := client.ZCard(key).Err()
    if err != nil {
       panic(err)
    }
    return true
}

/*
*
sorted set查询某个元素对应的分数
*/
func sortedsetZscore(key string, value string, client *redis.Client) (result any) {
    f, err := client.ZScore(key, value).Result()
    if err != nil {
       panic(err)
    }
    return f
}

/*
*
sorted set查询某个元素对应的分数
*/
func sortedsetZCount(key string, score1 string, score2 string, client *redis.Client) (result any) {
    f, err := client.ZCount(key, score1, score2).Result()
    if err != nil {
       panic(err)
    }
    return f
}

/*
*
sorted set,根据分数范围查询集合元素，从小到大排序，支持分页，这里仅返回元素不返回分数
*/
func sortedsetZRangeByScore(key string, score1 string, score2 string, size int64, client *redis.Client) (result any) {

    op := redis.ZRangeBy{
       Min:    score1,
       Max:    score2,
       Offset: 0,
       Count:  size,
    }

    f, err := client.ZRangeByScore(key, op).Result()
    if err != nil {
       panic(err)
    }
    return f
}

/*
*
sorted set,根据分数范围查询集合元素，从大到小排序，支持分页,这里仅返回元素不返回分数
*/
func sortedsetZRevRangeByScore(key string, score1 string, score2 string, size int64, client *redis.Client) (result any) {

    op := redis.ZRangeBy{
       Min:    score1,
       Max:    score2,
       Offset: 0,
       Count:  size,
    }

    f, err := client.ZRevRangeByScore(key, op).Result()
    if err != nil {
       panic(err)
    }
    return f
}

/*
*
sorted set,根据分数范围查询集合元素，这里既返回元素也返回分数
*/
func sortedsetZRangeByScoreWithScore(key string, score1 string, score2 string, size int64, client *redis.Client) (result any) {

    op := redis.ZRangeBy{
       Min:    score1,
       Max:    score2,
       Offset: 0,
       Count:  size,
    }

    f, err := client.ZRangeByScoreWithScores(key, op).Result()
    if err != nil {
       panic(err)
    }
    return f
}

/*
*
sorted set,根据分数范围删除集合元素
*/
func sortedsetZRemRangeByScore(key string, score1 string, score2 string, client *redis.Client) (result any) {

    err := client.ZRemRangeByScore(key, score1, score2).Err()
    if err != nil {
       panic(err)
    }
    return true
}

/*
*
sorted set,根据元素名，查询该元素在整个集合中的排名，从0开始，从小到大排序
*/
func sortedsetZRank(key string, value string, client *redis.Client) (result any) {

    s, err := client.ZRank(key, value).Result()
    if err != nil {
       panic(err)
    }
    return s
}

以上就是go语言操作redis常用的一些方法，可以直接应用于实际的代码中做成utils使用。