Golang 操作 Redis：为 Hash 中的字段设置过期时间 - go-redis 使用指南

package main

import (
    "context"
    "fmt"
    "github.com/redis/go-redis/v9"
    "time"
)

var ctx = context.Background()

// 设置 Hash 中的字段和字段的过期时间
func setFieldWithExpiration(rdb *redis.Client, hashKey, field, value string, expiration time.Duration) error {
    // 设置 Hash 中的字段值
    if err := rdb.HSet(ctx, hashKey, field, value).Err(); err != nil {
        return err
    }

    // 设置字段过期时间的辅助 key
    expirationKey := fmt.Sprintf("%s:%s:expiration", hashKey, field)
    return rdb.Set(ctx, expirationKey, time.Now().Add(expiration).Unix(), expiration).Err()
}

// 获取 Hash 中的字段值
func getField(rdb *redis.Client, hashKey, field string) (string, error) {
    expirationKey := fmt.Sprintf("%s:%s:expiration", hashKey, field)

    // 检查字段是否过期
    expirationTimeStr, err := rdb.Get(ctx, expirationKey).Result()
    if err != nil && err != redis.Nil {
        return "", err
    }

    if expirationTimeStr != "" {
        expirationTime, err := time.ParseInt(expirationTimeStr, 10, 64)
        if err != nil {
            return "", err
        }

        if time.Now().Unix() > expirationTime {
            // 如果字段已过期，删除字段和过期时间
            rdb.HDel(ctx, hashKey, field)
            rdb.Del(ctx, expirationKey)
            return "", nil
        }
    }

    // 返回 Hash 中的字段值
    return rdb.HGet(ctx, hashKey, field).Result()
}

// 定期扫描并清理过期的 Hash 字段
func cleanExpiredFields(rdb *redis.Client, hashKey string) error {
    cursor := uint64(0)
    for {
        // 扫描所有过期时间 key
        keys, nextCursor, err := rdb.Scan(ctx, cursor, fmt.Sprintf("%s:*:expiration", hashKey), 0).Result()
        if err != nil {
            return err
        }

        cursor = nextCursor
        if cursor == 0 {
            break
        }

        // 使用 MGet 批量获取所有过期时间 key 的值
        expirationValues, err := rdb.MGet(ctx, keys...).Result()
        if err != nil {
            return err
        }

        // 处理每个过期时间 key
        for i, key := range keys {
            expirationTimeStr := expirationValues[i]
            if expirationTimeStr != nil {
                expirationTime, err := time.ParseInt(expirationTimeStr.(string), 10, 64)
                if err != nil {
                    return err
                }

                if time.Now().Unix() > expirationTime {
                    // 如果字段已过期，删除 Hash 中的字段和过期时间 key
                    field := key[len(hashKey)+1:len(key)-len(":expiration")]
                    rdb.HDel(ctx, hashKey, field)
                    rdb.Del(ctx, key)
                }
            }
        }
    }
    return nil
}

func main() {
    rdb := redis.NewClient(&redis.Options{
        Addr:     "localhost:6379",
        Password: "",
        DB:       0,
    })

    // 设置字段 "field1" 的值和过期时间为 10 秒
    if err := setFieldWithExpiration(rdb, "myhash", "field1", "value1", 10*time.Second); err != nil {
        fmt.Println("Error setting field with expiration:", err)
        return
    }

    // 启动清理过期字段的定时任务
    ticker := time.NewTicker(5 * time.Second)
    defer ticker.Stop()

    go func() {
        for range ticker.C {
            if err := cleanExpiredFields(rdb, "myhash"); err != nil {
                fmt.Println("Error cleaning expired fields:", err)
            }
        }
    }()

    // 测试获取字段值
    value, err := getField(rdb, "myhash", "field1")
    if err != nil {
        fmt.Println("Error getting field:", err)
        return
    }

    fmt.Println("Field value:", value)

    // 等待 10 秒以超出字段的过期时间
    time.Sleep(10 * time.Second)

    // 再次获取字段值
    value, err = getField(rdb, "myhash", "field1")
    if err != nil {
        fmt.Println("Error getting field:", err)
        return
    }

    fmt.Println("Field value after expiration:", value)

    // 保持主线程运行
    select {}
}