Go语言HTTP请求限流中间件实现指南

package main

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

// rateLimitMiddleware 是一个HTTP中间件，用于实现IP限流
func rateLimitMiddleware(next http.HandlerFunc) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        // 1. 获取请求的远程IP地址
        // 注意：如果服务部署在反向代理（如Nginx）后，应优先使用X-Forwarded-For或X-Real-IP头
        // 此处为简化示例，直接使用REMOTE_ADDR，或r.RemoteAddr作为备用
        remoteIP := r.Header.Get("REMOTE_ADDR")
        if remoteIP == "" {
            remoteIP = r.RemoteAddr // 原始的TCP连接地址，可能包含端口
            // 进一步处理以去除端口，例如：strings.Split(remoteIP, ":")[0]
        }

        // 2. 检查该IP是否允许请求
        if !allowRequest(remoteIP) {
            log.Printf("IP %s 触发限流，返回 429", remoteIP)
            w.WriteHeader(http.StatusTooManyRequests) // HTTP 429
            return // 阻止请求继续向下传递
        }

        // 3. 如果允许，则将请求传递给下一个处理器
        next.ServeHTTP(w, r)
    }
}

// ipLimiter 存储单个IP的限流信息
type ipLimiter struct {
    mu        sync.Mutex    // 保护此IP的计数器
    count     int           // 当前窗口内的请求计数
    lastReset time.Time     // 上次计数器重置的时间
}

// 全局IP限流器配置
var (
    ipLimiters   = make(map[string]*ipLimiter) // 存储所有IP的限流器
    ipLimitersMu sync.Mutex                   // 保护ipLimiters map本身的并发访问
    ratePerSecond = 10                         // 每秒允许的请求数
    windowDuration = time.Second              // 限流窗口时长
)

// getIPLimiter 获取或创建一个IP的限流器
func getIPLimiter(ip string) *ipLimiter {
    ipLimitersMu.Lock()
    defer ipLimitersMu.Unlock()

    limiter, exists := ipLimiters[ip]
    if !exists {
        limiter = &ipLimiter{
            count:     0,
            lastReset: time.Now(),
        }
        ipLimiters[ip] = limiter
    }
    return limiter
}

// allowRequest 检查并更新指定IP的请求状态
func allowRequest(ip string) bool {
    limiter := getIPLimiter(ip)

    limiter.mu.Lock()
    defer limiter.mu.Unlock()

    // 如果当前时间已超过上次重置时间 + 窗口时长，则重置计数器
    if time.Since(limiter.lastReset) >= windowDuration {
        limiter.count = 0
        limiter.lastReset = time.Now()
    }

    // 递增计数并检查是否超出限制
    limiter.count++
    return limiter.count <= ratePerSecond
}

// 假设您已经初始化了Redis客户端，例如使用 go-redis 库
// var redisClient *redis.Client

/*
func allowRequestWithRedis(ip string) bool {
    // 定义限流参数
    rate := 10             // 每秒允许10个请求
    window := time.Second  // 窗口大小1秒

    // 构建Redis键，例如 "ratelimit:ip:192.168.1.1:1678886400"
    // 键名包含IP和当前时间窗口的起始时间戳（秒）
    key := fmt.Sprintf("ratelimit:ip:%s:%d", ip, time.Now().UnixNano()/int64(window))

    // 使用Redis事务或Lua脚本保证原子性
    // INCR 命令会原子性地增加键的值，如果键不存在则先创建并设置为0再增加
    count, err := redisClient.Incr(context.Background(), key).Result()
    if err != nil {
        log.Printf("Redis INCR error: %v", err)
        return false // 出现错误，为安全起见拒绝请求
    }

    // 如果是窗口内的第一个请求，设置键的过期时间
    if count == 1 {
        redisClient.Expire(context.Background(), key, window)
    }

    return count <= int64(rate)
}
*/

// use 是一个通用的中间件包装器 (用于演示，实际项目中可使用更专业的路由库)
func use(handler http.HandlerFunc, middlewares ...func(http.HandlerFunc) http.HandlerFunc) http.HandlerFunc {
    for i := len(middlewares) - 1; i >= 0; i-- {
        handler = middlewares[i](handler)
    }
    return handler
}

// 示例处理器
func loginHandler(w http.ResponseWriter, r *http.Request) {
    w.WriteHeader(http.StatusOK)
    w.Write([]byte("Login successful!"))
}

func main() {
    // 注册带有限流中间件的路由
    // 例如：对 /login 路径应用限流
    http.HandleFunc("/login", use(loginHandler, rateLimitMiddleware))

    log.Println("服务器启动，监听 :8080...")
    log.Fatal(http.ListenAndServe(":8080", nil))
}