缓存实战

func GetUser(ctx context.Context, id int64) (*User, error) {
    key := fmt.Sprintf("user:%d", id)
    // 1. 查缓存
    data, err := rdb.Get(ctx, key).Result()
    if err == nil {
        var user User
        json.Unmarshal([]byte(data), &user)
        return &user, nil
    }
    // 2. 查数据库
    user, err := db.QueryUser(ctx, id)
    if err != nil {
        return nil, err
    }
    // 3. 写缓存
    userBytes, _ := json.Marshal(user)
    rdb.Set(ctx, key, userBytes, 30*time.Minute)
    return user, nil
}

func UpdateUser(ctx context.Context, user *User) error {
    // 1. 更新数据库
    if err := db.UpdateUser(ctx, user); err != nil {
        return err
    }
    // 2. 删除缓存
    key := fmt.Sprintf("user:%d", user.ID)
    rdb.Del(ctx, key)
    return nil
}

// 伪代码：缓存层自动同步
type CacheService struct {
    rdb *redis.Client
    db  *sql.DB
}

func (s *CacheService) Get(ctx context.Context, key string) (string, error) {
    val, err := s.rdb.Get(ctx, key).Result()
    if err == nil {
        return val, nil
    }
    // 同步加载到缓存
    val, err = s.db.Load(ctx, key)
    if err != nil {
        return "", err
    }
    s.rdb.Set(ctx, key, val, 0)
    return val, nil
}

// 示例：文章阅读数计数
func IncrViewCount(ctx context.Context, articleID int64) error {
    key := fmt.Sprintf("article:view:%d", articleID)
    return rdb.Incr(ctx, key).Err()
}

// 定时任务：每5分钟批量同步到MySQL
func SyncViewCounts(ctx context.Context) error {
    keys, _ := rdb.Keys(ctx, "article:view:*").Result()
    for _, key := range keys {
        count, _ := rdb.GetSet(ctx, key, "0").Int64()
        articleID := extractID(key)
        db.UpdateViewCount(ctx, articleID, count)
    }
    return nil
}

// 延迟双删
func UpdateWithDelayDoubleDelete(ctx context.Context, user *User) error {
    key := fmt.Sprintf("user:%d", user.ID)
    // 第一删
    rdb.Del(ctx, key)
    // 更新数据库
    if err := db.UpdateUser(ctx, user); err != nil {
        return err
    }
    // 第二删（延迟执行）
    time.AfterFunc(500*time.Millisecond, func() {
        rdb.Del(context.Background(), key)
    })
    return nil
}

func GetItem(ctx context.Context, id int64) (*Item, error) {
    key := fmt.Sprintf("item:%d", id)

    data, err := rdb.Get(ctx, key).Result()
    if err == nil {
        if data == "null" {
            return nil, ErrNotFound
        }
        var item Item
        json.Unmarshal([]byte(data), &item)
        return &item, nil
    }

    item, err := db.QueryItem(ctx, id)
    if errors.Is(err, sql.ErrNoRows) {
        // 缓存空对象，短 TTL
        rdb.Set(ctx, key, "null", 5*time.Minute)
        return nil, ErrNotFound
    }
    if err != nil {
        return nil, err
    }

    itemBytes, _ := json.Marshal(item)
    rdb.Set(ctx, key, itemBytes, 30*time.Minute)
    return item, nil
}

# 创建布隆过滤器
BF.RESERVE user_filter 0.01 1000000

# 添加元素
BF.ADD user_filter user:1001
BF.MADD user_filter user:1002 user:1003

# 检查存在
BF.EXISTS user_filter user:1001   # 返回 1
BF.EXISTS user_filter user:9999   # 返回 0（一定不存在）

// 使用多个 hash 函数 + SETBIT/GETBIT 实现简易布隆过滤器
const (
    bloomKey = "bloom:user"
    hashCount = 3
)

func AddToBloom(ctx context.Context, value string) error {
    pipe := rdb.Pipeline()
    for i := 0; i < hashCount; i++ {
        offset := hash(value, i) % (1 << 20) // 位数组大小 2^20
        pipe.SetBit(ctx, bloomKey, int64(offset), 1)
    }
    _, err := pipe.Exec(ctx)
    return err
}

func ExistInBloom(ctx context.Context, value string) bool {
    pipe := rdb.Pipeline()
    cmds := make([]*redis.IntCmd, hashCount)
    for i := 0; i < hashCount; i++ {
        offset := hash(value, i) % (1 << 20)
        cmds[i] = pipe.GetBit(ctx, bloomKey, int64(offset))
    }
    pipe.Exec(ctx)
    for _, cmd := range cmds {
        if cmd.Val() == 0 {
            return false
        }
    }
    return true // 可能存在
}

func GetItemHandler(w http.ResponseWriter, r *http.Request) {
    id, err := strconv.ParseInt(r.URL.Query().Get("id"), 10, 64)
    if err != nil || id <= 0 {
        http.Error(w, "invalid id", http.StatusBadRequest)
        return
    }
    // ... 继续处理
}

const baseTTL = 30 * time.Minute

func SetWithJitter(ctx context.Context, key string, value interface{}) error {
    data, _ := json.Marshal(value)
    // 在基础 TTL 基础上加 ±5 分钟的随机偏移
    ttl := baseTTL + time.Duration(rand.Int63n(600))*time.Second
    return rdb.Set(ctx, key, data, ttl).Err()
}

# sentinel.conf
sentinel monitor mymaster 192.168.1.10 6379 2
sentinel down-after-milliseconds mymaster 30000
sentinel parallel-syncs mymaster 1
sentinel failover-timeout mymaster 180000

// 简单的本地限流器
var limiter = rate.NewLimiter(100, 200) // 100 QPS, burst 200

func GetItemWithLimiter(ctx context.Context, id int64) (*Item, error) {
    if !limiter.Allow() {
        return nil, errors.New("rate limited")
    }
    return GetItem(ctx, id)
}

func GetHotItem(ctx context.Context, id int64) (*Item, error) {
    cacheKey := fmt.Sprintf("item:%d", id)
    lockKey := fmt.Sprintf("lock:item:%d", id)

    // 1. 查缓存
    data, err := rdb.Get(ctx, cacheKey).Result()
    if err == nil {
        var item Item
        json.Unmarshal([]byte(data), &item)
        return &item, nil
    }

    // 2. 尝试获取互斥锁
    locked, err := rdb.SetNX(ctx, lockKey, "1", 10*time.Second).Result()
    if err != nil {
        return nil, err
    }

    if locked {
        // 3. 获取锁成功：Double Check + 查 DB + 写缓存 + 释放锁
        defer rdb.Del(ctx, lockKey)

        // Double Check
        data, err = rdb.Get(ctx, cacheKey).Result()
        if err == nil {
            var item Item
            json.Unmarshal([]byte(data), &item)
            return &item, nil
        }

        // 查数据库
        item, err := db.QueryItem(ctx, id)
        if err != nil {
            return nil, err
        }

        // 写缓存
        itemBytes, _ := json.Marshal(item)
        rdb.Set(ctx, cacheKey, itemBytes, 30*time.Minute)
        return item, nil
    }

    // 4. 获取锁失败：等待并重试（最多重试 10 次）
    for i := 0; i < 10; i++ {
        time.Sleep(50 * time.Millisecond)
        data, err = rdb.Get(ctx, cacheKey).Result()
        if err == nil {
            var item Item
            json.Unmarshal([]byte(data), &item)
            return &item, nil
        }
    }
    return nil, errors.New("failed to get item after retries")
}

type ItemWithExpire struct {
    Data      Item   `json:"data"`
    ExpireAt  int64  `json:"expire_at"` // 逻辑过期时间戳（毫秒）
}

const (
    cacheTTL      = 24 * time.Hour // 物理过期时间（很长，或设 -1 永不物理过期）
    logicTTL      = 30 * time.Minute // 逻辑过期时间
    lockTTL       = 10 * time.Second
)

