go-redis 封装使用

package redis

import (
    "database"
    "fmt"
    "time"
)

// Set 设置 key的值
func Set(key, value string) bool {
    result, err := database.RedisClient.Set(key, value, 0).Result()
    if err != nil {
        fmt.Println(err)
        return false
    }
    return result == "OK"
}

// SetEX 设置 key的值并指定过期时间
func SetEX(key, value string, ex time.Duration) bool {
    result, err := database.RedisClient.Set(key, value, ex).Result()
    if err != nil {
        fmt.Println(err)
        return false
    }
    return result == "OK"
}

// Get 获取 key的值
func Get(key string) (bool, string) {
    result, err := database.RedisClient.Get(key).Result()
    if err != nil {
        fmt.Println(err)
        return false, ""
    }
    return true, result
}

// GetSet 设置新值获取旧值
func GetSet(key, value string) (bool, string) {
    oldValue, err := database.RedisClient.GetSet(key, value).Result()
    if err != nil {
        fmt.Println(err)
        return false, ""
    }
    return true, oldValue
}

// Incr key值每次加一 并返回新值
func Incr(key string) int64 {
    val, err := database.RedisClient.Incr(key).Result()
    if err != nil {
        fmt.Println(err)
    }
    return val
}

// IncrBy key值每次加指定数值 并返回新值
func IncrBy(key string, incr int64) int64 {
    val, err := database.RedisClient.IncrBy(key, incr).Result()
    if err != nil {
        fmt.Println(err)
    }
    return val
}

// IncrByFloat key值每次加指定浮点型数值 并返回新值
func IncrByFloat(key string, incrFloat float64) float64 {
    val, err := database.RedisClient.IncrByFloat(key, incrFloat).Result()
    if err != nil {
        fmt.Println(err)
    }
    return val
}

// Decr key值每次递减 1 并返回新值
func Decr(key string) int64 {
    val, err := database.RedisClient.Decr(key).Result()
    if err != nil {
        fmt.Println(err)
    }
    return val
}

// DecrBy key值每次递减指定数值 并返回新值
func DecrBy(key string, incr int64) int64 {
    val, err := database.RedisClient.DecrBy(key, incr).Result()
    if err != nil {
        fmt.Println(err)
    }
    return val
}

// Del 删除 key
func Del(key string) bool {
    result, err := database.RedisClient.Del(key).Result()
    if err != nil {
        return false
    }
    return result == 1
}

// Expire 设置 key的过期时间
func Expire(key string, ex time.Duration) bool {
    result, err := database.RedisClient.Expire(key, ex).Result()
    if err != nil {
        return false
    }
    return result
}

/*------------------------------------ list 操作 ------------------------------------*/

// LPush 从列表左边插入数据，并返回列表长度
func LPush(key string, date ...interface{}) int64 {
    result, err := database.RedisClient.LPush(key, date).Result()
    if err != nil {
        fmt.Println(err)
    }
    return result
}

// RPush 从列表右边插入数据，并返回列表长度
func RPush(key string, date ...interface{}) int64 {
    result, err := database.RedisClient.RPush(key, date).Result()
    if err != nil {
        fmt.Println(err)
    }
    return result
}

// LPop 从列表左边删除第一个数据，并返回删除的数据
func LPop(key string) (bool, string) {
    val, err := database.RedisClient.LPop(key).Result()
    if err != nil {
        fmt.Println(err)
        return false, ""
    }
    return true, val
}

// RPop 从列表右边删除第一个数据，并返回删除的数据
func RPop(key string) (bool, string) {
    val, err := database.RedisClient.RPop(key).Result()
    if err != nil {
        fmt.Println(err)
        return false, ""
    }
    return true, val
}

// LIndex 根据索引坐标，查询列表中的数据
func LIndex(key string, index int64) (bool, string) {
    val, err := database.RedisClient.LIndex(key, index).Result()
    if err != nil {
        fmt.Println(err)
        return false, ""
    }
    return true, val
}

// LLen 返回列表长度
func LLen(key string) int64 {
    val, err := database.RedisClient.LLen(key).Result()
    if err != nil {
        fmt.Println(err)
    }
    return val
}

// LRange 返回列表的一个范围内的数据，也可以返回全部数据
func LRange(key string, start, stop int64) []string {
    vales, err := database.RedisClient.LRange(key, start, stop).Result()
    if err != nil {
        fmt.Println(err)
    }
    return vales
}

// LRem 从列表左边开始，删除元素data， 如果出现重复元素，仅删除 count次
func LRem(key string, count int64, data interface{}) bool {
    _, err := database.RedisClient.LRem(key, count, data).Result()
    if err != nil {
        fmt.Println(err)
    }
    return true
}

// LInsert 在列表中 pivot 元素的后面插入 data
func LInsert(key string, pivot int64, data interface{}) bool {
    err := database.RedisClient.LInsert(key, "after", pivot, data).Err()
    if err != nil {
        fmt.Println(err)
        return false
    }
    return true
}

/*------------------------------------ set 操作 ------------------------------------*/

// SAdd 添加元素到集合中
func SAdd(key string, data ...interface{}) bool {
    err := database.RedisClient.SAdd(key, data).Err()
    if err != nil {
        fmt.Println(err)
        return false
    }
    return true
}

// SCard 获取集合元素个数
func SCard(key string) int64 {
    size, err := database.RedisClient.SCard("key").Result()
    if err != nil {
        fmt.Println(err)
    }
    return size
}

