短链服务进阶：点击统计与 Kafka 异步处理

1
// ID=1 -> "1", ID=2 -> "2", ID=100 -> "1C"
2
code := EncodeBase62(uint64(id))

1
import "github.com/sqids/sqids-go"
2

3
// 初始化（使用自定义字母表增加随机性）
4
s, _ := sqids.New(sqids.Options{
5
    Alphabet:  "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789",
6
    MinLength: 3,
7
})
8

9
// 编码
10
code, _ := s.Encode([]uint64{123})  // -> "Xk9" (每次相同)
11

12
// 解码
13
ids := s.Decode("Xk9")  // -> [123]

1
var (
2
    sq     *sqids.Sqids
3
    sqOnce sync.Once
4
)
5

6
func SqInit() {
7
    sqOnce.Do(func() {
8
        var err error
9
        sq, err = sqids.New(sqids.Options{
10
            Alphabet:  "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789",
11
            MinLength: 3,
12
        })
13
        if err != nil {
14
            panic(err)
15
        }
16
    })
17
}
18

19
func EncodeSqids(id uint64) string {
20
    SqInit()
21
    code, _ := sq.Encode([]uint64{id})
22
    return code
23
}

1
// 不推荐：每次跳转都写数据库
2
func RedirectHandler(c *gee.Context) {
3
    url := repo.Resolve(code)
4
    repo.InsertClickStat(code, ip, ua, referer)  // 阻塞！
5
    repo.IncrementClickCount(code)               // 又一次 DB 操作
6
    c.Redirect(302, url)
7
}

1
-- 点击明细表（不加外键，提高写入性能）
2
CREATE TABLE click_stats (
3
    id         BIGSERIAL PRIMARY KEY,
4
    code       TEXT NOT NULL,
5
    clicked_at TIMESTAMPTZ NOT NULL,
6
    ip         TEXT,
7
    user_agent TEXT,
8
    referer    TEXT
9
);
10

11
CREATE INDEX idx_click_stats_code ON click_stats(code);
12
CREATE INDEX idx_click_stats_clicked_at ON click_stats(clicked_at);
13

14
-- 在 shortlinks 表添加计数字段
15
ALTER TABLE shortlinks ADD COLUMN click_count BIGINT NOT NULL DEFAULT 0;

1
type ChannelCollector struct {
2
    ch     chan ClickEvent
3
    closed bool
4
    mu     sync.Mutex
5
}
6

7
func NewChannelCollector(bufferSize int) *ChannelCollector {
8
    return &ChannelCollector{
9
        ch: make(chan ClickEvent, bufferSize),
10
    }
11
}
12

13
func (c *ChannelCollector) Collect(event ClickEvent) {
14
    c.mu.Lock()
15
    defer c.mu.Unlock()
16
    if c.closed {
17
        return
18
    }
19
    select {
20
    case c.ch <- event:
21
    default:
22
        slog.Warn("click event channel full, dropping event")
23
    }
24
}
25

26
func (c *ChannelCollector) Events() <-chan ClickEvent {
27
    return c.ch
28
}
29

30
func (c *ChannelCollector) Close() {
31
    c.mu.Lock()
32
    defer c.mu.Unlock()
33
    if !c.closed {
34
        c.closed = true
35
        close(c.ch)
36
    }
37
}

1
func (c *Consumer) flush(batch []ClickEvent) {
2
    if len(batch) == 0 {
3
        return
4
    }
5

6
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
7
    defer cancel()
8

9
    tx, err := c.db.Begin(ctx)
10
    if err != nil {
11
        slog.Error("begin tx failed", "err", err)
12
        return
13
    }
14
    defer tx.Rollback(context.Background())
15

16
    for _, e := range batch {
17
        tx.Exec(ctx,
18
            `INSERT INTO click_stats (code,clicked_at,ip,user_agent,referer)
19
             VALUES ($1,$2,$3,$4,$5)`,
20
            e.Code, e.ClickedAt, e.IP, e.UserAgent, e.Referer)
21

22
        tx.Exec(ctx,
23
            `UPDATE shortlinks SET click_count = click_count + 1 WHERE code = $1`,
24
            e.Code)
25
    }
26

27
    if err := tx.Commit(ctx); err != nil {
28
        slog.Error("commit failed", "err", err)
29
    }
30
}

1
func NewRedirectHandler(repo *ShortlinksRepo, collector stats.Collector) gee.HandlerFunc {
2
    return func(c *gee.Context) {
3
        code := c.Param("code")
4
        url := repo.Resolve(c.Request.Context(), code)
5

6
        if url == "" {
7
            c.AbortWithStatus(http.StatusNotFound)
8
            return
9
        }
10

11
        // 异步收集，不阻塞响应
12
        collector.Collect(stats.ClickEvent{
13
            Code:      code,
14
            ClickedAt: time.Now(),
15
            IP:        c.ClientIP(),
16
            UserAgent: c.GetHeader("User-Agent"),
17
            Referer:   c.GetHeader("Referer"),
18
        })
19

20
        c.Redirect(http.StatusFound, url)
21
    }
22
}

1
GET /api/v1/users/mine/:code/stats?limit=20&cursor=0

1
{
2
  "total_clicks": 1234,
3
  "recent_clicks": [
4
    {
5
      "clicked_at": "2026-01-16T10:00:00Z",
6
      "ip": "1.2.3.4",
7
      "user_agent": "Mozilla/5.0...",
8
      "referer": "https://google.com"
9
    }
10
  ],
11
  "next_cursor": 20
12
}

1
func (r *ShortlinksRepo) ListStatsByCode(ctx context.Context, code string, limit int, cursor int64) (*StatsResponse, error) {
2
    // 获取总点击数
3
    var totalClicks int64
4
    r.db.QueryRow(ctx,
5
        `SELECT click_count FROM shortlinks WHERE code = $1`,
6
        code).Scan(&totalClicks)
7

8
    // 获取明细（游标分页）
9
    rows, _ := r.db.Query(ctx,
10
        `SELECT id, clicked_at, ip, user_agent, referer
11
         FROM click_stats
12
         WHERE code = $1 AND id > $2
13
         ORDER BY id
14
         LIMIT $3`,
15
        code, cursor, limit)
16

17
    var clicks []ClickDetail
18
    var lastID int64
19
    for rows.Next() {
20
        var c ClickDetail
21
        rows.Scan(&c.ID, &c.ClickedAt, &c.IP, &c.UserAgent, &c.Referer)
22
        clicks = append(clicks, c)
23
        lastID = c.ID
24
    }
25

26
    return &StatsResponse{
27
        TotalClicks:  totalClicks,
28
        RecentClicks: clicks,
29
        NextCursor:   lastID,
30
    }, nil
31
}

1
func NewGetStatsHandler(r *repo.ShortlinksRepo) gee.HandlerFunc {
2
    return func(ctx *gee.Context) {
3
        userID := ctx.MustGet("identity").(auth.Identity).UserID()
4
        code := ctx.Param("code")
5

6
        // 检查所有权
7
        owns, _ := r.UserOwnsShortlink(ctx.Req.Context(), userID, code)
8
        if !owns {
9
            ctx.AbortWithError(http.StatusForbidden, "no permission")
10
            return
11
        }
12

13
        // 查询统计...
14
    }
15
}

1
r.GET("/:code", redirectHandler)  // 通配符
2
r.GET("/healthz", healthHandler)  // 静态
3

4
// 访问 /healthz 应该匹配静态路由
5
// 实际却匹配了通配符，code="healthz"

1
// 错误写法
2
func (n *node) matchChildren(part string) []*node {
3
    for _, child := range n.children {
4
        if child.part == part || child.isWild {  // 问题在这里
5
            nodes = append(nodes, child)
6
        }
7
    }
8
    return nodes
9
}

1
func (n *node) matchChildren(part string) []*node {
2
    var nodes []*node
3
    for _, child := range n.children {
4
        // 精确匹配优先
5
        if child.part == part && !child.isWild {
6
            nodes = append(nodes, child)
7
        }
8
    }
9
    // 没有精确匹配才考虑通配符
10
    if len(nodes) == 0 {
11
        for _, child := range n.children {
12
            if child.isWild {
13
                nodes = append(nodes, child)
14
            }
15
        }
16
    }
17
    return nodes
18
}

1
// 管理员路由
2
admin := api.Group("/admin")
3
admin.Use(AuthRequired(ts), RequireRole("admin"))
4
admin.POST("/shortlinks/:code/disable", disableHandler)
5

6
// 用户路由
7
users := api.Group("/users")
8
users.Use(AuthRequired(ts))
9
users.DELETE("/mine/:code", removeFromListHandler)  // 只删除关联关系