综合项目实战记录（短链接服务）

shortlink/                  # 项目根
├── go.mod                  # 模块文件（本机执行 go mod init shortlink）
├── cmd/
│   └── server/
│       └── main.go         # 入口：装配 Store、路由、监听
├── internal/               # 不对外导出（别的模块 import 不了，强制封装）
│   ├── handler/
│   │   ├── handler.go      # HTTP 处理器（路由注册、Create、Redirect）
│   │   ├── handler_test.go # 单测
│   │   └── codec.go        # 短码生成
│   └── store/
│       ├── store.go        # URLStore 接口（抽象边界）
│       └── memory.go       # 内存实现
└── Dockerfile              # 多阶段构建

mkdir -p shortlink/cmd/server shortlink/internal/handler shortlink/internal/store
cd shortlink
go mod init shortlink

package store

// URLStore 定义短链接存储的动作集。
// 提供内存实现 MemoryStore；将来可用 database/sql 实现 SQLStore 平替。
type URLStore interface {
	Save(short, long string) error              // 保存一对映射
	Get(short string) (string, bool)            // 取长链接；不存在返回 ok=false
	Exists(short string) bool                   // 短码是否已存在（生成冲突检测用）
	Incr(short string) int                      // 访问计数 +1，返回最新计数
	Count(short string) int                     // 读计数（只读，健康检查/调试用）
}

package store

import "sync"

// MemoryStore 是 URLStore 的内存实现：并发安全、进程内生效。
type MemoryStore struct {
	mu     sync.RWMutex
	urls   map[string]string // short -> long
	counts map[string]int    // short -> 访问次数
}

var _ URLStore = (*MemoryStore)(nil) // 编译期断言：确保 MemoryStore 实现了接口

func NewMemoryStore() *MemoryStore {
	return &MemoryStore{
		urls:   make(map[string]string),
		counts: make(map[string]int),
	}
}

func (s *MemoryStore) Save(short, long string) error {
	s.mu.Lock()
	defer s.mu.Unlock()
	s.urls[short] = long
	if _, ok := s.counts[short]; !ok {
		s.counts[short] = 0
	}
	return nil
}

func (s *MemoryStore) Get(short string) (string, bool) {
	s.mu.RLock()
	defer s.mu.RUnlock()
	long, ok := s.urls[short]
	return long, ok
}

func (s *MemoryStore) Exists(short string) bool {
	s.mu.RLock()
	defer s.mu.RUnlock()
	_, ok := s.urls[short]
	return ok
}

func (s *MemoryStore) Incr(short string) int {
	s.mu.Lock()
	defer s.mu.Unlock()
	s.counts[short]++
	return s.counts[short]
}

func (s *MemoryStore) Count(short string) int {
	s.mu.RLock()
	defer s.mu.RUnlock()
	return s.counts[short]
}

package handler

import "math/rand"

// base62 字符集：数字 + 小写 + 大写。62^6 = 56 亿种组合，冲突概率可接受。
const alphabet = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"

// genCode 生成长度为 6 的随机短码。
// Go 1.20+ 全局 rand 自动播种，无需手动 rand.Seed。
func genCode() string {
	const n = 6
	b := make([]byte, n)
	for i := range b {
		b[i] = alphabet[rand.Intn(len(alphabet))]
	}
	return string(b)
}

package handler

import (
	"encoding/json"
	"net/http"
	"strings"

	"shortlink/internal/store"
)

// Server 持有 store 引用，路由都挂在它上面。
type Server struct {
	store store.URLStore
}

// NewServer 构造函数：依赖注入 store。
func NewServer(s store.URLStore) *Server {
	return &Server{store: s}
}

// Routes 返回 http.Handler，serve 时代替裸 mux，方便测试复用。
func (s *Server) Routes() http.Handler {
	mux := http.NewServeMux()
	mux.HandleFunc("POST /api/shorten", s.Create)   // 方法路由：只认 POST
	mux.HandleFunc("GET /{code}", s.Redirect)       // 通配符：GET /AbC3x9
	// 注意 /api/shorten 被 POST 限定，不会与 GET /{code} 的 GET 语义冲突
	return mux
}

// ----- 请求/响应结构体 -----

type createReq struct {
	URL string `json:"url"` // 必填长链接
}

type createResp struct {
	Short  string `json:"short"`  // 返回短码形式 /AbC3x9
	Long   string `json:"long"`   // 原链接回显
	Visits int    `json:"visits"` // 当前计数（新链接恒为 0）
}

// ----- 处理器 -----

// Create 处理 POST /api/shorten：收 URL，返回短码。
func (s *Server) Create(w http.ResponseWriter, r *http.Request) {
	var req createReq
	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		http.Error(w, `{"error":"bad json"}`, http.StatusBadRequest)
		return
	}
	if !strings.HasPrefix(req.URL, "http://") && !strings.HasPrefix(req.URL, "https://") {
		http.Error(w, `{"error":"url must start with http(s)://"}`, http.StatusBadRequest)
		return
	}

	// 生成短码，冲突则重试（62^6 空间下几乎不重试）
	var code string
	for {
		code = genCode()
		if !s.store.Exists(code) {
			break
		}
	}
	if err := s.store.Save(code, req.URL); err != nil {
		http.Error(w, `{"error":"store save failed"}`, http.StatusInternalServerError)
		return
	}

	w.Header().Set("Content-Type", "application/json; charset=utf-8")
	w.WriteHeader(http.StatusCreated)
	json.NewEncoder(w).Encode(createResp{Short: "/" + code, Long: req.URL})
}

