videoplayer/worker/redis.go

package worker

import (
	"fmt"
	"strconv"
	"time"
)
import (
	"context"
	"encoding/json"
	"github.com/go-redis/redis/v8"
)

var redisClient *redis.Client // Redis 客户端, 用于连接 Redis 服务器
func InitRedis() {
	ctx := context.Background()
	// 连接redis
	redisClient = redis.NewClient(&redis.Options{
		Addr:     "127.0.0.1:6379", // Redis 服务器地址
		Password: "lj502138",       // 如果 Redis 设置了密码
		DB:       2,                // 使用的数据库编号
	})

	// 验证 Redis 客户端是否可以正常工作
	_, err := redisClient.Ping(ctx).Result()
	if err != nil {
		fmt.Println("Error connecting to Redis: %v", err)
	}
}

func CloseRedis() {
	// 关闭 Redis 客户端
	if err := redisClient.Close(); err != nil {
		fmt.Println("Error closing Redis client: %v", err)
	}
}

func IsContainKey(key string) bool {
	ctx := context.Background()
	val, err := redisClient.Exists(ctx, key).Result() // 检查键是否存在, 如果存在则返回 1, 否则返回 0
	if err != nil {
		fmt.Println("Error getting key: %v", err)
		return false
	}
	if val == 0 {
		return false
	}
	return true
}

// 设置redis
func SetRedis(key string, value string) bool {
	ctx := context.Background()
	// 设置键值对, 0 表示不设置过期时间, 如果需要设置过期时间, 可以设置为 time.Second * 10 等
	err := redisClient.Set(ctx, key, value, time.Minute*30).Err()
	if err != nil {
		fmt.Println("Error setting key: %v", err)
		return false
	}
	return true
}

// 设置hash
func SetHashWithTime(key string, id int, name, email string, duration time.Duration) bool {
	//捕获错误，如果错误返回

	ctx := context.Background() // 创建一个上下文
	fields := map[string]interface{}{
		"id":    strconv.Itoa(id),
		"name":  name,
		"email": email,
	}

	// 设置哈希表的字段值, 0 表示不设置过期时间, 如果需要设置过期时间, 可以设置为 time.Second * 10 等
	err := redisClient.HSet(ctx, key, fields).Err()
	if err != nil {
		fmt.Println("Error setting key: %v", err)
		return false
	}
	err = redisClient.Expire(ctx, key, time.Hour*10).Err()
	if err != nil {
		fmt.Println("Error setting key: %v", err)
		return false
	}
	return true
}

// 设置redis hash，设置过期时间
func SetHash(key string, data map[string]interface{}) bool {
	ctx := context.Background()
	err := redisClient.HSet(ctx, key, data).Err()
	if err != nil {
		fmt.Println("%v :Error setting hash: %v", key, err)
		return false
	}
	err = redisClient.Expire(ctx, key, time.Minute*30).Err()
	if err != nil {
		fmt.Println("%v :Error setting expire: %v", key, err)
		return false
	}
	return true
}

func SetHashWithField(key string, field string, value string) bool {
	ctx := context.Background()
	err := redisClient.HSet(ctx, key, field, value).Err()
	if err != nil {
		fmt.Println("Error setting key: %v", err)
		return false
	}
	return true
}

func GetHash(key string, field string) string {
	ctx := context.Background()
	val, err := redisClient.HGet(ctx, key, field).Result()
	if err != nil {
		fmt.Println("Error getting hash: %v", err)
		return ""
	}
	return val
}

func GetHashAll(key string) map[string]string {
	ctx := context.Background()
	val, err := redisClient.HGetAll(ctx, key).Result()
	if err != nil {
		fmt.Println("Error getting hash: %v", err)
		return nil
	}
	return val
}

// 设置redis
func SetRedisWithExpire(key string, value string, expire time.Duration) bool { // 设置键值对, 0 表示不设置过期时间, 如果需要设置过期时间, 可以设置为 time.Second * 10 等
	ctx := context.Background()
	// 设置键值对, 0 表示不设置过期时间, 如果需要设置过期时间, 可以设置为 time.Second * 10 等
	err := redisClient.Set(ctx, key, value, expire).Err()
	if err != nil {
		fmt.Println("Error setting key: %v", err)
		return false
	}
	return true
}

// 获取redis
func GetRedis(key string) string {
	ctx := context.Background()
	val, err := redisClient.Get(ctx, key).Result() // 从 Redis 读取键值, 如果键不存在则返回空字符串, 如果出现错误则返回错误
	if err != nil {
		fmt.Println("Error getting key: %v", err)
		return ""
	}
	return val
}

// pop redis list from right,as stack
func PopRedisList(key string) string {
	ctx := context.Background()
	val, err := redisClient.RPop(ctx, key).Result() // 从 Redis 读取键值, 如果键不存在则返回空字符串, 如果出现错误则返回错误
	if err != nil {
		fmt.Println("Error reading from Redis: %v", err)
		return ""
	}
	return val
}

// push redis list from right
func PushRedisList(key string, value string) bool {
	ctx := context.Background()
	err := redisClient.RPush(ctx, key, value).Err()
	if err != nil {
		fmt.Println("Error setting key: %v", err)
		return false
	}
	return true
}

// delete redis key
func delRedis(key string) {
	ctx := context.Background()
	err := redisClient.Del(ctx, key).Err()
	if err != nil {
		fmt.Println("Error setting key: %v", err)
	}
}

// User 用户,用于存入 Redis hash
type RUser struct {
	ID    int    `json:"id"`
	Name  string `json:"name"`
	Age   int    `json:"age"`
	Email string `json:"email"`
}

func (u *RUser) toJSONString() string {
	// 将User对象编码为JSON字符串
	userJSON, err := json.Marshal(u)
	if err != nil {
		fmt.Println("Failed to marshal user: %v", err)
	}
	return string(userJSON)
}

// put hash to redis
func hSetRedis(key string, field string, value string) {
	ctx := context.Background()
	err := redisClient.HSet(ctx, key, field, value).Err()
	if err != nil {
		fmt.Println("Error setting key: %v", err)
	}
}

// get hash from redis
func hGetRedis(key string, field string) string {
	ctx := context.Background()
	val, err := redisClient.HGet(ctx, key, field).Result()
	if err != nil {
		fmt.Println("Error getting key: %v", err)
	}
	return val
}