Go语言中间件实现IP黑名单与滑动窗口限流的设计

在构建高并发的Web服务时，你迟早会碰到两类讨厌的请求：一类来自恶意扫描的固定IP，另一类则是短时间内的异常高频调用。单独使用IP黑名单，只能挡住已知的坏人，却无法应对突发流量；单独使用限流，又会对所有请求一视同仁，浪费资源。真正落地的方案，往往需要将两者结合，用黑名单进行前置阻断，用滑动窗口限流进行精细化控制。在Go语言里，借助标准的net/http中间件模式，我们可以用很简洁的代码实现这套组合拳。

中间件的执行顺序决定了请求的处理流程。一个合理的顺序是：黑名单检查放在最外层，一旦命中直接返回403，不再消耗后续资源；滑动窗口限流放在黑名单之后，只对未被封禁的IP进行频率统计。这样既能快速剔除恶意IP，又能保护限流器本身不被海量攻击请求打垮。如果反过来，先限流后黑名单，那么黑名单IP依然会消耗限流器的计算和存储资源，这在遭遇大规模攻击时是不明智的。

黑名单的存储方式直接影响查询性能。最简单的做法是使用内存中的map，用sync.RWMutex保护并发读写。这种方式查询极快，但重启后数据丢失，且无法在多个实例间共享。对于生产环境，更推荐使用Redis的Set结构，既能持久化，又支持集群共享。如果黑名单数量在十万级别以内，内存map配合定时从数据库或配置文件加载的方案，性价比最高。关键是要根据实际规模选择，不要过度设计。

先看一个基于内存的轻量实现。核心是一个线程安全的IP集合，提供增删查改操作。中间件在处理请求时，先提取客户端IP，然后判断是否在黑名单中。

package middleware

import (
    "net/http"
    "sync"
)

type IPBlacklist struct {
    mu    sync.RWMutex
    ips   map[string]bool
}

func NewIPBlacklist() *IPBlacklist {
    return &IPBlacklist{
        ips: make(map[string]bool),
    }
}

func (b *IPBlacklist) Add(ip string) {
    b.mu.Lock()
    defer b.mu.Unlock()
    b.ips[ip] = true
}

func (b *IPBlacklist) Remove(ip string) {
    b.mu.Lock()
    defer b.mu.Unlock()
    delete(b.ips, ip)
}

func (b *IPBlacklist) Contains(ip string) bool {
    b.mu.RLock()
    defer b.mu.RUnlock()
    return b.ips[ip]
}

func (b *IPBlacklist) Middleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        ip := r.RemoteAddr
        if b.Contains(ip) {
            http.Error(w, "Forbidden", http.StatusForbidden)
            return
        }
        next.ServeHTTP(w, r)
    })
}

这里需要注意，r.RemoteAddr可能包含端口号，比如"192.168.1.1:54321"，实际使用中应该用net.SplitHostPort分离出纯IP。另外，如果服务前面有反向代理，客户端真实IP通常在X-Forwarded-For或X-Real-IP头中，需要根据部署架构调整提取逻辑。

相比固定窗口限流在窗口边界容易被突发流量击穿的问题，滑动窗口通过维护一个时间序列上的请求记录，实时计算当前时间点往前一个窗口期内的请求数，判断更为平滑和精确。实现方式主要有两种：日志滑动窗口和计数器滑动窗口。日志滑动窗口记录每次请求的时间戳，精确但内存开销大；计数器滑动窗口将窗口划分为多个小格子，每个格子记录该时间段内的请求数，通过加权计算得到近似值，适合高并发场景。

假设窗口大小为1秒，限流阈值为100次。我们把1秒切分成10个格子，每个格子代表100毫秒。每个格子记录这100毫秒内的请求计数。当新请求到来时，计算当前时间点往前1秒这个范围内所有格子的请求总数。具体做法是：用当前时间戳除以格子大小得到当前格子索引，然后累加从当前格子往前数10个格子的计数值。格子用循环数组存储，通过取模运算定位。这个算法的时间复杂度是O(格子数)，空间复杂度也是O(格子数)，在精度和性能之间取得了很好的平衡。

下面给出一个完整的计数器滑动窗口限流器实现，支持按IP维度进行限制。

package middleware

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

type SlidingWindowLimiter struct {
    mu         sync.Mutex
    windowSize time.Duration
    slotNum    int
    threshold  int
    slots      map[string]*SlotRing
}

type SlotRing struct {
    slots    []int
    head     int
    slotSize time.Duration
    lastTime time.Time
}

func NewSlidingWindowLimiter(windowSize time.Duration, slotNum int, threshold int) *SlidingWindowLimiter {
    return &SlidingWindowLimiter{
        windowSize: windowSize,
        slotNum:    slotNum,
        threshold:  threshold,
        slots:      make(map[string]*SlotRing),
    }
}

