HttpRouter实战指南：从入门到精通

HttpRouter实战指南：从入门到精通

【免费下载链接】httprouter A high performance HTTP request router that scales well 项目地址: https://gitcode.com/gh_mirrors/ht/httprouter

本文全面介绍Go语言高性能HTTP路由器HttpRouter的安装、基础用法、参数配置、中间件集成和多域名管理等核心内容。从快速安装到实际应用示例，详细讲解命名参数与通配参数的使用技巧，深入探讨中间件开发和多域名路由架构设计，帮助开发者掌握构建高性能Web应用的完整技能体系。

HttpRouter快速安装与基础用法

HttpRouter是一个轻量级、高性能的HTTP请求路由器，专门为Go语言设计。它采用基数树（Radix Tree）数据结构，在处理大量路由时依然保持出色的性能表现。本节将详细介绍如何快速安装HttpRouter并掌握其基础用法。

安装HttpRouter

HttpRouter的安装非常简单，只需使用Go模块管理工具即可完成：

go get github.com/julienschmidt/httprouter

安装完成后，您可以在Go代码中通过import语句引入HttpRouter包：

import "github.com/julienschmidt/httprouter"

创建第一个HttpRouter应用

让我们从一个简单的示例开始，了解HttpRouter的基本用法：

package main

import (
    "fmt"
    "log"
    "net/http"
    
    "github.com/julienschmidt/httprouter"
)

// 首页处理器
func Index(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
    fmt.Fprint(w, "欢迎使用HttpRouter!\n")
}

// 用户问候处理器
func Hello(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
    fmt.Fprintf(w, "你好, %s!\n", ps.ByName("name"))
}

func main() {
    // 创建路由器实例
    router := httprouter.New()
    
    // 注册路由
    router.GET("/", Index)
    router.GET("/hello/:name", Hello)
    
    // 启动服务器
    log.Println("服务器启动在 :8080 端口")
    log.Fatal(http.ListenAndServe(":8080", router))
}

路由参数详解

HttpRouter支持两种类型的路由参数，让您能够构建灵活的RESTful API：

命名参数（Named Parameters）

命名参数使用冒号前缀（:name），匹配单个路径段：

// 用户资料路由
router.GET("/user/:userID", UserProfileHandler)
router.GET("/blog/:category/:postID", BlogPostHandler)

匹配示例：

/user/123          → userID="123"
/blog/go/router    → category="go", postID="router"

通配参数（Catch-All Parameters）

通配参数使用星号前缀（*filepath），匹配从当前位置到路径末尾的所有内容：

// 静态文件服务路由
router.GET("/static/*filepath", StaticFileHandler)

匹配示例：

/static/css/style.css     → filepath="/css/style.css"
/static/images/logo.png   → filepath="/images/logo.png"

HTTP方法支持

HttpRouter为常用的HTTP方法提供了便捷的注册方法：

// 支持所有标准HTTP方法
router.GET("/users", GetUsersHandler)
router.POST("/users", CreateUserHandler)
router.PUT("/users/:id", UpdateUserHandler)
router.PATCH("/users/:id", PartialUpdateUserHandler)
router.DELETE("/users/:id", DeleteUserHandler)
router.OPTIONS("/users", OptionsHandler)
router.HEAD("/users", HeadHandler)

参数获取方式

在处理器函数中，可以通过Params对象获取路由参数：

func UserHandler(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
    // 通过名称获取参数
    userID := ps.ByName("userID")
    
    // 通过索引获取参数（第一个参数索引为0）
    firstParam := ps[0].Key   // 参数名
    firstValue := ps[0].Value // 参数值
    
    fmt.Fprintf(w, "用户ID: %s, 第一个参数: %s=%s", userID, firstParam, firstValue)
}

路由配置选项

HttpRouter提供了丰富的配置选项来定制路由行为：

func main() {
    router := httprouter.New()
    
    // 配置路由选项
    router.RedirectTrailingSlash = true    // 自动重定向尾部斜杠
    router.RedirectFixedPath = true        // 自动修正路径
    router.HandleMethodNotAllowed = true   // 处理方法不允许
    router.HandleOPTIONS = true            // 自动处理OPTIONS请求
    
    // 自定义404处理器
    router.NotFound = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        http.Error(w, "页面未找到", http.StatusNotFound)
    })
    
    // 自定义405处理器
    router.MethodNotAllowed = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        http.Error(w, "方法不允许", http.StatusMethodNotAllowed)
    })
    
    // 注册路由
    router.GET("/api/users", GetUsersHandler)
    router.POST("/api/users", CreateUserHandler)
    
    log.Fatal(http.ListenAndServe(":8080", router))
}

错误处理与中间件

HttpRouter内置了panic恢复机制，并支持自定义错误处理：

// 自定义panic处理器
router.PanicHandler = func(w http.ResponseWriter, r *http.Request, err interface{}) {
    log.Printf("发生panic: %v", err)
    http.Error(w, "内部服务器错误", http.StatusInternalServerError)
}

// 基本认证中间件示例
func BasicAuth(handler httprouter.Handle, username, password string) httprouter.Handle {
    return func(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
        user, pass, ok := r.BasicAuth()
        if !ok || user != username || pass != password {
            w.Header().Set("WWW-Authenticate", `Basic realm="Restricted"`)
            http.Error(w, "未授权", http.StatusUnauthorized)
            return
        }
        handler(w, r, ps)
    }
}

// 使用中间件保护路由
router.GET("/admin", BasicAuth(AdminHandler, "admin", "secret"))

实际应用示例

下面是一个完整的RESTful API示例，展示HttpRouter在实际项目中的应用：

package main

import (
    "encoding/json"
    "fmt"
    "log"
    "net/http"
    "strconv"
    
    "github.com/julienschmidt/httprouter"
)

type User struct {
    ID    int    `json:"id"`
    Name  string `json:"name"`
    Email string `json:"email"`
}

var users = []User{
    {ID: 1, Name: "张三", Email: "zhangsan@example.com"},
    {ID: 2, Name: "李四", Email: "lisi@example.com"},
}

// 获取所有用户
func GetUsers(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(users)
}

// 获取单个用户
func GetUser(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
    id, _ := strconv.Atoi(ps.ByName("id"))
    for _, user := range users {
        if user.ID == id {
            w.Header().Set("Content-Type", "application/json")
            json.NewEncoder(w).Encode(user)
            return
        }
    }
    http.Error(w, "用户未找到", http.StatusNotFound)
}

// 创建用户
func CreateUser(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
    var user User
    if err := json.NewDecoder(r.Body).Decode(&user); err != nil {
        http.Error(w, "无效的请求体", http.StatusBadRequest)
        return
    }
    
    user.ID = len(users) + 1
    users = append(users, user)
    
    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(http.StatusCreated)
    json.NewEncoder(w).Encode(user)
}

func main() {
    router := httprouter.New()
    
    // 注册API路由
    router.GET("/api/users", GetUsers)
    router.GET("/api/users/:id", GetUser)
    router.POST("/api/users", CreateUser)
    
    // 启动服务器
    log.Println("REST API服务器启动在 :8080")
    log.Fatal(http.ListenAndServe(":8080", router))
}

通过本节的介绍，您已经掌握了HttpRouter的基本安装和使用方法。HttpRouter以其简洁的API设计和出色的性能表现，成为构建Go Web应用的理想选择。在接下来的章节中，我们将深入探讨HttpRouter的高级特性和最佳实践。

命名参数与通配参数的配置技巧

在现代Web开发中，路由系统是构建RESTful API和Web应用的核心组件。HttpRouter作为Go语言中高性能的HTTP请求路由器，提供了两种强大的参数类型：命名参数（Named Parameters）和通配参数（Catch-All Parameters）。掌握这两种参数的配置技巧对于构建灵活、高效的API至关重要。

命名参数的基本语法与使用

命名参数使用冒号（:）前缀标识，用于捕获单个路径段的值。其语法格式为 :parameterName，其中parameterName是参数的标识符。

// 基本命名参数配置
router.GET("/user/:id", func(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
    userID := ps.ByName("id")
    fmt.Fprintf(w, "用户ID: %s", userID)
})

router.GET("/product/:category/:slug", func(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
    category := ps.ByName("category")
    slug := ps.ByName("slug")
    fmt.Fprintf(w, "分类: %s, 产品: %s", category, slug)
})

命名参数的工作机制遵循以下匹配规则：

命名参数的匹配行为如下表所示：

路由模式	请求路径	匹配结果	参数值
/user/:id	/user/123	✅ 匹配	id="123"
/user/:id	/user/456/profile	❌ 不匹配	-
/user/:id	/user/	❌ 不匹配	-
/product/:cat/:id	/product/electronics/789	✅ 匹配	cat="electronics", id="789"

通配参数的高级应用

通配参数使用星号（*）前缀标识，能够捕获从当前位置到路径末尾的所有内容。其语法格式为 *parameterName，必须放置在路径的末尾。

// 通配参数配置示例
router.GET("/static/*filepath", func(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
    filePath := ps.ByName("filepath")
    // 处理静态文件请求
    fmt.Fprintf(w, "文件路径: %s", filePath)
})

router.GET("/api/*rest", func(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
    restPath := ps.ByName("rest")
    // 处理API通配请求
    fmt.Fprintf(w, "API路径: %s", restPath)
})

通配参数的匹配机制可以通过以下流程图理解：

通配参数的实际匹配示例如下：

路由模式	请求路径	匹配结果	参数值
/files/*filepath	/files/	✅ 匹配	filepath="/"
/files/*filepath	/files/document.pdf	✅ 匹配	filepath="/document.pdf"
/files/*filepath	/files/images/photo.jpg	✅ 匹配	filepath="/images/photo.jpg"
/api/*rest	/api/v1/users	✅ 匹配	rest="/v1/users"
/api/*rest	/api/v2/products/123	✅ 匹配	rest="/v2/products/123"

参数访问与处理技巧

HttpRouter提供了多种方式来访问和处理路由参数：

// 方式1: 使用ByName方法按名称访问
func getUserHandler(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
    userID := ps.ByName("id")
    // 处理用户ID
}

// 方式2: 通过索引直接访问参数切片
func getProductHandler(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
    if len(ps) >= 2 {
        category := ps[0].Value  // 第一个参数的值
        productID := ps[1].Value // 第二个参数的值
        paramName := ps[1].Key   // 第二个参数的名称
    }
}

// 方式3: 在使用标准http.Handler时的上下文访问
func standardHandler(w http.ResponseWriter, r *http.Request) {
    params := httprouter.ParamsFromContext(r.Context())
    if params != nil {
        userID := params.ByName("id")
    }
}

参数验证与错误处理

在实际应用中，对路由参数进行验证是必不可少的：

router.GET("/user/:id", func(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
    userID := ps.ByName("id")
    
    // 参数存在性验证
    if userID == "" {
        http.Error(w, "用户ID不能为空", http.StatusBadRequest)
        return
    }
    
    // 格式验证 - 示例：验证是否为数字ID
    if !isValidUserID(userID) {
        http.Error(w, "无效的用户ID格式", http.StatusBadRequest)
        return
    }
    
    // 业务逻辑处理
    user, err := getUserByID(userID)
    if err != nil {
        http.Error(w, "用户不存在", http.StatusNotFound)
        return
    }
    
    // 返回成功响应
    json.NewEncoder(w).Encode(user)
})

// 辅助函数：验证用户ID格式
func isValidUserID(id string) bool {
    // 简单的数字验证，实际中可能需要更复杂的验证
    _, err := strconv.Atoi(id)
    return err == nil
}

混合使用命名参数和通配参数

在某些复杂场景下，可以混合使用两种参数类型：

// 混合参数配置
router.GET("/api/:version/*path", func(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
    version := ps.ByName("version")
    path := ps.ByName("path")
    
    // 验证版本格式
    if !isValidAPIVersion(version) {
        http.Error(w, "不支持的API版本", http.StatusBadRequest)
        return
    }
    
    // 根据版本和路径处理请求
    handleAPIRequest(version, path, w, r)
})

// 文件服务路由示例
router.GET("/content/:type/*filepath", func(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
    contentType := ps.ByName("type")
    filePath := ps.ByName("filepath")
    
    // 安全检查：防止路径遍历攻击
    if strings.Contains(filePath, "..") {
        http.Error(w, "无效的文件路径", http.StatusBadRequest)
        return
    }
    
    serveContentFile(contentType, filePath, w, r)
})

最佳实践与性能优化

1. 参数命名规范：

   • 使用有意义的参数名称（如:userId而非:id）
   • 保持命名一致性 across the application
   • 避免使用过于通用的名称

2. 路由设计原则：

   • 将静态路径段放在前面，参数放在后面
   • 避免过于复杂的参数组合
   • 使用通配参数谨慎，确保安全性

3. 性能考虑：

   • HttpRouter使用基数树结构，参数数量不影响匹配性能
   • 避免在热路径中进行复杂的参数验证
   • 使用适当的缓存策略处理频繁访问的参数

// 性能优化的参数处理示例
var userIDRegex = regexp.MustCompile(`^[a-zA-Z0-9_-]+$`)

router.GET("/user/:userId", func(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
    userID := ps.ByName("userId")
    
    // 使用预编译的正则表达式进行快速验证
    if !userIDRegex.MatchString(userID) {
        http.Error(w, "无效的用户ID格式", http.StatusBadRequest)
        return
    }
    
    // 快速处理逻辑
    // ...
})

通过掌握命名参数和通配参数的配置技巧，开发者可以构建出既灵活又高性能的Web应用程序。HttpRouter的参数系统设计简洁而强大，正确使用这些特性将显著提升API的质量和开发效率。

中间件集成与自定义处理器开发

HttpRouter作为一个高性能的HTTP请求路由器，不仅提供了基础的URL路由功能，还支持灵活的中间件集成和自定义处理器开发。本章将深入探讨如何在HttpRouter中实现中间件模式、开发自定义处理器，以及利用标准库的http.Handler接口进行集成。

中间件模式与HttpRouter集成

HttpRouter本身是一个http.Handler实现，这意味着它可以无缝集成到任何基于标准库的中间件链中。中间件模式的核心思想是通过包装处理器函数来实现横切关注点（cross-cutting concerns）的处理。

基础中间件实现

让我们从一个简单的日志中间件开始：

package main

import (
    "fmt"
    "log"
    "net/http"
    "time"

    "github.com/julienschmidt/httprouter"
)

// 日志中间件
func LoggingMiddleware(next httprouter.Handle) httprouter.Handle {
    return func(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
        start := time.Now()
        next(w, r, ps)
        duration := time.Since(start)
        log.Printf("%s %s %v", r.Method, r.URL.Path, duration)
    }
}

// 认证中间件
func AuthMiddleware(next httprouter.Handle, token string) httprouter.Handle {
    return func(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
        if r.Header.Get("Authorization") != "Bearer "+token {
            http.Error(w, "Unauthorized", http.StatusUnauthorized)
            return
        }
        next(w, r, ps)
    }
}

func HelloHandler(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
    fmt.Fprintf(w, "Hello, %s!", ps.ByName("name"))
}

func main() {
    router := httprouter.New()
    
    // 应用中间件链
    handler := LoggingMiddleware(
        AuthMiddleware(HelloHandler, "secret-token"),
    )
    
    router.GET("/hello/:name", handler)
    log.Fatal(http.ListenAndServe(":8080", router))
}

中间件执行流程

HttpRouter中间件的执行流程可以通过以下序列图清晰展示：

自定义处理器开发

HttpRouter支持两种类型的处理器：原生的httprouter.Handle和标准的http.Handler接口。

HttpRouter原生处理器

// 原生HttpRouter处理器
func UserProfileHandler(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
    userID := ps.ByName("id")
    // 处理业务逻辑
    fmt.Fprintf(w, "User Profile: %s", userID)
}

// 注册路由
router.GET("/users/:id", UserProfileHandler)

标准http.Handler集成

HttpRouter提供了Handler和HandlerFunc方法来集成标准的HTTP处理器：

// 标准http.Handler实现
type UserService struct {
    db *sql.DB
}

func (us *UserService) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    // 从context中获取路由参数
    params := httprouter.ParamsFromContext(r.Context())
    userID := params.ByName("id")
    
    // 查询数据库
    var username string
    err := us.db.QueryRow("SELECT username FROM users WHERE id = ?", userID).Scan(&username)
    if err != nil {
        http.Error(w, "User not found", http.StatusNotFound)
        return
    }
    
    fmt.Fprintf(w, "Username: %s", username)
}

// 注册标准Handler
userService := &UserService{db: db}
router.Handler(http.MethodGet, "/api/users/:id", userService)

高级中间件模式

中间件工厂模式

对于需要配置参数的中间件，可以使用工厂模式：

// 限流中间件工厂
func RateLimitMiddleware(requestsPerSecond int) func(httprouter.Handle) httprouter.Handle {
    limiter := rate.NewLimiter(rate.Limit(requestsPerSecond), 1)
    
    return func(next httprouter.Handle) httprouter.Handle {
        return func(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
            if !limiter.Allow() {
                http.Error(w, "Rate limit exceeded", http.StatusTooManyRequests)
                return
            }
            next(w, r, ps)
        }
    }
}

// 使用限流中间件
rateLimitedHandler := RateLimitMiddleware(10)(UserProfileHandler)
router.GET("/limited/users/:id", rateLimitedHandler)

错误处理中间件

统一的错误处理中间件可以捕获处理器中的panic和错误：

func RecoveryMiddleware(next httprouter.Handle) httprouter.Handle {
    return func(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
        defer func() {
            if err := recover(); err != nil {
                log.Printf("Panic recovered: %v", err)
                http.Error(w, "Internal Server Error", http.StatusInternalServerError)
            }
        }()
        next(w, r, ps)
    }
}

内置处理器配置

HttpRouter提供了多个内置的处理器配置选项，用于处理特殊场景：

全局OPTIONS处理器

router.GlobalOPTIONS = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    // 设置CORS头
    if r.Header.Get("Access-Control-Request-Method") != "" {
        w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
        w.Header().Set("Access-Control-Allow-Origin", "*")
        w.Header().Set("Access-Control-Allow-Headers", "Content-Type, Authorization")
    }
    w.WriteHeader(http.StatusNoContent)
})

自定义NotFound处理器

router.NotFound = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(http.StatusNotFound)
    json.NewEncoder(w).Encode(map[string]string{
        "error": "Endpoint not found",
        "path":  r.URL.Path,
    })
})

方法不允许处理器

router.MethodNotAllowed = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(http.StatusMethodNotAllowed)
    json.NewEncoder(w).Encode(map[string]string{
        "error":  "Method not allowed",
        "method": r.Method,
        "path":   r.URL.Path,
    })
})

中间件组合与链式调用

对于复杂的应用，可能需要组合多个中间件。可以使用函数组合模式：

// 中间件组合函数
func Compose(middlewares ...func(httprouter.Handle) httprouter.Handle) func(httprouter.Handle) httprouter.Handle {
    return func(final httprouter.Handle) httprouter.Handle {
        for i := len(middlewares) - 1; i >= 0; i-- {
            final = middlewares[i](final)
        }
        return final
    }
}

// 创建中间件链
middlewareChain := Compose(
    LoggingMiddleware,
    RecoveryMiddleware,
    RateLimitMiddleware(100),
    AuthMiddleware("secret-token"),
)

// 应用中间件链
securedHandler := middlewareChain(UserProfileHandler)
router.GET("/secure/users/:id", securedHandler)

性能考虑与最佳实践

在使用中间件时，需要注意性能影响：

1. 避免不必要的中间件：每个中间件都会增加处理时间
2. 使用sync.Pool：对于频繁创建的对象，使用对象池
3. 尽早返回：在中间件中尽早处理错误和特殊情况
4. 监控性能：使用性能分析工具监控中间件的影响

// 高性能中间件示例
var bufferPool = sync.Pool{
    New: func() interface{} {
        return bytes.NewBuffer(make([]byte, 0, 1024))
    },
}

func CompressionMiddleware(next httprouter.Handle) httprouter.Handle {
    return func(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
        if !strings.Contains(r.Header.Get("Accept-Encoding"), "gzip") {
            next(w, r, ps)
            return
        }
        
        buf := bufferPool.Get().(*bytes.Buffer)
        buf.Reset()
        defer bufferPool.Put(buf)
        
        gz := gzip.NewWriter(buf)
        defer gz.Close()
        
        // 创建包装的ResponseWriter
        grw := &gzipResponseWriter{
            ResponseWriter: w,
            Writer:         gz,
            Buffer:         buf,
        }
        
        next(grw, r, ps)
    }
}

通过合理的中间件设计和自定义处理器开发，可以构建出既高性能又易于维护的HTTP服务。HttpRouter的灵活性使得它能够适应各种复杂的业务场景，从简单的API服务到复杂的企业级应用。

多域名与子域名的路由管理

在现代Web应用开发中，一个服务器通常需要处理来自多个域名或子域名的请求。HttpRouter虽然本身不直接提供多域名路由的内置支持，但通过巧妙的架构设计和Go语言的灵活性，我们可以轻松实现强大的多域名路由管理方案。

多域名路由的核心原理

HttpRouter的多域名路由管理基于一个简单而强大的概念：每个域名或子域名使用独立的路由器实例。这种设计模式的优势在于：

1. 隔离性：不同域名的路由规则完全隔离，避免冲突
2. 灵活性：每个域名可以有自己的中间件链和配置
3. 可维护性：代码结构清晰，易于扩展和维护

实现多域名路由的架构设计

让我们通过一个完整的示例来展示如何构建多域名路由系统：

package main

import (
    "fmt"
    "net/http"
    "log"
    "strings"

    "github.com/julienschmidt/httprouter"
)

// HostSwitch 实现多域名路由的核心结构
type HostSwitch map[string]http.Handler

// ServeHTTP 方法实现 http.Handler 接口
func (hs HostSwitch) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    // 标准化主机名（去除端口号）
    host := strings.Split(r.Host, ":")[0]
    
    // 查找对应的路由器
    if handler := hs[host]; handler != nil {
        handler.ServeHTTP(w, r)
    } else {
        // 默认处理或404
        http.Error(w, "Host not found", http.StatusNotFound)
    }
}

// 业务处理函数
func Index(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
    fmt.Fprintf(w, "Welcome to %s!\n", r.Host)
}

func UserProfile(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
    fmt.Fprintf(w, "User %s on %s\n", ps.ByName("id"), r.Host)
}

func APIVersion(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
    fmt.Fprint(w, `{"version": "1.0", "host": "`+r.Host+`"}`)
}

func main() {
    // 创建主域名路由器
    mainRouter := httprouter.New()
    mainRouter.GET("/", Index)
    mainRouter.GET("/user/:id", UserProfile)
    
    // 创建API子域名路由器
    apiRouter := httprouter.New()
    apiRouter.GET("/", APIVersion)
    apiRouter.GET("/v1/status", func(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
        fmt.Fprint(w, `{"status": "ok"}`)
    })
    
    // 创建管理子域名路由器
    adminRouter := httprouter.New()
    adminRouter.GET("/", func(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
        fmt.Fprint(w, "Admin Dashboard")
    })
    adminRouter.GET("/users", func(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
        fmt.Fprint(w, "User Management")
    })

    // 配置多域名路由映射
    hs := make(HostSwitch)
    hs["example.com"] = mainRouter        // 主域名
    hs["api.example.com"] = apiRouter     // API子域名
    hs["admin.example.com"] = adminRouter // 管理子域名
    hs["localhost"] = mainRouter          // 开发环境

    log.Println("Server starting on :8080")
    log.Fatal(http.ListenAndServe(":8080", hs))
}

多域名路由的工作流程

高级多域名配置模式

对于更复杂的应用场景，我们可以采用以下高级配置模式：

1. 基于模式匹配的路由

// PatternBasedHostSwitch 支持通配符匹配的域名路由
type PatternBasedHostSwitch struct {
    patterns map[string]http.Handler
    exact    map[string]http.Handler
}

func (p *PatternBasedHostSwitch) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    host := strings.Split(r.Host, ":")[0]
    
    // 先尝试精确匹配
    if handler, exists := p.exact[host]; exists {
        handler.ServeHTTP(w, r)
        return
    }
    
    // 再尝试模式匹配
    for pattern, handler := range p.patterns {
        if matched, _ := filepath.Match(pattern, host); matched {
            handler.ServeHTTP(w, r)
            return
        }
    }
    
    http.Error(w, "Host not found", http.StatusNotFound)
}

2. 带中间件的域名路由

// 域名特定的中间件
func APIAuthMiddleware(handler http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        if r.Header.Get("X-API-Key") != "secret-key" {
            http.Error(w, "Unauthorized", http.StatusUnauthorized)
            return
        }
        handler.ServeHTTP(w, r)
    })
}

// 配置带中间件的路由
apiRouter := httprouter.New()
// ... 路由配置
wrappedAPIRouter := APIAuthMiddleware(apiRouter)
hs["api.example.com"] = wrappedAPIRouter

性能优化建议

多域名路由虽然功能强大，但也需要注意性能优化：

1. 使用sync.Map：对于高并发场景，可以使用sync.Map替代普通map
2. 预编译路由：在启动时预编译所有路由规则
3. 连接池管理：为每个域名维护独立的数据库连接池

import "sync"

// ConcurrentHostSwitch 并发安全的域名路由
type ConcurrentHostSwitch struct {
    mu sync.RWMutex
    handlers map[string]http.Handler
}

func (c *ConcurrentHostSwitch) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    host := strings.Split(r.Host, ":")[0]
    
    c.mu.RLock()
    handler, exists := c.handlers[host]
    c.mu.RUnlock()
    
    if exists {
        handler.ServeHTTP(w, r)
    } else {
        http.Error(w, "Host not found", http.StatusNotFound)
    }
}

测试策略

为确保多域名路由的正确性，需要建立完善的测试体系：

func TestMultiDomainRouting(t *testing.T) {
    // 创建测试路由器
    hs := make(HostSwitch)
    // ... 配置路由
    
    testCases := []struct {
        host     string
        path     string
        expected string
    }{
        {"example.com", "/", "Welcome to example.com!"},
        {"api.example.com", "/", `{"version": "1.0"}`},
        {"admin.example.com", "/", "Admin Dashboard"},
    }
    
    for _, tc := range testCases {
        req := httptest.NewRequest("GET", tc.path, nil)
        req.Host = tc.host
        w := httptest.NewRecorder()
        
        hs.ServeHTTP(w, req)
        
        if w.Body.String() != tc.expected {
            t.Errorf("Host %s, path %s: expected %s, got %s", 
                tc.host, tc.path, tc.expected, w.Body.String())
        }
    }
}

实际应用场景

多域名路由管理在以下场景中特别有用：

场景	配置示例	优势
SaaS多租户	{tenant}.app.com	租户隔离，个性化配置
微服务网关	service1.api.com, service2.api.com	服务发现，负载均衡
多语言站点	en.example.com, zh.example.com	内容本地化，SEO优化
环境隔离	dev.example.com, prod.example.com	环境分离，安全隔离

通过HttpRouter和Go的标准库，我们可以构建出既灵活又高性能的多域名路由系统。这种架构不仅满足了现代Web应用的需求，还为未来的扩展留下了充足的空间。

总结

HttpRouter作为Go语言生态中高性能的HTTP路由器，通过基数树数据结构提供了卓越的路由匹配性能。本文系统介绍了从基础安装、参数配置到高级功能的全方位知识，包括命名参数与通配参数的灵活运用、中间件集成模式、自定义处理器开发以及多域名路由管理架构。掌握这些内容后，开发者能够构建出既灵活又高性能的Web应用程序，满足从简单API到复杂企业级应用的各种需求。HttpRouter的简洁API设计和出色性能表现使其成为Go Web开发的理想选择。

【免费下载链接】httprouter A high performance HTTP request router that scales well 项目地址: https://gitcode.com/gh_mirrors/ht/httprouter