// Redirect 处理 GET /{code}：查 store，302 跳转，并计数。
func (s *Server) Redirect(w http.ResponseWriter, r *http.Request) {
	// r.PathValue 是 Go 1.22 ServeMux 通配符取值方式
	code := strings.TrimPrefix(r.PathValue("code"), "/")
	long, ok := s.store.Get(code)
	if !ok {
		http.NotFound(w, r) // 404
		return
	}

	s.store.Incr(code) // 计数 +1（read path 的一个写操作）

	// 302 Found：浏览器/客户端跟随跳转
	http.Redirect(w, r, long, http.StatusFound)
}

package main

import (
	"log"
	"net/http"
	"time"

	"shortlink/internal/handler"
	"shortlink/internal/store"
)

func main() {
	// 装配：store 目前是内存实现，换成 SQLStore 只改这一行
	s := store.NewMemoryStore()
	h := handler.NewServer(s)

	srv := &http.Server{
		Addr:              ":8080",
		Handler:           h.Routes(),
		ReadHeaderTimeout: 5 * time.Second, // 生产级：显式施加超时
		ReadTimeout:       10 * time.Second,
		WriteTimeout:      10 * time.Second,
		IdleTimeout:       60 * time.Second,
	}

	log.Printf("shortlink server listening on %s", srv.Addr)
	if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
		log.Fatal(err)
	}
}

package handler

import (
	"encoding/json"
	"net/http"
	"net/http/httptest"
	"strings"
	"testing"

	"shortlink/internal/store"
)

// 组装被测对象：真实 handler + 内存 store，全内存跑测试
func newTestServer() *Server {
	return NewServer(store.NewMemoryStore())
}

func TestCreateReturnsShortCode(t *testing.T) {
	h := newTestServer()

	body := strings.NewReader(`{"url":"https://example.com/very/long/path?q=1"}`)
	req := httptest.NewRequest(http.MethodPost, "/api/shorten", body)
	w := httptest.NewRecorder()

	h.Create(w, req)

	if w.Code != http.StatusCreated {
		t.Fatalf("status = %d, want %d", w.Code, http.StatusCreated)
	}
	var resp createResp
	if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
		t.Fatalf("bad json: %v", err)
	}
	if len(resp.Short) != 7 { // "/" + 6 位短码
		t.Fatalf("short = %q, want 7 chars", resp.Short)
	}
}

func TestCreateRejectsBadURL(t *testing.T) {
	h := newTestServer()

	req := httptest.NewRequest(http.MethodPost, "/api/shorten",
		strings.NewReader(`{"url":"javascript:alert(1)"}`))
	w := httptest.NewRecorder()

	h.Create(w, req)

	if w.Code != http.StatusBadRequest {
		t.Fatalf("status = %d, want 400", w.Code)
	}
}

func TestRedirectAndCount(t *testing.T) {
	h := newTestServer()
	const longURL = "https://example.com/page"

	// 先造一个短链
	req := httptest.NewRequest(http.MethodPost, "/api/shorten",
		strings.NewReader(`{"url":"`+longURL+`"}`))
	w := httptest.NewRecorder()
	h.Create(w, req)

	var resp createResp
	json.Unmarshal(w.Body.Bytes(), &resp)
	code := strings.TrimPrefix(resp.Short, "/")

	// 访问短链两次，验证 302 + 计数
	for i := 0; i < 2; i++ {
		r := httptest.NewRequest(http.MethodGet, "/"+code, nil)
		rec := httptest.NewRecorder()
		h.Redirect(rec, r)

		if rec.Code != http.StatusFound { // 302
			t.Fatalf("redirect status = %d, want 302", rec.Code)
		}
		if loc := rec.Header().Get("Location"); loc != longURL {
			t.Fatalf("Location = %q, want %q", loc, longURL)
		}
	}

	if n := h.store.Count(code); n != 2 {
		t.Fatalf("count = %d, want 2", n)
	}
}

func TestUnknownCodeIs404(t *testing.T) {
	h := newTestServer()

	r := httptest.NewRequest(http.MethodGet, "/NoSuchCode", nil)
	w := httptest.NewRecorder()
	h.Redirect(w, r)

	if w.Code != http.StatusNotFound {
		t.Fatalf("status = %d, want 404", w.Code)
	}
}

go test ./...
# ok  shortlink/internal/handler  0.031s

# 初始化（上面已做）
go mod init shortlink

# 拉依赖（本项目全标准库，实际会生成 go.sum 记录 checksum）
go mod tidy

# 构建：输出单一可执行文件
go build -o bin/shortlink ./cmd/server

# 静态检查 + 测试
go vet ./...
go test ./... -race    # -race 开着跑一遍，抓并发数据竞争（强烈推荐）

# 本地跑起来
./bin/shortlink
curl -X POST localhost:8080/api/shorten -d '{"url":"https://go.dev/doc"}' -H 'Content-Type: application/json'
# {"short":"/x3Kq9Z","long":"https://go.dev/doc","visits":0}
curl -L -v localhost:8080/x3Kq9Z   # 跟随 302 跳到 go.dev

# ---- 阶段 1：builder ----
FROM golang:1.23-alpine AS builder
WORKDIR /app

# 先只拷 go.mod/go.sum，利用 Docker 层缓存避免每次重下依赖
COPY go.mod go.sum ./
RUN go mod download

COPY . .
# CGO_ENABLED=0：编译纯静态二进制，可不带 glibc 跑在精简镜像
RUN CGO_ENABLED=0 GOOS=linux go build -o /shortlink ./cmd/server

# ---- 阶段 2：runtime ----
FROM alpine:3.20
WORKDIR /app
COPY --from=builder /shortlink /usr/local/bin/shortlink
EXPOSE 8080
ENTRYPOINT ["shortlink"]

docker build -t shortlink:latest .
docker run --rm -p 8080:8080 shortlink:latest
# 再 curl 同一个接口即可验证容器内服务