func GetHotItemLogical(ctx context.Context, id int64) (*Item, error) {
    cacheKey := fmt.Sprintf("item:logical:%d", id)
    lockKey := fmt.Sprintf("lock:item:logical:%d", id)

    data, err := rdb.Get(ctx, cacheKey).Result()
    if err != nil {
        // 缓存中完全没有：正常查 DB 并写入（首次加载）
        return loadAndCache(ctx, id, cacheKey)
    }

    var cached ItemWithExpire
    if err := json.Unmarshal([]byte(data), &cached); err != nil {
        return nil, err
    }

    // 判断是否逻辑过期
    if time.Now().UnixMilli() < cached.ExpireAt {
        // 未过期，直接返回
        return &cached.Data, nil
    }

    // 已过期，尝试获取锁
    locked, _ := rdb.SetNX(ctx, lockKey, "1", lockTTL).Result()
    if locked {
        // 获得锁：异步重建
        go rebuildCache(context.Background(), id, cacheKey, lockKey)
    }
    // 无论是否获得锁，都返回旧数据
    return &cached.Data, nil
}

func loadAndCache(ctx context.Context, id int64, cacheKey string) (*Item, error) {
    item, err := db.QueryItem(ctx, id)
    if err != nil {
        return nil, err
    }

    wrapped := ItemWithExpire{
        Data:     *item,
        ExpireAt: time.Now().Add(logicTTL).UnixMilli(),
    }
    data, _ := json.Marshal(wrapped)
    rdb.Set(ctx, cacheKey, data, cacheTTL)
    return item, nil
}

func rebuildCache(ctx context.Context, id int64, cacheKey, lockKey string) {
    defer rdb.Del(ctx, lockKey)

    // Double Check：可能其他线程已经重建过
    data, _ := rdb.Get(ctx, cacheKey).Result()
    if data != "" {
        var cached ItemWithExpire
        json.Unmarshal([]byte(data), &cached)
        if time.Now().UnixMilli() < cached.ExpireAt {
            return // 已被其他线程重建，无需再次重建
        }
    }

    item, err := db.QueryItem(ctx, id)
    if err != nil {
        return
    }

    wrapped := ItemWithExpire{
        Data:     *item,
        ExpireAt: time.Now().Add(logicTTL).UnixMilli(),
    }
    newData, _ := json.Marshal(wrapped)
    rdb.Set(ctx, cacheKey, newData, cacheTTL)
}

# 获取锁：NX（不存在才设置）+ EX（超时时间，防止死锁）
SET lock:order:1001 uuid-12345 NX EX 30

-- unlock.lua
-- KEYS[1]: 锁的 key
-- ARGV[1]: 锁的 value（唯一标识）
if redis.call('GET', KEYS[1]) == ARGV[1] then
    return redis.call('DEL', KEYS[1])
else
    return 0
end

package lock

import (
    "context"
    "errors"
    "time"

    "github.com/google/uuid"
    "github.com/redis/go-redis/v9"
)

type RedisLock struct {
    rdb       *redis.Client
    key       string
    value     string // 唯一标识，释放时校验
    expireSec int
}

// NewRedisLock 创建一个 Redis 分布式锁实例
func NewRedisLock(rdb *redis.Client, key string, expireSec int) *RedisLock {
    return &RedisLock{
        rdb:       rdb,
        key:       key,
        value:     uuid.New().String(),
        expireSec: expireSec,
    }
}

// TryLock 尝试获取锁，返回是否成功
func (l *RedisLock) TryLock(ctx context.Context) (bool, error) {
    return l.rdb.SetNX(ctx, l.key, l.value, time.Duration(l.expireSec)*time.Second).Result()
}

// Lock 阻塞获取锁，支持重试
func (l *RedisLock) Lock(ctx context.Context, retryTimes int, retryInterval time.Duration) (bool, error) {
    for i := 0; i < retryTimes; i++ {
        ok, err := l.TryLock(ctx)
        if err != nil {
            return false, err
        }
        if ok {
            return true, nil
        }
        time.Sleep(retryInterval)
    }
    return false, errors.New("failed to acquire lock after retries")
}

