545 lines
14 KiB
Go
545 lines
14 KiB
Go
package worker
|
||
|
||
import (
|
||
"StuAcaWorksAI/proto"
|
||
"context"
|
||
"encoding/json"
|
||
"fmt"
|
||
"github.com/go-redis/redis/v8"
|
||
"strconv"
|
||
"time"
|
||
)
|
||
|
||
var RedisClient *redis.Client // Redis 客户端, 用于连接 Redis 服务器
|
||
func InitRedis() error {
|
||
ctx := context.Background()
|
||
|
||
if proto.Config.REDIS_User_PW == false {
|
||
// 连接redis
|
||
RedisClient = redis.NewClient(&redis.Options{
|
||
Addr: proto.Config.REDIS_ADDR, // Redis 服务器地址
|
||
DB: proto.Config.REDIS_DB, // 使用的数据库编号
|
||
})
|
||
} else {
|
||
// 连接redis
|
||
RedisClient = redis.NewClient(&redis.Options{
|
||
Addr: proto.Config.REDIS_ADDR, // Redis 服务器地址
|
||
Password: proto.Config.REDIS_PASSWORD, // 如果 Redis 设置了密码
|
||
DB: proto.Config.REDIS_DB, // 使用的数据库编号
|
||
})
|
||
}
|
||
|
||
// 验证 Redis 客户端是否可以正常工作
|
||
_, err := RedisClient.Ping(ctx).Result()
|
||
if err != nil {
|
||
fmt.Println("Error connecting to Redis: %v", err)
|
||
}
|
||
return 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
|
||
}
|
||
|
||
// 设置redis,永久
|
||
func SetRedisForever(key string, value string) bool {
|
||
ctx := context.Background()
|
||
err := RedisClient.Set(ctx, key, value, 0).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(key, " 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(key, " Error reading from Redis: %v", err)
|
||
return ""
|
||
}
|
||
return val
|
||
}
|
||
|
||
// pop redis list from left,as queue
|
||
func PopRedisListLeft(key string) string {
|
||
ctx := context.Background()
|
||
val, err := RedisClient.LPop(ctx, key).Result() // 从 Redis 读取键值, 如果键不存在则返回空字符串, 如果出现错误则返回错误
|
||
if err != nil {
|
||
return ""
|
||
}
|
||
return val
|
||
}
|
||
|
||
func DelRedis(key string) {
|
||
ctx := context.Background()
|
||
err := RedisClient.Del(ctx, key).Err()
|
||
if err != nil {
|
||
fmt.Println("Error deleting key: %v", err)
|
||
}
|
||
}
|
||
|
||
// 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
|
||
}
|
||
|
||
func GetRedisListLen(key string) int64 {
|
||
ctx := context.Background()
|
||
val, err := RedisClient.LLen(ctx, key).Result()
|
||
if err != nil {
|
||
fmt.Println("Error getting key: %v", err)
|
||
return 0
|
||
}
|
||
return val
|
||
}
|
||
|
||
func PushRedisListWithExpire(key string, value string, expire time.Duration) bool {
|
||
ctx := context.Background()
|
||
err := RedisClient.RPush(ctx, key, value).Err()
|
||
if err != nil {
|
||
fmt.Println("Error setting key: %v", err)
|
||
return false
|
||
}
|
||
err = RedisClient.Expire(ctx, key, expire).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
|
||
}
|
||
|
||
// 设置set，有过期时间
|
||
func SetRedisSet(key string, values []string, expire time.Duration) bool {
|
||
ctx := context.Background()
|
||
err := RedisClient.SAdd(ctx, key, values).Err()
|
||
if err != nil {
|
||
fmt.Println("Error setting key: %v", err)
|
||
return false
|
||
}
|
||
err = RedisClient.Expire(ctx, key, expire).Err()
|
||
if err != nil {
|
||
fmt.Println("Error setting key: %v", err)
|
||
return false
|
||
}
|
||
return true
|
||
}
|
||
|
||
// 设置set,添加元素
|
||
func SetRedisSetAdd(key string, value string) bool {
|
||
ctx := context.Background()
|
||
err := RedisClient.SAdd(ctx, key, value).Err()
|
||
if err != nil {
|
||
fmt.Println("Error setting key: %v", err)
|
||
return false
|
||
}
|
||
return true
|
||
}
|
||
|
||
// 批量添加元素
|
||
func SetRedisSetAddBatchWithExpire(key string, values []string, expire time.Duration) bool {
|
||
ctx := context.Background()
|
||
err := RedisClient.SAdd(ctx, key, values).Err()
|
||
if err != nil {
|
||
fmt.Println("SetRedisSetAddBatchWithExpire Error setting key: %v", err)
|
||
return false
|
||
}
|
||
err = RedisClient.Expire(ctx, key, expire).Err()
|
||
if err != nil {
|
||
fmt.Println("SetRedisSetAddBatchWithExpire Error setting key: %v", err)
|
||
return false
|
||
}
|
||
return true
|
||
|
||
}
|
||
|
||
// 设置set,添加元素
|
||
func SetRedisSetAddWithExpire(key string, value string, expire time.Duration) bool {
|
||
ctx := context.Background()
|
||
err := RedisClient.SAdd(ctx, key, value).Err()
|
||
if err != nil {
|
||
fmt.Println("SetRedisSetAddWithExpire Error setting key: %v", err)
|
||
return false
|
||
}
|
||
err = RedisClient.Expire(ctx, key, expire).Err()
|
||
if err != nil {
|
||
fmt.Println("SetRedisSetAddWithExpire Error setting key: %v", err)
|
||
return false
|
||
}
|
||
return true
|
||
}
|
||
|
||
// 设置set,删除元素
|
||
func SetRedisSetRemove(key string, value string) bool {
|
||
ctx := context.Background()
|
||
err := RedisClient.SRem(ctx, key, value).Err()
|
||
if err != nil {
|
||
fmt.Println("Error setting key: %v", err)
|
||
return false
|
||
}
|
||
return true
|
||
}
|
||
|
||
// 获取两个set的交集
|
||
func GetRedisSetIntersect(key1 string, key2 string) []string {
|
||
ctx := context.Background()
|
||
val, err := RedisClient.SInter(ctx, key1, key2).Result()
|
||
if err != nil {
|
||
fmt.Println("Error getting key: %v", err)
|
||
return nil
|
||
}
|
||
return val
|
||
}
|
||
|
||
// 查看set是否包含元素
|
||
func IsContainSet(key string, value string) bool {
|
||
ctx := context.Background()
|
||
val, err := RedisClient.SIsMember(ctx, key, value).Result()
|
||
if err != nil {
|
||
fmt.Println("Error getting key: %v", err)
|
||
return false
|
||
}
|
||
return val
|
||
}
|
||
|
||
// 查看set的所有元素
|
||
func GetRedisSetMembers(key string) []string {
|
||
ctx := context.Background()
|
||
val, err := RedisClient.SMembers(ctx, key).Result()
|
||
if err != nil {
|
||
fmt.Println("Error getting key: %v", err)
|
||
return nil
|
||
}
|
||
return val
|
||
}
|
||
|
||
// BITMAP
|
||
func SetRedisBitmap(key string, offset int64, value int) bool {
|
||
ctx := context.Background()
|
||
err := RedisClient.SetBit(ctx, key, offset, value).Err()
|
||
if err != nil {
|
||
fmt.Println("Error setting key: %v", err)
|
||
return false
|
||
}
|
||
return true
|
||
}
|
||
|
||
// BITMAP获取
|
||
func GetRedisBitmap(key string, offset int64) int {
|
||
ctx := context.Background()
|
||
val, err := RedisClient.GetBit(ctx, key, offset).Result()
|
||
if err != nil {
|
||
fmt.Println("Error getting key: %v", err)
|
||
return 0
|
||
}
|
||
return int(val)
|
||
}
|
||
|
||
// 发布订阅者模式-发布消息
|
||
func Publish(channel string, message string, expire time.Duration) {
|
||
ctx := context.Background()
|
||
err := RedisClient.Publish(ctx, channel, message).Err()
|
||
if err != nil {
|
||
fmt.Println("Error publishing message: %v", err)
|
||
}
|
||
err = RedisClient.Expire(ctx, channel, expire).Err()
|
||
if err != nil {
|
||
fmt.Println("Error setting key: %v", err)
|
||
}
|
||
}
|
||
|
||
// 发布订阅者模式-订阅消息
|
||
func Subscribe(channel string) []string {
|
||
ctx := context.Background()
|
||
pubsub := RedisClient.Subscribe(ctx, channel)
|
||
ch := pubsub.Channel()
|
||
defer pubsub.Close()
|
||
var messages []string
|
||
for msg := range ch {
|
||
messages = append(messages, msg.Payload)
|
||
}
|
||
return messages
|
||
}
|
||
|
||
// redis两个set求差集存入第一个set
|
||
func SetRedisSetDiffAndStore(key1 string, key2 string) bool {
|
||
ctx := context.Background()
|
||
err := RedisClient.SDiffStore(ctx, key1, key1, key2).Err() //将key1和key2的差集存入key1
|
||
if err != nil {
|
||
fmt.Println("SetRedisSetDiffAndStore Error setting key: %v", err)
|
||
return false
|
||
}
|
||
return true
|
||
}
|
||
|
||
// redis将第二个set存入第一个set
|
||
func SetRedisSetUnionAndStore(key1 string, key2 string) bool {
|
||
ctx := context.Background()
|
||
err := RedisClient.SUnionStore(ctx, key1, key1, key2).Err() //将key1和key2的并集存入key1
|
||
if err != nil {
|
||
fmt.Println("SetRedisSetUnionAndStore Error setting key: %v", err)
|
||
return false
|
||
}
|
||
return true
|
||
}
|
||
|
||
// redis 清空set
|
||
func ClearRedisSet(key string) bool {
|
||
ctx := context.Background()
|
||
err := RedisClient.Del(ctx, key).Err()
|
||
if err != nil {
|
||
fmt.Println("Error setting key: %v", err)
|
||
return false
|
||
}
|
||
return true
|
||
}
|
||
|
||
// 获取两个集合的并集
|
||
func GetRedisSetUnion(key1 string, key2 string) []string {
|
||
ctx := context.Background()
|
||
val, err := RedisClient.SUnion(ctx, key1, key2).Result()
|
||
if err != nil {
|
||
fmt.Println("Error getting key: %v", err)
|
||
return nil
|
||
}
|
||
return val
|
||
}
|
||
|
||
type RedisInfo struct {
|
||
Key string
|
||
Value string
|
||
Type string
|
||
Expire int // 过期时间, 单位: 秒
|
||
}
|
||
|
||
// 获取所有的key和value,及其对应的过期时间
|
||
func GetAllRedisInfo() ([]RedisInfo, error) {
|
||
ctx := context.Background()
|
||
keys, err := RedisClient.Keys(ctx, "*").Result()
|
||
if err != nil {
|
||
fmt.Println("Error getting key: %v", err)
|
||
return nil, err
|
||
}
|
||
var redisInfos []RedisInfo
|
||
for _, key := range keys {
|
||
//先查看key类型，再根据类型获取value
|
||
key_type, val, err := getKeyTypeAndData(key)
|
||
if err != nil {
|
||
fmt.Println("Error getting key: %v", err)
|
||
return nil, err
|
||
}
|
||
expire, err := RedisClient.TTL(ctx, key).Result()
|
||
if err != nil {
|
||
fmt.Println("Error getting key: %v", err)
|
||
return nil, err
|
||
}
|
||
redisInfo := RedisInfo{
|
||
Key: key,
|
||
Value: val,
|
||
Type: key_type,
|
||
Expire: int(expire.Seconds()),
|
||
}
|
||
redisInfos = append(redisInfos, redisInfo)
|
||
}
|
||
return redisInfos, nil
|
||
}
|
||
|
||
func getKeyTypeAndData(key string) (string, string, error) {
|
||
ctx := context.Background()
|
||
key_type := RedisClient.Type(ctx, key).Val()
|
||
var val interface{}
|
||
var err error
|
||
switch key_type {
|
||
case "string":
|
||
val, err = RedisClient.Get(ctx, key).Result()
|
||
case "hash":
|
||
val, err = RedisClient.HGetAll(ctx, key).Result()
|
||
case "list":
|
||
val, err = RedisClient.LRange(ctx, key, 0, -1).Result()
|
||
case "set":
|
||
val, err = RedisClient.SMembers(ctx, key).Result()
|
||
case "zset":
|
||
val, err = RedisClient.ZRange(ctx, key, 0, -1).Result()
|
||
case "bitmap":
|
||
val, err = RedisClient.GetBit(ctx, key, 0).Result()
|
||
default:
|
||
val = "unknown type"
|
||
}
|
||
return key_type, fmt.Sprintf("%v", val), err
|
||
}
|