// SIsMember 判断元素是否在集合中
func SIsMember(key string, data interface{}) bool {
    ok, err := database.RedisClient.SIsMember(key, data).Result()
    if err != nil {
        fmt.Println(err)
    }
    return ok
}

// SMembers 获取集合所有元素
func SMembers(key string) []string {
    es, err := database.RedisClient.SMembers(key).Result()
    if err != nil {
        fmt.Println(err)
    }
    return es
}

// SRem 删除 key集合中的 data元素
func SRem(key string, data ...interface{}) bool {
    _, err := database.RedisClient.SRem(key, data).Result()
    if err != nil {
        fmt.Println(err)
        return false
    }
    return true
}

// SPopN 随机返回集合中的 count个元素，并且删除这些元素
func SPopN(key string, count int64) []string {
    vales, err := database.RedisClient.SPopN(key, count).Result()
    if err != nil {
        fmt.Println(err)
    }
    return vales
}

/*------------------------------------ hash 操作 ------------------------------------*/

// HSet 根据 key和 field字段设置，field字段的值
func HSet(key, field, value string) bool {
    err := database.RedisClient.HSet(key, field, value).Err()
    if err != nil {
        return false
    }
    return true
}

// HGet 根据 key和 field字段，查询field字段的值
func HGet(key, field string) string {
    val, err := database.RedisClient.HGet(key, field).Result()
    if err != nil {
        fmt.Println(err)
    }
    return val
}

// HMGet 根据key和多个字段名，批量查询多个 hash字段值
func HMGet(key string, fields ...string) []interface{} {
    vales, err := database.RedisClient.HMGet(key, fields...).Result()
    if err != nil {
        panic(err)
    }
    return vales
}

// HGetAll 根据 key查询所有字段和值
func HGetAll(key string) map[string]string {
    data, err := database.RedisClient.HGetAll(key).Result()
    if err != nil {
        fmt.Println(err)
    }
    return data
}

// HKeys 根据 key返回所有字段名
func HKeys(key string) []string {
    fields, err := database.RedisClient.HKeys(key).Result()
    if err != nil {
        fmt.Println(err)
    }
    return fields
}

// HLen 根据 key，查询hash的字段数量
func HLen(key string) int64 {
    size, err := database.RedisClient.HLen(key).Result()
    if err != nil {
        fmt.Println(err)
    }
    return size
}

// HMSet 根据 key和多个字段名和字段值，批量设置 hash字段值
func HMSet(key string, data map[string]interface{}) string {
    result, err := database.RedisClient.HMSet(key, data).Result()
    if err != nil {
        fmt.Println(err)
        return ""
    }
    return result
}

// HSetNX 如果 field字段不存在，则设置 hash字段值
func HSetNX(key, field string, value interface{}) bool {
    result, err := database.RedisClient.HSetNX(key, field, value).Result()
    if err != nil {
        fmt.Println(err)
        return false
    }
    return result
}

// HDel 根据 key和字段名，删除 hash字段，支持批量删除
func HDel(key string, fields ...string) bool {
    _, err := database.RedisClient.HDel(key, fields...).Result()
    if err != nil {
        fmt.Println(err)
        return false
    }
    return true
}

// HExists 检测 hash字段名是否存在
func HExists(key, field string) bool {
    result, err := database.RedisClient.HExists(key, field).Result()
    if err != nil {
        fmt.Println(err)
        return false
    }
    return result
}




package database
import (
    "context"
    "github.com/redis/go-redis/v9"
    "log"
    "sync"
    "time"
)

//创建一个全局的redis客户端实例Rdb
var RedisClient *redis.Client
var ctx = context.Background()

func InitRedisConn() {
    RedisClient = redis.NewClient(&redis.Options{
        //Addr: "192.168.116.11:6379",
        Addr: config.RedisHostPort,
        //留空为没设密码
        Password: "",
        // 默认的DB 为 0
        DB: config.BaseConfigInfo.RedisDB,
        // 连接池大小
        PoolSize: 10,
    })
    // 验证是否连接到redis服务端
    _, err := RedisClient.Ping(ctx).Result()
    if err != nil {
        zaplog.Error(nil, "NewRedisConnError", err)
        log.Fatal("NewRedisConnError:", err)
    }
}

//设置bitmap使用
//语法: setbit like_id1 100 1   //设置ID为100为1
func GiveLike(keys string, userid int64) (bool, error) {
    res, err := RedisClient.GetBit(ctx, keys, userid-1).Result()
    if err != nil {
        return false, err
    }
    if res == 1 {
        return true, nil
    }
    res, err = RedisClient.SetBit(ctx, keys, userid-1, 1).Result()
    if err != nil {
        return false, err
    }

    return true, nil
}

//查询bitmap使用
func GiveLikeSelect(keys string, userid int64) (bool, error) {
    res, err := RedisClient.GetBit(ctx, keys, userid-1).Result()
    if err != nil {
        return false, err
    }

    if res == 1 {
        return true, nil
    }

    return false, nil
}

// https://github.com/bsm/redislock
//redis加锁
func Lock(key string) bool {
    var mutex sync.Locker
    mutex.Lock()
    defer mutex.Unlock()
    bool, err := RedisClient.SetNX(ctx, key, 1, 10*time.Second).Result()
    if err != nil {
        log.Println(err.Error())
    }
    return bool
}

//redis 释放锁
func UnLock(key string) int64 {
    nums, err := RedisClient.Del(ctx, key).Result()
    if err != nil {
        log.Println(err.Error())
        return 0
    }
    return nums
}