如何从零构建 URL 短链接系统：完整技术指南

const base62 = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"

func Encode(id int64) string {
    if id == 0 {
        return string(base62[0])
    }
    var buf [11]byte // 62^11 > 2^63, 足够容纳 int64
    i := len(buf)
    for id > 0 {
        i--
        buf[i] = base62[id%62]
        id /= 62
    }
    return string(buf[i:])
}

// 冲突检测伪代码
func GenerateShortCode(longURL string) (string, error) {
    for retries := 0; retries < 3; retries++ {
        id := snowflake.NextID()
        code := base62.Encode(id)
        err := db.Insert(code, longURL)
        if err == nil {
            return code, nil
        }
        if !isDuplicateKeyError(err) {
            return "", err
        }
        // 冲突则重试
    }
    return "", errors.New("failed to generate unique code after retries")
}

CREATE TABLE `short_urls` (
    `id`           BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
    `short_code`   VARCHAR(10)  NOT NULL COMMENT '短码',
    `long_url`     VARCHAR(2048) NOT NULL COMMENT '原始长 URL',
    `hash`         CHAR(32)     NOT NULL COMMENT '长 URL MD5，用于去重查询',
    `user_id`      BIGINT UNSIGNED DEFAULT 0 COMMENT '创建者',
    `custom`       TINYINT      DEFAULT 0 COMMENT '是否自定义短码',
    `expire_at`    TIMESTAMP    NULL COMMENT '过期时间',
    `click_count`  BIGINT UNSIGNED DEFAULT 0 COMMENT '总点击数',
    `created_at`   TIMESTAMP    DEFAULT CURRENT_TIMESTAMP,
    `updated_at`   TIMESTAMP    DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
    UNIQUE KEY `uk_short_code` (`short_code`),
    KEY `idx_hash` (`hash`),
    KEY `idx_user_created` (`user_id`, `created_at`),
    KEY `idx_expire` (`expire_at`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='短链映射表';

-- 按月自动分表：short_clicks_202608
CREATE TABLE `short_clicks_202608` (
    `id`          BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
    `short_code`  VARCHAR(10)  NOT NULL,
    `ip`          VARCHAR(45)  NOT NULL COMMENT 'IPv4/v6',
    `user_agent`  VARCHAR(512) DEFAULT '',
    `referer`     VARCHAR(2048) DEFAULT '',
    `country`     CHAR(2)      DEFAULT '' COMMENT 'ISO-3166',
    `device`      VARCHAR(20)  DEFAULT '' COMMENT 'mobile/desktop/tablet',
    `browser`     VARCHAR(20)  DEFAULT '',
    `os`          VARCHAR(20)  DEFAULT '',
    `clicked_at`  TIMESTAMP    DEFAULT CURRENT_TIMESTAMP,
    KEY `idx_code_time` (`short_code`, `clicked_at`),
    KEY `idx_country` (`country`),
    KEY `idx_clicked` (`clicked_at`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='点击统计表-2026年8月';

// 缓存重建互斥锁实现（防击穿）
func GetLongURL(code string) (string, error) {
    // 1. 查缓存
    longURL, err := redis.Get(ctx, "short:"+code)
    if err == nil {
        return longURL, nil
    }
    if !errors.Is(err, redis.Nil) {
        return "", err
    }

    // 2. 获取重建锁（SETNX，5s TTL）
    locked, _ := redis.SetNX(ctx, "short:"+code+":lock", "1", 5*time.Second)
    if !locked {
        // 未获得锁，短暂等待后重试
        time.Sleep(50 * time.Millisecond)
        return redis.Get(ctx, "short:"+code)
    }
    defer redis.Del(ctx, "short:"+code+":lock")

    // 3. 查 DB 并回写缓存
    longURL, err = db.FindByCode(code)
    if err != nil {
        if errors.Is(err, sql.ErrNoRows) {
            redis.Set(ctx, "short:"+code, "", 60*time.Second) // 空值缓存
            return "", ErrNotFound
        }
        return "", err
    }
    redis.Set(ctx, "short:"+code, longURL, 24*time.Hour)
    return longURL, nil
}

func WarmupCache(codes []string) {
    for _, code := range codes {
        longURL, err := db.FindByCode(code)
        if err == nil {
            redis.Set(ctx, "short:"+code, longURL, 24*time.Hour)
        }
    }
}

// 基于 Redis 的滑动窗口限流
func AllowRequest(clientID string, limit int, window time.Duration) bool {
    key := fmt.Sprintf("rate:%s", clientID)
    now := time.Now().Unix()
    pipe := redis.Pipeline()
    pipe.ZRemRangeByScore(ctx, key, "0", fmt.Sprintf("%d", now-window.Seconds()))
    pipe.ZCard(ctx, key)
    pipe.ZAdd(ctx, key, &redis.Z{Score: float64(now), Member: now})
    pipe.Expire(ctx, key, window)
    cmds, _ := pipe.Exec(ctx)
    current := cmds[1].(*redis.IntCmd).Val()
    return current < int64(limit)
}

package main

import (
    "context"
    "database/sql"
    "errors"
    "fmt"
    "log"
    "net/http"
    "time"

    _ "github.com/go-sql-driver/mysql"
    "github.com/redis/go-redis/v9"
)

const base62Chars = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"

// --- Base62 编码 ---
func EncodeBase62(id int64) string {
    if id == 0 {
        return string(base62Chars[0])
    }
    var buf [11]byte
    i := len(buf)
    for id > 0 {
        i--
        buf[i] = base62Chars[id%62]
        id /= 62
    }
    return string(buf[i:])
}

// --- 简版雪花发号器 ---
type Snowflake struct {
    epoch     int64
    machineID int64
    sequence  int64
    lastTime  int64
}

func NewSnowflake(machineID int64) *Snowflake {
    return &Snowflake{epoch: 1609459200000, machineID: machineID} // 2021-01-01
}

func (s *Snowflake) NextID() int64 {
    now := time.Now().UnixMilli()
    if now < s.lastTime {
        now = s.lastTime // 简单处理时钟回拨
    }
    if now == s.lastTime {
        s.sequence = (s.sequence + 1) & 4095
        if s.sequence == 0 {
            for now <= s.lastTime {
                now = time.Now().UnixMilli()
            }
        }
    } else {
        s.sequence = 0
    }
    s.lastTime = now
    return ((now - s.epoch) << 22) | (s.machineID << 12) | s.sequence
}

// --- 数据层 ---

type Shortener struct {
    db    *sql.DB
    redis *redis.Client
    sf    *Snowflake
}

func NewShortener() *Shortener {
    dsn := "user:pass@tcp(127.0.0.1:3306)/shortlink?parseTime=true"
    db, _ := sql.Open("mysql", dsn)
    rdb := redis.NewClient(&redis.Options{Addr: "localhost:6379"})
    return &Shortener{db: db, redis: rdb, sf: NewSnowflake(1)}
}

func (s *Shortener) CreateShortURL(longURL string) (string, error) {
    id := s.sf.NextID()
    code := EncodeBase62(id)
    _, err := s.db.Exec(
        "INSERT INTO short_urls (short_code, long_url, hash) VALUES (?, ?, MD5(?))",
        code, longURL, longURL,
    )
    if err != nil {
        return "", err
    }
    s.redis.Set(context.Background(), "short:"+code, longURL, 24*time.Hour)
    return code, nil
}

func (s *Shortener) GetLongURL(code string) (string, error) {
    ctx := context.Background()
    // 1. 查 Redis
    val, err := s.redis.Get(ctx, "short:"+code).Result()
    if err == nil {
        return val, nil
    }
    if !errors.Is(err, redis.Nil) {
        return "", err
    }
    // 2. 查 MySQL
    var longURL string
    err = s.db.QueryRow("SELECT long_url FROM short_urls WHERE short_code = ?", code).Scan(&longURL)
    if err != nil {
        if errors.Is(err, sql.ErrNoRows) {
            s.redis.Set(ctx, "short:"+code, "", 60*time.Second)
            return "", errors.New("not found")
        }
        return "", err
    }
    s.redis.Set(ctx, "short:"+code, longURL, 24*time.Hour)
    return longURL, nil
}

// --- HTTP 服务 ---
func main() {
    svc := NewShortener()

    http.HandleFunc("/api/shorten", func(w http.ResponseWriter, r *http.Request) {
        longURL := r.URL.Query().Get("url")
        if longURL == "" {
            http.Error(w, "url required", http.StatusBadRequest)
            return
        }
        code, err := svc.CreateShortURL(longURL)
        if err != nil {
            http.Error(w, err.Error(), http.StatusInternalServerError)
            return
        }
        fmt.Fprintf(w, `{"short_url":"http://s.io/%s"}`, code)
    })

    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        code := r.URL.Path[1:]
        if code == "" {
            http.Error(w, "not found", http.StatusNotFound)
            return
        }
        longURL, err := svc.GetLongURL(code)
        if err != nil {
            http.Error(w, err.Error(), http.StatusNotFound)
            return
        }
        http.Redirect(w, r, longURL, http.StatusFound)
    })

    log.Println("Server listening on :8080")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

FROM golang:1.24-alpine AS builder
WORKDIR /app
COPY go.mod go.sum ./
RUN go mod download
COPY . .
RUN CGO_ENABLED=0 go build -o shortener ./cmd/main.go

FROM alpine:latest
RUN apk --no-cache add ca-certificates
WORKDIR /root/
COPY --from=builder /app/shortener .
EXPOSE 8080
CMD ["./shortener"]

# docker-compose.yml
version: "3.8"
services:
  api:
    build: .
    ports:
      - "8080:8080"
    environment:
      - DB_DSN=user:pass@tcp(mysql:3306)/shortlink
      - REDIS_ADDR=redis:6379
    depends_on:
      - mysql
      - redis
    deploy:
      replicas: 3

  mysql:
    image: mysql:8.0
    environment:
      MYSQL_ROOT_PASSWORD: root
      MYSQL_DATABASE: shortlink
    volumes:
      - mysql_data:/var/lib/mysql

  redis:
    image: redis:7-alpine
    volumes:
      - redis_data:/data

volumes:
  mysql_data:
  redis_data: