Golang实现简单URL短链服务实例

map

package main

import (
    "crypto/rand"
    "encoding/base64"
    "encoding/json"
    "fmt"
    "io"
    "log"
    "net/http"
    "sync"
    "time"

    "github.com/gorilla/mux" // 使用gorilla/mux来简化路由
)

// ShortenerService 包含短链服务的核心数据和方法
type ShortenerService struct {
    mu        sync.RWMutex // 读写锁，保护urls map的并发访问
    urls      map[string]string // 短码 -> 长URL的映射
    longToShort map[string]string // 长URL -> 短码的映射，用于避免重复生成短码
}

// NewShortenerService 创建并返回一个新的ShortenerService实例
func NewShortenerService() *ShortenerService {
    return &ShortenerService{
        urls:      make(map[string]string),
        longToShort: make(map[string]string),
    }
}

// generateShortCode 生成一个指定长度的随机短码
func (s *ShortenerService) generateShortCode(length int) (string, error) {
    // 尝试生成短码，直到找到一个唯一的
    for {
        b := make([]byte, length)
        if _, err := io.ReadFull(rand.Reader, b); err != nil {
            return "", fmt.Errorf("failed to generate random bytes: %w", err)
        }
        // 使用Base64 URL编码，避免特殊字符
        shortCode := base64.URLEncoding.EncodeToString(b)[:length]

        s.mu.RLock()
        _, exists := s.urls[shortCode]
        s.mu.RUnlock()

        if !exists {
            return shortCode, nil
        }
        // 如果短码已存在，继续尝试生成新的
        log.Printf("Collision detected for short code %s, retrying...", shortCode)
        // 稍微等待一下，避免在极端情况下CPU空转
        time.Sleep(1 * time.Millisecond) 
    }
}

// RequestBody 定义了接收的请求体结构
type RequestBody struct {
    URL string `json:"url"`
}

// ResponseBody 定义了返回的响应体结构
type ResponseBody struct {
    ShortURL string `json:"short_url"`
    OriginalURL string `json:"original_url"`
}

// shortenHandler 处理短链创建请求
func (s *ShortenerService) shortenHandler(w http.ResponseWriter, r *http.Request) {
    var req RequestBody
    if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
        http.Error(w, "Invalid request body", http.StatusBadRequest)
        return
    }

    if req.URL == "" {
        http.Error(w, "URL cannot be empty", http.StatusBadRequest)
        return
    }

    // 检查是否已经存在该长链接的短码
    s.mu.RLock()
    existingShortCode, exists := s.longToShort[req.URL]
    s.mu.RUnlock()

    if exists {
        resp := ResponseBody{
            ShortURL:    fmt.Sprintf("http://localhost:8080/%s", existingShortCode),
            OriginalURL: req.URL,
        }
        w.Header().Set("Content-Type", "application/json")
        json.NewEncoder(w).Encode(resp)
        return
    }

    // 生成新的短码
    shortCode, err := s.generateShortCode(6) // 尝试生成6位短码
    if err != nil {
        http.Error(w, "Failed to generate short code", http.StatusInternalServerError)
        return
    }

    // 存储映射关系
    s.mu.Lock()
    s.urls[shortCode] = req.URL
    s.longToShort[req.URL] = shortCode
    s.mu.Unlock()

    resp := ResponseBody{
        ShortURL:    fmt.Sprintf("http://localhost:8080/%s", shortCode),
        OriginalURL: req.URL,
    }
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(resp)
}

// redirectHandler 处理短链重定向请求
func (s *ShortenerService) redirectHandler(w http.ResponseWriter, r *http.Request) {
    vars := mux.Vars(r)
    shortCode := vars["shortCode"]

    s.mu.RLock()
    longURL, ok := s.urls[shortCode]
    s.mu.RUnlock()

    if !ok {
        http.Error(w, "Short URL not found", http.StatusNotFound)
        return
    }

    http.Redirect(w, r, longURL, http.StatusMovedPermanently) // 301永久重定向
}

func main() {
    service := NewShortenerService()
    r := mux.NewRouter()

    r.HandleFunc("/shorten", service.shortenHandler).Methods("POST")
    r.HandleFunc("/{shortCode}", service.redirectHandler).Methods("GET")

    fmt.Println("URL Shortener Service started on :8080")
    log.Fatal(http.ListenAndServe(":8080", r))
}

shortenHandler

redirectHandler

map

sync.RWMutex

generateShortCode

crypto/rand

gofmt

+

/

=

crypto/rand

math/rand

shortenHandler

longToShort