// Unlock 释放锁（Lua 脚本保证原子性）
func (l *RedisLock) Unlock(ctx context.Context) error {
    script := `
        if redis.call('GET', KEYS[1]) == ARGV[1] then
            return redis.call('DEL', KEYS[1])
        else
            return 0
        end
    `
    result, err := l.rdb.Eval(ctx, script, []string{l.key}, l.value).Result()
    if err != nil {
        return err
    }
    if result.(int64) == 0 {
        return errors.New("lock already released by others or expired")
    }
    return nil
}

// 使用 go:embed 嵌入 Lua 脚本（推荐方式）

//go:embed scripts/unlock.lua
var unlockScript string

func (l *RedisLock) UnlockWithEmbed(ctx context.Context) error {
    result, err := l.rdb.Eval(ctx, unlockScript, []string{l.key}, l.value).Result()
    if err != nil {
        return err
    }
    if result.(int64) == 0 {
        return errors.New("lock already released by others or expired")
    }
    return nil
}

func main() {
    ctx := context.Background()
    lock := NewRedisLock(rdb, "lock:order:1001", 30)

    ok, err := lock.TryLock(ctx)
    if err != nil || !ok {
        log.Fatal("failed to acquire lock")
    }
    defer lock.Unlock(ctx)

    // 执行业务逻辑
    processOrder(ctx, 1001)
}

-- reentrant_lock.lua
local key = KEYS[1]
local threadId = ARGV[1]
local ttl = ARGV[2]

-- 如果锁不存在，或当前线程持有锁
if redis.call('EXISTS', key) == 0 or redis.call('HEXISTS', key, threadId) == 1 then
    redis.call('HINCRBY', key, threadId, 1)
    redis.call('EXPIRE', key, ttl)
    return 1
end
return 0

// WatchDog 自动续期
func (l *RedisLock) StartWatchDog(ctx context.Context) {
    ticker := time.NewTicker(time.Duration(l.expireSec/3) * time.Second)
    defer ticker.Stop()

    for {
        select {
        case <-ctx.Done():
            return
        case <-ticker.C:
            // 续期：把锁的超时时间重置
            script := `
                if redis.call('GET', KEYS[1]) == ARGV[1] then
                    return redis.call('EXPIRE', KEYS[1], ARGV[2])
                end
                return 0
            `
            result, _ := l.rdb.Eval(ctx, script, []string{l.key}, l.value, l.expireSec).Result()
            if result.(int64) == 0 {
                return // 锁已不属于当前线程，停止续期
            }
        }
    }
}

// 使用示例
func ProcessWithWatchDog(ctx context.Context) error {
    lock := NewRedisLock(rdb, "lock:task", 10)

    ctx, cancel := context.WithCancel(context.Background())
    defer cancel()

    go lock.StartWatchDog(ctx) // 启动看门狗

    ok, _ := lock.TryLock(ctx)
    if !ok {
        return errors.New("lock failed")
    }
    defer lock.Unlock(ctx)

    // 执行长时间任务...
    time.Sleep(30 * time.Second)
    return nil
}

import (
    "github.com/go-redsync/redsync/v4"
    "github.com/go-redsync/redsync/v4/redis/goredis/v9"
)

func NewRedlock() *redsync.Redsync {
    // 创建多个独立 Redis 连接池
    pools := []redsync.Pool{
        goredis.NewPool(rdb1),
        goredis.NewPool(rdb2),
        goredis.NewPool(rdb3),
        goredis.NewPool(rdb4),
        goredis.NewPool(rdb5),
    }
    return redsync.New(pools...)
}

func LockWithRedlock(ctx context.Context, rs *redsync.Redsync) error {
    mutex := rs.NewMutex("lock:order:1001",
        redsync.WithExpiry(8*time.Second),
        redsync.WithTries(3),              // 重试次数
        redsync.WithRetryDelay(100*time.Millisecond),
    )

    if err := mutex.LockContext(ctx); err != nil {
        return err
    }
    defer mutex.UnlockContext(ctx)

    // 业务逻辑
    return nil
}