func (l *SlidingWindowLimiter) Allow(ip string) bool {
    l.mu.Lock()
    defer l.mu.Unlock()

    ring, exists := l.slots[ip]
    now := time.Now()
    if !exists {
        ring = &SlotRing{
            slots:    make([]int, l.slotNum),
            head:     0,
            slotSize: l.windowSize / time.Duration(l.slotNum),
            lastTime: now,
        }
        l.slots[ip] = ring
    }

    // 计算时间流逝，推进head指针并清零过期格子
    elapsed := now.Sub(ring.lastTime)
    steps := int(elapsed / ring.slotSize)
    if steps > l.slotNum {
        steps = l.slotNum
    }
    for i := 0; i < steps; i++ {
        ring.head = (ring.head + 1) % l.slotNum
        ring.slots[ring.head] = 0
    }
    if steps > 0 {
        ring.lastTime = now
    }

    // 统计当前窗口内的请求总数
    total := 0
    for _, count := range ring.slots {
        total += count
    }

    if total >= l.threshold {
        return false
    }

    ring.slots[ring.head]++
    return true
}

func (l *SlidingWindowLimiter) Middleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        ip := r.RemoteAddr
        if !l.Allow(ip) {
            http.Error(w, "Too Many Requests", http.StatusTooManyRequests)
            return
        }
        next.ServeHTTP(w, r)
    })
}

这个实现中，SlotRing为每个IP维护一个独立的环形槽数组。当请求到来时，先根据时间流逝推进head指针，把已经滑出窗口的过期槽位清零，然后统计当前所有槽位的请求总数。如果超过阈值则拒绝，否则在当前槽位计数加一。这里有一个细节：steps的计算用整除来推算经过了多少个完整槽位，如果服务长时间没有请求，steps可能超过槽位总数，此时直接清空所有槽位即可。

上面的限流器会为每个新IP创建一个SlotRing，如果服务长期运行，map中的IP数量会持续增长，造成内存泄漏。必须增加一个后台goroutine定期清理长时间未活动的IP记录。清理策略可以设定为：如果某个IP的最后请求时间距今超过窗口大小的两倍，就将其从map中删除。这个清理间隔可以设置为窗口大小的一倍或两倍，避免过于频繁的扫描。

func (l *SlidingWindowLimiter) StartCleanup(interval time.Duration) {
    go func() {
        ticker := time.NewTicker(interval)
        for range ticker.C {
            l.mu.Lock()
            now := time.Now()
            for ip, ring := range l.slots {
                if now.Sub(ring.lastTime) > l.windowSize*2 {
                    delete(l.slots, ip)
                }
            }
            l.mu.Unlock()
        }
    }()
}

调用StartCleanup后，清理协程会定期扫描并移除僵尸IP，保持内存占用在合理范围内。在生产环境中，还可以考虑结合LRU等淘汰策略，设置一个最大IP数量上限，防止极端情况下内存溢出。

两个中间件各自独立，通过标准的http.Handler链式调用组合在一起。先执行黑名单检查，再执行限流检查。

func main() {
    blacklist := middleware.NewIPBlacklist()
    blacklist.Add("10.0.0.5")
    blacklist.Add("192.168.1.100")

    limiter := middleware.NewSlidingWindowLimiter(1*time.Second, 10, 100)
    limiter.StartCleanup(2 * time.Second)

    mux := http.NewServeMux()
    mux.HandleFunc("/api", func(w http.ResponseWriter, r *http.Request) {
        w.Write([]byte("Hello"))
    })

    // 组合中间件：黑名单 -> 限流 -> 业务处理
    handler := blacklist.Middleware(limiter.Middleware(mux))
    http.ListenAndServe(":8080", handler)
}

这种组合方式清晰且灵活。如果后续需要增加其他中间件，比如JWT鉴权、请求日志等，只需继续嵌套即可。每个中间件职责单一，符合Go语言推崇的简洁组合思想。

真实落地时，有几个细节值得深入打磨。第一，IP提取的准确性。如果服务部署在Kubernetes或使用Nginx反向代理，必须正确配置Trusted Proxies，从X-Forwarded-For的最左侧取真实客户端IP，同时防范IP伪造。第二，黑名单的动态管理。应该提供管理接口或监听配置变更，实现不重启服务就能增删黑名单IP。第三，限流阈值和窗口大小的配置化。不同接口的承载能力不同，应该支持按路由设置不同的限流参数，而不是全局一刀切。第四，监控和告警。将黑名单命中次数、限流拒绝次数通过Prometheus等指标暴露出来，便于观察攻击趋势和调整阈值。

如果服务是多实例部署，内存方案会导致限流失效，因为各实例独立计数。此时需要将计数存储迁移到Redis。滑动窗口在Redis中的实现通常使用有序集合，以时间戳为score，请求ID或随机值为member。每次请求时，先移除窗口外的过期记录，再统计当前窗口内的元素数量，最后插入当前请求记录。这三个操作需要放在一个Lua脚本中原子执行，避免竞态条件。黑名单同样可以用Redis的Set存储，通过SISMEMBER命令判断。虽然Redis方案增加了网络开销，但在分布式环境下是必要的选择。

Go语言中间件模式为IP黑名单和滑动窗口限流提供了优雅的实现范式。内存版方案适合单机或低流量场景，代码简洁，性能极高；Redis版方案适合分布式部署，保证多实例间的一致性。无论哪种方案，核心都在于分层拦截的设计思想：黑名单前置阻断已知威胁，滑动窗口精细控制未知流量。加上定期清理、动态配置和监控告警等工程化实践，这套组合能够有效提升服务的防护能力，为后端业务提供稳定的流量屏障。