Golang中使用gorilla mux实现限流器

你的实现有几个关键问题需要解决。让我分析并提供修正方案：

1. 路由配置问题

你的子路由配置是正确的，但中间件应用方式需要调整：

func route() {
    r := mux.NewRouter()
    
    // /hello 路径 - 无限制
    r.PathPrefix("/hello").HandlerFunc(api.ProcessSupplier).Methods("GET")
    
    // /index.php 路径 - 应用限流中间件
    ws := r.PathPrefix("/index.php").Subrouter()
    ws.Use(limit)  // 只在子路由应用限流
    ws.HandleFunc("", api.ProcessWebService).Methods("GET", "POST")
    
    r.Use(panicRecovery)
    
    http.HandleFunc("/favicon.ico", faviconHandler)
    
    // 注意：不要在全局应用 limit 中间件
    if config.HTTPSEnabled {
        err := http.ListenAndServeTLS(":"+config.Port, 
            config.HTTPSCertificateFilePath, 
            config.HTTPSKeyFilePath, 
            handlers.CompressHandlerLevel(r, gzip.BestSpeed))
        if err != nil {
            log.Println(err)
        }
    } else {
        err := http.ListenAndServe(":"+config.Port, 
            handlers.CompressHandler(r))  // 移除全局的 limit()
        if err != nil {
            log.Println(err)
        }
    }
}

2. 限流器配置问题

你的主要问题是 rate.NewLimiter(5, 3) 配置。这创建了一个令牌桶：

• 速率：每秒5个令牌
• 桶容量：3个令牌

要实现每秒10个请求，应该使用：

func getVisitor(username string) *rate.Limiter {
    mu.Lock()
    defer mu.Unlock()
    
    v, exists := visitors[username]
    if !exists {
        // 创建每秒10个请求的限流器
        limiter := rate.NewLimiter(10, 10)  // 每秒10个，桶容量10
        visitors[username] = &visitor{
            limiter:  limiter,
            lastSeen: time.Now(),
        }
        return limiter
    }
    
    v.lastSeen = time.Now()
    return v.limiter
}

3. 完整修正示例

package main

import (
    "net/http"
    "sync"
    "time"
    
    "golang.org/x/time/rate"
    "github.com/gorilla/mux"
)

var (
    visitors = make(map[string]*visitor)
    mu       sync.Mutex
)

type visitor struct {
    limiter  *rate.Limiter
    lastSeen time.Time
}

func getVisitor(username string) *rate.Limiter {
    mu.Lock()
    defer mu.Unlock()
    
    v, exists := visitors[username]
    if !exists {
        // 每秒10个请求，桶容量10
        limiter := rate.NewLimiter(10, 10)
        visitors[username] = &visitor{
            limiter:  limiter,
            lastSeen: time.Now(),
        }
        return limiter
    }
    
    v.lastSeen = time.Now()
    return v.limiter
}

func cleanupVisitors() {
    for {
        time.Sleep(time.Minute)
        mu.Lock()
        for username, v := range visitors {
            if time.Since(v.lastSeen) > 3*time.Minute {
                delete(visitors, username)
            }
        }
        mu.Unlock()
    }
}

func limit(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // 从请求中获取用户名
        userName := r.FormValue("username")
        if userName == "" {
            // 如果没有用户名，使用IP地址
            userName = r.RemoteAddr
        }
        
        limiter := getVisitor(userName)
        if !limiter.Allow() {
            http.Error(w, http.StatusText(http.StatusTooManyRequests), 
                http.StatusTooManyRequests)
            return
        }
        
        next.ServeHTTP(w, r)
    })
}

func main() {
    go cleanupVisitors()
    
    r := mux.NewRouter()
    
    // 不受限的路由
    r.HandleFunc("/hello", func(w http.ResponseWriter, r *http.Request) {
        w.Write([]byte("Hello, no rate limit here!"))
    })
    
    // 受限的子路由
    ws := r.PathPrefix("/index.php").Subrouter()
    ws.Use(limit)
    ws.HandleFunc("", func(w http.ResponseWriter, r *http.Request) {
        w.Write([]byte("This endpoint is rate limited"))
    }).Methods("GET", "POST")
    
    http.ListenAndServe(":8080", r)
}

关键修正点：

1. 路由配置：使用 Subrouter().Use(limit) 只在特定路径应用限流
2. 限流器参数：rate.NewLimiter(10, 10) 实现每秒10个请求
3. 中间件位置：确保不在全局路由应用限流中间件
4. 清理逻辑：修正了清理函数中的时间判断（3分钟清理）

这样配置后，/index.php 路径会按用户名/IP进行限流（每秒10个请求），而 /hello 路径不受限制。