package idgen

import (
    "context"
    "fmt"
    "time"

    "github.com/redis/go-redis/v9"
)

const BeginTimeStamp uint64 = 1710000000 // 自定义起始时间戳

var rdb *redis.Client

// GenId 生成全局唯一 ID
func GenId(ctx context.Context, keyPrefix string) (int64, error) {
    // 1. 生成时间戳部分（当前时间 - 基准时间）
    now := time.Now().Unix()
    timePart := uint64(now) - BeginTimeStamp

    // 2. 使用 Redis INCR 生成序列号（原子操作、保证唯一）
    dateKey := fmt.Sprintf("icr:%s:%s", keyPrefix, time.Now().Format("2006:01:02"))
    seq, err := rdb.Incr(ctx, dateKey).Result()
    if err != nil {
        return 0, fmt.Errorf("redis incr failed: %w", err)
    }

    // 序列号 key 一天后自动过期
    rdb.Expire(ctx, dateKey, 24*time.Hour)

    // 3. 拼接：时间戳左移 32 位 | 序列号
    id := int64((timePart << 32) | uint64(seq))
    return id, nil
}

// ParseId 从 ID 中解析出时间戳和序列号（调试用）
func ParseId(id int64) (timestamp uint64, seq uint64) {
    u := uint64(id)
    return (u >> 32) + BeginTimeStamp, u & 0xFFFFFFFF
}

-- 扣减时判断 stock > 0
UPDATE seckill_voucher
SET stock = stock - 1
WHERE voucher_id = ? AND stock > 0;

func DeductStock(ctx context.Context, voucherID int64) error {
    result, err := db.Exec(ctx,
        "UPDATE seckill_voucher SET stock=stock-1 WHERE voucher_id=? AND stock>0",
        voucherID,
    )
    if err != nil {
        return err
    }
    rowsAffected, _ := result.RowsAffected()
    if rowsAffected == 0 {
        return errors.New("stock exhausted")
    }
    return nil
}

-- 扣减时检查版本号
UPDATE seckill_voucher
SET stock = stock - 1, version = version + 1
WHERE voucher_id = ? AND version = ?;

-- 使用 SELECT ... FOR UPDATE
SELECT stock FROM seckill_voucher WHERE voucher_id = ? FOR UPDATE;
-- 判断 stock > 0 后执行 UPDATE

ALTER TABLE seckill_order ADD UNIQUE INDEX idx_user_voucher (user_id, voucher_id);

func CheckAndOrder(ctx context.Context, userID, voucherID int64) error {
    member := fmt.Sprintf("%d", userID)

    // 使用 SADD 的返回值判断：返回 1 表示首次添加（未下单），0 表示已存在（已下单）
    added, err := rdb.SAdd(ctx, fmt.Sprintf("order:set:%d", voucherID), member).Result()
    if err != nil {
        return err
    }
    if added == 0 {
        return errors.New("duplicate order")
    }

    // 这里还需要原子性地检查库存...
    return nil
}

-- seckill.lua
-- KEYS[1]: 库存 key (stock:voucher:id)
-- KEYS[2]: 已下单用户集合 key (order:set:voucher:id)
-- ARGV[1]: 用户 ID
-- ARGV[2]: 订单 ID

local stock = tonumber(redis.call('GET', KEYS[1]))
if stock == nil or stock <= 0 then
    return -1  -- 库存不足
end

-- 检查用户是否已下单
if redis.call('SISMEMBER', KEYS[2], ARGV[1]) == 1 then
    return -2  -- 重复下单
end

-- 扣减库存
redis.call('DECR', KEYS[1])
-- 记录用户已下单
redis.call('SADD', KEYS[2], ARGV[1])
-- 将订单信息放入消息队列，异步写入 DB
redis.call('LPUSH', 'order:queue', ARGV[2])
return 1  -- 秒杀成功

