短链服务性能优化：Redis 限流 + 多级缓存实战

1
local key = KEYS[1]
2
local now = tonumber(ARGV[1])
3
local window = tonumber(ARGV[2])
4
local limit = tonumber(ARGV[3])
5
local member = ARGV[4]
6

7
-- 清理过期数据
8
local windowStart = now - window
9
redis.call("ZREMRANGEBYSCORE", key, 0, windowStart)
10

11
-- 添加当前请求
12
redis.call("ZADD", key, now, member)
13

14
-- 统计窗口内请求数
15
local count = redis.call("ZCARD", key)
16

17
-- 设置过期时间
18
redis.call("PEXPIRE", key, window)
19

20
if count <= limit then
21
  return {1, 0}  -- 放行
22
end
23

24
-- 超限：回滚当前请求，计算重试时间
25
redis.call("ZREM", key, member)
26
local oldest = redis.call("ZRANGE", key, 0, 0, "WITHSCORES")
27
if oldest[2] ~= nil then
28
  local retryAfter = (tonumber(oldest[2]) + window) - now
29
  return {0, retryAfter}
30
end
31
return {0, window}

1
// 创建短链 - 10次/分钟
2
api.POST("/shortlinks",
3
    httpmiddleware.RateLimit(limiter, "create", 10, time.Minute),
4
    shortlinkhttpapi.NewCreateHandler(slRepo))
5

6
// 跳转 - 100次/分钟
7
r.GET("/:code",
8
    httpmiddleware.RateLimit(limiter, "redirect", 100, time.Minute),
9
    shortlinkhttpapi.NewRedirectHandler(slRepo, collector))

1
func (s *ShortlinksRepo) Resolve(ctx context.Context, code string) string {
2
    // 1. 查缓存
3
    if s.cache != nil {
4
        if url, _ := s.cache.Get(ctx, code); url != "" {
5
            if url == "__nil__" {
6
                return ""  // 命中负缓存
7
            }
8
            return url
9
        }
10
    }
11

12
    // 2. 查数据库
13
    var url string
14
    err := s.db.QueryRow(ctx,
15
        "SELECT url FROM shortlinks WHERE code=$1 AND disabled=false",
16
        code).Scan(&url)
17

18
    if err != nil {
19
        if errors.Is(err, pgx.ErrNoRows) && s.cache != nil {
20
            s.cache.SetNotFound(ctx, code)  // 写负缓存
21
        }
22
        return ""
23
    }
24

25
    // 3. 回填缓存
26
    if s.cache != nil {
27
        s.cache.Set(ctx, code, url)
28
    }
29
    return url
30
}

1
-- 每次 GET 都执行这个脚本
2
local v = redis.call("GET", key)        -- 调用 1
3
local pttl = redis.call("PTTL", key)    -- 调用 2
4
if pttl < threshold then
5
  redis.call("PEXPIRE", key, targetTTL) -- 可能调用 3
6
end
7
return v

1
无缓存：App → PostgreSQL（1次网络往返）
2
有缓存：App → Redis → PostgreSQL → Redis（最多3次网络往返）

1
SELECT url FROM shortlinks WHERE code=$1 AND disabled=false

1
func (c *ShortlinkCache) Get(ctx context.Context, code string) (string, error) {
2
    res, err := c.client.Get(ctx, "sl:"+code).Result()
3
    if err == redis.Nil {
4
        return "", nil
5
    }
6
    return res, err
7
}

1
请求
2
  ↓
3
┌─────────────────┐
4
│ L1: 本地缓存     │  ← ~100ns，TTL 5分钟
5
│ (ristretto)     │
6
└────────┬────────┘
7
         ↓ miss
8
┌─────────────────┐
9
│ L2: Redis       │  ← ~0.5ms，TTL 1小时
10
└────────┬────────┘
11
         ↓ miss
12
┌─────────────────┐
13
│ L3: PostgreSQL  │  ← ~2ms
14
└─────────────────┘

1
type ShortlinkCache struct {
2
    client *redis.Client
3
    local  *LocalCache  // L1 本地缓存
4
    ttl    time.Duration
5
    emptyTTL time.Duration
6
}
7

8
func (c *ShortlinkCache) Get(ctx context.Context, code string) (string, error) {
9
    // L1: 本地缓存
10
    if c.local != nil {
11
        if url, ok := c.local.Get(code); ok {
12
            return url, nil
13
        }
14
    }
15

16
    // L2: Redis
17
    res, err := c.client.Get(ctx, "sl:"+code).Result()
18
    if err == redis.Nil {
19
        return "", nil
20
    }
21
    if err != nil {
22
        return "", err
23
    }
24

25
    // 回填本地缓存
26
    if c.local != nil {
27
        c.local.Set(code, res)
28
    }
29
    return res, nil
30
}

1
┌─────────┐     ┌─────────┐
2
│ 实例 A  │     │ 实例 B  │
3
│ 本地缓存 │     │ 本地缓存 │  ← 各自独立
4
└────┬────┘     └────┬────┘
5
     └───────┬───────┘
6
             │
7
      ┌──────┴──────┐
8
      │    Redis    │  ← 共享
9
      └─────────────┘

1
func (c *ShortlinkCache) Delete(ctx context.Context, code string) error {
2
    if c.local != nil {
3
        c.local.Del(code)  // 删除本地缓存
4
    }
5
    return c.client.Del(ctx, "sl:"+code).Err()  // 删除 Redis
6
}