upload-api/service/redis_tools.go

package service

import (
	"fmt"
	"service-api/global"
	"time"

	"github.com/go-redis/redis"
	"go.uber.org/zap"
)

// RedisGet ...
func RedisGet(key string) string {
	result, err := global.MG_REDIS.Get(key).Result()
	if err != nil {
		return ""
	}
	return result
}

func RedisSet(key string, value interface{}, expiration time.Duration) string {
	result, err := global.MG_REDIS.Set(key, value, expiration).Result()
	if err != nil {
		global.MG_LOG.Error("Redis Set Error:", zap.Any("err", err))
		return ""
	}
	return result
}

func RedisDel(key ...string) (int64, error) {
	result, err := global.MG_REDIS.Del(key...).Result()
	if err != nil {
		global.MG_LOG.Error("Redis Del Error:", zap.Any("err", err))
		return -1, err
	}
	return result, err
}

// RedisHashSet 向key的hash中添加元素field的值
func RedisHashSet(key, field string, data interface{}) error {
	err := global.MG_REDIS.HSet(key, field, data).Err()
	if err != nil {
		global.MG_LOG.Error("Redis HSet Error:", zap.Any("err", err))
		return err
	}
	return nil
}

// RedisBatchHashSet 批量向key的hash添加对应元素field的值
func RedisBatchHashSet(key string, fields map[string]interface{}) (error, string) {
	val, err := global.MG_REDIS.HMSet(key, fields).Result()
	if err != nil {
		global.MG_LOG.Error("Redis HMSet Error:", zap.Any("err", err))
		return err, ""
	}
	return nil, val
}

func RedisHDel(key string, fields ...string) (error, int64) {
	result, err := global.MG_REDIS.HDel(key, fields...).Result()
	if err != nil {
		global.MG_LOG.Error("Redis HMSet Error:", zap.Any("err", err))
		return err, 0
	}
	return nil, result
}

func RedisHSet(key, field string, value interface{}) (error, bool) {
	val, err := global.MG_REDIS.HSet(key, field, value).Result()
	if err != nil {
		global.MG_LOG.Error("Redis HSet Error:", zap.Any("err", err))
		return err, false
	}
	return nil, val
}

// RedisHashGet 通过key获取hash的元素值
func RedisHashGet(key, field string) string {
	val, err := global.MG_REDIS.HGet(key, field).Result()
	if err != nil {
		return ""
	}
	return val
}

func RedisHashMGet(key string, fields ...string) []interface{} {
	val, err := global.MG_REDIS.HMGet(key, fields...).Result()
	if err != nil {
		return nil
	}
	return val
}

//HGetAll
func RedisHashGetAll(key string) map[string]string {
	val, err := global.MG_REDIS.HGetAll(key).Result()
	if err != nil {
		return nil
	}
	return val
}

// RedisBatchHashGet 批量获取key的hash中对应多元素值
func RedisBatchHashGet(key string, fields ...string) map[string]interface{} {
	resMap := make(map[string]interface{})
	for _, field := range fields {
		val, err := global.MG_REDIS.HGet(key, fmt.Sprintf("%s", field)).Result()
		if err == nil && val != "" {
			resMap[field] = val
		}
	}
	return resMap
}

func RedisLPush(key string, values ...interface{}) (int64, error) {
	result, err := global.MG_REDIS.LPush(key, values...).Result()
	if err != nil {
		global.MG_LOG.Error("Redis LPush Error:", zap.Any("err", err))
		return 0, err
	}
	return result, nil
}

func RedisLPop(key string) (error, string) {
	result, err := global.MG_REDIS.LPop(key).Result()
	if err != nil {
		return err, ""
	}
	return err, result
}

// RedisSAdd 无序集合添加
func RedisSAdd(key string, values ...interface{}) (int64, error) {
	result, err := global.MG_REDIS.SAdd(key, values...).Result()
	if err != nil {
		global.MG_LOG.Error("Redis LPush Error:", zap.Any("err", err))
		return 0, err
	}
	return result, nil
}

func RedisSIsMember(key string, value interface{}) (bool, error) {
	result, err := global.MG_REDIS.SIsMember(key, value).Result()
	if err != nil {
		global.MG_LOG.Error("Redis LPush Error:", zap.Any("err", err))
		return false, err
	}
	return result, nil
}

func RedisSRem(key string, values ...interface{}) (int64, error) {
	result, err := global.MG_REDIS.SRem(key, values...).Result()
	if err != nil {
		return 0, err
	}
	return result, err
}

// RedisSMembers 从无序集合中获取数据
func RedisSMembers(key string) ([]string, error) {
	val, err := global.MG_REDIS.SMembers(key).Result()
	if err != nil {
		global.MG_LOG.Error("Redis SMembers Error:", zap.Any("err", err))
		return nil, err
	}
	return val, nil
}

// RedisZAdd 有序集合添加
func RedisZAdd(key string, values map[float64]interface{}) (int64, error) {
	var members []redis.Z
	for scale, value := range values {
		members = append(members, redis.Z{
			Score:  scale,
			Member: value,
		})
	}
	result, err := global.MG_REDIS.ZAdd(key, members...).Result()
	if err != nil {
		global.MG_LOG.Error("Redis ZAdd Error:", zap.Any("err", err))
		return 0, err
	}
	return result, nil
}

func RedisZRem(key string, values ...interface{}) (int64, error) {
	result, err := global.MG_REDIS.ZRem(key, values...).Result()
	if err != nil {
		return 0, err
	}
	return result, err
}

func RedisZCard(key string) (int64, error) {
	result, err := global.MG_REDIS.ZCard(key).Result()
	if err != nil {
		global.MG_LOG.Error("Redis ZAdd Error:", zap.Any("err", err))
		return 0, err
	}
	return result, nil
}

func RedisZRange(key string, start, stop int64, sort string) ([]interface{}, error) {
	var val = make([]interface{}, 0)
	if sort == "asc" { //scale 正序
		result, err := global.MG_REDIS.ZRangeWithScores(key, start, stop).Result()
		if err != nil {
			global.MG_LOG.Error("Redis ZPopMax Error:", zap.Any("err", err))
			return val, err
		}
		for _, z := range result {
			val = append(val, z.Member)
		}
	} else { //scale 倒序
		result, err := global.MG_REDIS.ZRevRange(key, start, stop).Result()
		if err != nil {
			global.MG_LOG.Error("Redis ZPopMax Error:", zap.Any("err", err))
			return val, err
		}
		for _, z := range result {
			val = append(val, z)
		}
		return val, nil
	}

	return val, nil
}

// RedisIncr 获取自增唯一ID
func RedisIncr(key string) int {
	val, err := global.MG_REDIS.Incr(key).Result()
	if err != nil {
		global.MG_LOG.Error("Redis RedisIncr Error:", zap.Any("err", err))
	}
	return int(val)
}

func RedisTest(key string, values ...interface{}) {
	result, err := global.MG_REDIS.SRem(key, values...).Result()
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println(result)
}