func Seckill(ctx context.Context, voucherID, userID int64, orderID string) (int, error) {
    script := `
        local stock = tonumber(redis.call('GET', KEYS[1]))
        if stock == nil or stock <= 0 then
            return -1
        end
        if redis.call('SISMEMBER', KEYS[2], ARGV[1]) == 1 then
            return -2
        end
        redis.call('DECR', KEYS[1])
        redis.call('SADD', KEYS[2], ARGV[1])
        redis.call('LPUSH', KEYS[3], ARGV[2])
        return 1
    `
    stockKey := fmt.Sprintf("stock:voucher:%d", voucherID)
    userKey := fmt.Sprintf("order:set:%d", voucherID)
    queueKey := "order:queue"

    result, err := rdb.Eval(ctx, script, []string{stockKey, userKey, queueKey},
        userID, orderID).Int()
    if err != nil {
        return 0, err
    }
    return result, nil
}

func StartOrderWorker(ctx context.Context) {
    for {
        // BRPOP 阻塞弹出，超时 5 秒
        result, err := rdb.BRPop(ctx, 5*time.Second, "order:queue").Result()
        if err != nil {
            continue
        }
        orderID := result[1]

        // 写入数据库
        if err := db.CreateOrder(ctx, orderID); err != nil {
            log.Printf("create order failed: %v", err)
            // 写入死信队列，人工处理
            rdb.LPush(ctx, "order:dlq", orderID)
        }
    }
}

const bigVFollowersThreshold = 10000

func PublishPost(ctx context.Context, userID int64, postID string, content string) error {
    score := float64(time.Now().UnixMilli())
    followerCount := getUserFollowerCount(ctx, userID)

    if followerCount < bigVFollowersThreshold {
        // 普通用户：推模式，写入所有粉丝的收件箱
        followers := getFollowers(ctx, userID)
        pipe := rdb.Pipeline()
        for _, followerID := range followers {
            feedKey := fmt.Sprintf("feed:%d", followerID)
            pipe.ZAdd(ctx, feedKey, redis.Z{Score: score, Member: postID})
        }
        _, err := pipe.Exec(ctx)
        return err
    }

    // 大 V：仅写入自己的发布列表，粉丝读取时拉取
    outboxKey := fmt.Sprintf("outbox:%d", userID)
    return rdb.ZAdd(ctx, outboxKey, redis.Z{Score: score, Member: postID}).Err()
}

func GetFeed(ctx context.Context, userID int64, lastScore float64, limit int) ([]string, error) {
    feedKey := fmt.Sprintf("feed:%d", userID)
    // 推模式：直接读取自己的收件箱
    posts, err := rdb.ZRevRangeByScore(ctx, feedKey, &redis.ZRangeBy{
        Min:    "0",
        Max:    fmt.Sprintf("%f", lastScore),
        Offset: 0,
        Count:  int64(limit),
    }).Result()
    if err != nil {
        return nil, err
    }

    // 拉模式：拉取关注的大 V 的最新内容
    bigVs := getBigVFollowing(ctx, userID)
    for _, bvID := range bigVs {
        bvPosts, _ := rdb.ZRevRangeByScore(ctx, fmt.Sprintf("outbox:%d", bvID), &redis.ZRangeBy{
            Min:    "0",
            Max:    fmt.Sprintf("%f", lastScore),
            Offset: 0,
            Count:  int64(limit),
        }).Result()
        posts = append(posts, bvPosts...)
    }

    return posts, nil
}

// FeedPage 滚动分页查询
type FeedPage struct {
    Items     []string `json:"items"`
    LastScore float64  `json:"last_score"` // 下一页游标
    HasMore   bool     `json:"has_more"`   // 是否还有更多
}

