Golang如何实现请求限流_Golang HTTP请求限流与防刷实践_技术教程

答案：Golang中通过令牌桶算法实现HTTP限流，可结合IP粒度、中间件封装及Redis分布式方案，平衡系统稳定性与用户体验。

在高并发场景下，Golang 实现 HTTP 请求限流是保障服务稳定性的关键手段。限流能有效防止恶意刷接口、资源耗尽或雪崩效应。通过合理设计限流策略，可以在不影响正常用户体验的前提下，过滤掉异常流量。

基于令牌桶的限流实现

令牌桶算法是 Golang 中最常用的限流方式之一，它允许一定的突发流量，同时控制平均速率。标准库 golang.org/x/time/rate 提供了开箱即用的实现。

使用示例如下：

package main

import (
    "golang.org/x/time/rate"
    "net/http"
    "time"
)

var limiter = rate.NewLimiter(10, 50) // 每秒10个令牌，最多容纳50个

func handler(w http.ResponseWriter, r *http.Request) {
    if !limiter.Allow() {
        http.Error(w, "Too Many Requests", http.StatusTooManyRequests)
        return
    }
    w.Write([]byte("OK"))
}

func main() {
    http.HandleFunc("/", handler)
    http.ListenAndServe(":8080", nil)
}

上面代码限制每秒最多处理10个请求，支持最多50次突发。适用于全局统一限流场景。

基于 IP 的精细化限流

实际业务中通常需要对不同客户端独立限流，比如按 IP 分配配额。可以通过 map + sync.Mutex 或 sync.Map 存储每个 IP 的限流器。

var clients = make(map[string]*rate.Limiter)
var mtx sync.Mutex

func getLimiter(ip string) *rate.Limiter {
    mtx.Lock()
    defer mtx.Unlock()

    limiter, exists := clients[ip]
    if !exists {
        limiter = rate.NewLimiter(2, 5) // 每秒2次，最多5次突发
        clients[ip] = limiter
    }
    return limiter
}

func limitedHandler(w http.ResponseWriter, r *http.Request) {
    ip := r.RemoteAddr
    if !getLimiter(ip).Allow() {
        http.Error(w, "Rate limit exceeded", http.StatusTooManyRequests)
        return
    }
    w.Write([]byte("Hello"))
}

该方法可实现 per-IP 限流，适合防刷场景。注意长期运行可能导致 map 膨胀，建议定期清理过期条目或使用带 TTL 的缓存结构。

中间件方式集成限流

将限流逻辑封装为 HTTP 中间件，可以更灵活地应用于特定路由。

func rateLimit(next http.HandlerFunc) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        ip := r.RemoteAddr
        limiter := getLimiter(ip)

        if !limiter.Allow() {
            http.Error(w, "Too many requests", http.StatusTooManyRequests)
            return
        }
        next(w, r)
    }
}

// 使用
http.HandleFunc("/api/data", rateLimit(dataHandler))

这种方式解耦了业务逻辑与限流控制，便于复用和管理。

结合 Redis 实现分布式限流

单机限流无法应对多实例部署场景。借助 Redis 和 Lua 脚本可实现分布式令牌桶或滑动窗口限流。

常用方案包括：

使用 github.com/go-redis/redis_rate 客户端库
自定义 Lua 脚本判断是否超限
利用 Redis 的 INCR + EXPIRE 原子操作实现计数器限流

例如：

import "github.com/go-redis/redis/v8"

rdb := redis.NewClient(&redis.Options{Addr: "localhost:6379"})
limiter := redis_rate.NewLimiter(rdb)
limiter.Allow(ctx, "ip:"+ip, redis_rate.PerSecond(5))

该方式适合微服务架构下的统一限流控制。

基本上就这些。根据业务规模选择合适的限流粒度和存储方式，能显著提升系统的抗压能力。限流不是一刀切，而是平衡可用性与安全性的过程。