go 实现短链

package main
 
import (
    "database/sql"
    "fmt"
    "log"
    "net/http"
    "time"
 
    _ "github.com/go-sql-driver/mysql"
    "github.com/gomodule/redigo/redis"
)
 
// ShortLink 表示短链结构体
type ShortLink struct {
    ID          int
    ShortCode   string
    OriginalURL string
    ExpireTime  time.Time
}
 
// 生成短链
func generateShortCode() string {
    // 这里可以使用更复杂的算法生成唯一短码
    return fmt.Sprintf("%d", time.Now().UnixNano())
}
 
// 保存短链到 MySQL
func saveShortLinkToMySQL(db *sql.DB, shortLink ShortLink) error {
    query := "INSERT INTO short_links (short_code, original_url, expire_time) VALUES (?,?,?)"
    _, err := db.Exec(query, shortLink.ShortCode, shortLink.OriginalURL, shortLink.ExpireTime)
    return err
}
 
// 从 MySQL 中获取短链
func getShortLinkFromMySQL(db *sql.DB, shortCode string) (ShortLink, error) {
    query := "SELECT id, short_code, original_url, expire_time FROM short_links WHERE short_code =?"
    row := db.QueryRow(query, shortCode)
 
    var shortLink ShortLink
    err := row.Scan(&shortLink.ID, &shortLink.ShortCode, &shortLink.OriginalURL, &shortLink.ExpireTime)
    if err == sql.ErrNoRows {
        return shortLink, fmt.Errorf("短链未找到")
    } else if err!= nil {
        return shortLink, err
    }
    return shortLink, nil
}
 
// 保存热点 URL 到 Redis
func saveHotURLToRedis(conn redis.Conn, shortCode string, originalURL string) error {
    _, err := conn.Do("SET", shortCode, originalURL)
    if err!= nil {
        return err
    }
    // 设置过期时间
    _, err = conn.Do("EXPIRE", shortCode, 3600)  // 1 小时过期，可根据需求调整
    return err
}
 
// 从 Redis 中获取热点 URL
func getHotURLFromRedis(conn redis.Conn, shortCode string) (string, error) {
    originalURL, err := redis.String(conn.Do("GET", shortCode))
    if err == redis.ErrNil {
        return "", fmt.Errorf("Redis 中未找到热点短链")
    } else if err!= nil {
        return "", err
    }
    return originalURL, nil
}
 
// 处理短链请求
func handleShortLinkRequest(w http.ResponseWriter, r *http.Request) {
    shortCode := r.URL.Path[1:]
 
    // 尝试从 Redis 中获取
    redisConn, err := redis.Dial("tcp", "localhost:6379")
    if err!= nil {
        log.Println("连接 Redis 失败:", err)
        w.WriteHeader(http.StatusInternalServerError)
        return
    }
    defer redisConn.Close()
 
    originalURL, err := getHotURLFromRedis(redisConn, shortCode)
    if err == nil {
        // 重定向到原始 URL
        http.Redirect(w, r, originalURL, http.StatusFound)
        return
    }
 
    // 从 MySQL 中获取
    db, err := sql.Open("mysql", "username:password@tcp(localhost:3306)/database_name")
    if err!= nil {
        log.Println("连接 MySQL 失败:", err)
        w.WriteHeader(http.StatusInternalServerError)
        return
    }
    defer db.Close()
 
    shortLink, err := getShortLinkFromMySQL(db, shortCode)
    if err!= nil {
        w.WriteHeader(http.StatusNotFound)
        fmt.Fprintf(w, "短链未找到")
        return
    }
 
    // 检查是否过期
    if time.Now().After(shortLink.ExpireTime) {
        w.WriteHeader(http.StatusGone)
        fmt.Fprintf(w, "短链已过期")
        return
    }
 
    // 保存到 Redis 作为热点
    err = saveHotURLToRedis(redisConn, shortCode, shortLink.OriginalURL)
    if err!= nil {
        log.Println("保存到 Redis 失败:", err)
    }
 
    // 重定向到原始 URL
    http.Redirect(w, r, shortLink.OriginalURL, http.StatusFound)
}
 
func main() {
    http.HandleFunc("/", handleShortLinkRequest)
 
    log.Fatal(http.ListenAndServe(":8080", nil))
}