func GetFeedByCursor(ctx context.Context, userID int64, lastScore float64, limit int) (*FeedPage, error) {
    feedKey := fmt.Sprintf("feed:%d", userID)
    limitPlusOne := int64(limit + 1) // 多取一条，判断 has_more

    maxScore := fmt.Sprintf("%f", lastScore)
    if lastScore == 0 {
        maxScore = "+inf" // 首次请求，从最新开始
    }

    // ZREVRANGEBYSCORE：按 score 倒序，从 maxScore 开始（不含）
    results, err := rdb.ZRevRangeByScoreWithScores(ctx, feedKey, &redis.ZRangeBy{
        Min:    "-inf",
        Max:    maxScore,
        Offset: 0,
        Count:  limitPlusOne,
    }).Result()
    if err != nil {
        return nil, err
    }

    page := &FeedPage{
        Items:   make([]string, 0, limit),
        HasMore: len(results) > limit,
    }

    for i, z := range results {
        if i >= limit {
            break
        }
        page.Items = append(page.Items, z.Member.(string))
    }

    if len(results) > 0 {
        lastIdx := min(limit, len(results)) - 1
        page.LastScore = results[lastIdx].Score
    }

    return page, nil
}

# 添加商铺地理坐标
GEOADD shops:location 116.404 39.915 "shop:1"   # 北京
GEOADD shops:location 121.473 31.230 "shop:2"   # 上海
GEOADD shops:location 113.264 23.129 "shop:3"   # 广州
GEOADD shops:location 114.057 22.543 "shop:4"   # 深圳

# 搜索指定坐标 5km 范围内的商铺
GEOSEARCH shops:location FROMLONLAT 116.397 39.908 BYRADIUS 5 km WITHDIST

# 按距离排序
GEOSEARCH shops:location FROMLONLAT 116.397 39.908 BYRADIUS 20 km WITHDIST ASC

# 计算两点距离
GEODIST shops:location "shop:1" "shop:2" km

type Shop struct {
    ID       string  `json:"id"`
    Name     string  `json:"name"`
    Distance float64 `json:"distance_km"`
}

// AddShopLocation 添加商铺地理坐标
func AddShopLocation(ctx context.Context, shopID string, lng, lat float64) error {
    return rdb.GeoAdd(ctx, "shops:location",
        &redis.GeoLocation{
            Name:      shopID,
            Longitude: lng,
            Latitude:  lat,
        },
    ).Err()
}

// SearchNearbyShops 搜索附近商铺（带滚动分页）
func SearchNearbyShops(ctx context.Context, lng, lat, radius float64, unit string, count int) ([]Shop, error) {
    locations, err := rdb.GeoSearchLocation(ctx, "shops:location",
        &redis.GeoSearchLocationQuery{
            GeoSearchQuery: redis.GeoSearchQuery{
                Longitude:  lng,
                Latitude:   lat,
                Radius:     radius,
                RadiusUnit: unit,
                Sort:       "ASC",
                Count:      count,
            },
            WithDist: true,
        },
    ).Result()
    if err != nil {
        return nil, err
    }

    shops := make([]Shop, 0, len(locations))
    for _, loc := range locations {
        shops = append(shops, Shop{
            ID:       loc.Name,
            Distance: loc.Dist,
        })
    }
    return shops, nil
}

# user_id=1001 的用户在第 1 天签到
SETBIT sign:2026:1001 0 1

# user_id=1001 的用户在第 7 天签到
SETBIT sign:2026:1001 6 1

# 统计第 1 到第 7 天的签到天数
BITCOUNT sign:2026:1001 0 6

# 获取第 7 天的签到状态
GETBIT sign:2026:1001 6

# BITFIELD：查看最近 7 天的签到情况（无符号，偏移从 0 开始）
BITFIELD sign:2026:1001 GET u7 0

// SignIn 用户签到
func SignIn(ctx context.Context, userID int64, year int, dayOfYear int) error {
    key := fmt.Sprintf("sign:%d:%d", year, userID)
    // dayOfYear 从 1 开始，offset 从 0 开始
    return rdb.SetBit(ctx, key, int64(dayOfYear-1), 1).Err()
}

// GetSignInStatus 获取指定日的签到状态
func GetSignInStatus(ctx context.Context, userID int64, year int, dayOfYear int) (bool, error) {
    key := fmt.Sprintf("sign:%d:%d", year, userID)
    bit, err := rdb.GetBit(ctx, key, int64(dayOfYear-1)).Result()
    return bit == 1, err
}

// GetTotalSignDays 统计用户某年累计签到天数
func GetTotalSignDays(ctx context.Context, userID int64, year int) (int64, error) {
    key := fmt.Sprintf("sign:%d:%d", year, userID)
    return rdb.BitCount(ctx, key, &redis.BitCount{
        Start: 0,
        End:   365, // 覆盖全年
    }).Result()
}

// GetConsecutiveSignDays 统计到今天的连续签到天数
func GetConsecutiveSignDays(ctx context.Context, userID int64, year int, todayDayOfYear int) (int64, error) {
    key := fmt.Sprintf("sign:%d:%d", year, userID)

    // 1. 取从 0 到今天的所有位
    bits, err := rdb.BitField(ctx, key,
        "GET", fmt.Sprintf("u%d", todayDayOfYear), "0",
    ).Result()
    if err != nil || len(bits) == 0 {
        return 0, err
    }

    // 2. 从右向左逐位检查，遇 0 停止
    val := bits[0]
    var consecutive int64
    for i := 0; i < todayDayOfYear; i++ {
        if val&1 == 1 {
            consecutive++
            val >>= 1
        } else {
            break
        }
    }
    return consecutive, nil
}

// GetSignMapOfMonth 获取某月的签到日历（用于前端展示）
func GetSignMapOfMonth(ctx context.Context, userID int64, year int, month int, daysInMonth int) ([]bool, error) {
    key := fmt.Sprintf("sign:%d:%d", year, userID)
    startDay := dayOfYear(year, month, 1)

    pipe := rdb.Pipeline()
    cmds := make([]*redis.IntCmd, daysInMonth)
    for i := 0; i < daysInMonth; i++ {
        cmds[i] = pipe.GetBit(ctx, key, int64(startDay+i-1))
    }
    pipe.Exec(ctx)

    result := make([]bool, daysInMonth)
    for i, cmd := range cmds {
        result[i] = cmd.Val() == 1
    }
    return result, nil
}

# 记录用户访问（UV）
PFADD uv:page:homepage user:1001 user:1002 user:1003

# 统计 UV
PFCOUNT uv:page:homepage       # → 3

# 重复添加不会增加计数
PFADD uv:page:homepage user:1001
PFCOUNT uv:page:homepage       # → 还是 3

# 合并多天数据
PFADD uv:2026-07-09 user:1001 user:1002
PFADD uv:2026-07-10 user:1002 user:1003
PFMERGE uv:2026-07-09:10 uv:2026-07-09 uv:2026-07-10
PFCOUNT uv:2026-07-09:10       # → 3（1001, 1002, 1003 去重后）

// RecordUV 记录页面访问 UV
func RecordUV(ctx context.Context, pageKey string, userID int64) error {
    key := fmt.Sprintf("uv:%s", pageKey)
    return rdb.PFAdd(ctx, key, userID).Err()
}

// GetUV 统计指定页面 UV
func GetUV(ctx context.Context, pageKey string) (int64, error) {
    key := fmt.Sprintf("uv:%s", pageKey)
    return rdb.PFCount(ctx, key).Result()
}

// MergeDailyUV 合并多天 UV（如周报、月报统计）
func MergeDailyUV(ctx context.Context, pageKey string, dates []string) (int64, error) {
    // 构建每天的 key
    keys := make([]string, len(dates))
    for i, date := range dates {
        keys[i] = fmt.Sprintf("uv:%s:%s", pageKey, date)
    }
    mergedKey := fmt.Sprintf("uv:%s:merged:tmp", pageKey)

    // 合并
    if err := rdb.PFMerge(ctx, mergedKey, keys...).Err(); err != nil {
        return 0, err
    }

    count, err := rdb.PFCount(ctx, mergedKey).Result()
    rdb.Del(ctx, mergedKey) // 清理临时 key
    return count, err
}