定制 Go HTTP 库中的现有处理器-Golang-PHP中文网

定制 Go HTTP 库中的现有处理器

霞舞

发布： 2025-07-17 15:34:16

原创

725人浏览过

定制 go http 库中的现有处理器

本文介绍了如何在 Go 语言的 net/http 库中定制已有的处理器（Handler），通过闭包的方式向处理器函数传递额外的参数。我们将以 websocket.Draft75Handler 为例，展示如何创建一个包含通道的自定义处理器，并提供示例代码和使用说明，帮助开发者更好地理解和应用这一技巧。

在 Go 的 net/http 包中，Handle 函数用于将特定的 URL 路径与一个实现了 Handler 接口的对象关联起来。Handler 接口定义如下：

type Handler interface {
    ServeHTTP(http.ResponseWriter, *http.Request)
}

登录后复制

这意味着任何实现了 ServeHTTP 方法的类型都可以作为一个处理器。

然而，有时我们需要在已有的处理器基础上进行扩展，例如，向处理器传递额外的参数，以便在处理请求时使用。对于像 websocket.Draft75Handler 这样的函数类型处理器，可以使用闭包来实现这一目标。

使用闭包传递参数

如果处理器是一个函数，例如 websocket.Draft75Handler，我们可以通过闭包将其包装起来，从而向其传递额外的参数。以下是一个示例：

package main

import (
    "fmt"
    "net/http"
    "github.com/gorilla/websocket" // 确保安装 gorilla/websocket 包
)

// 自定义处理器，接受一个参数
func MyHandler(arg interface{}) http.HandlerFunc {
    upgrader := websocket.Upgrader{
        CheckOrigin: func(r *http.Request) bool {
            return true // 允许所有来源，生产环境请修改
        },
    }
    return func(w http.ResponseWriter, r *http.Request) {
        // 在这里处理请求，可以使用 arg 参数
        conn, err := upgrader.Upgrade(w, r, nil)
        if err != nil {
            fmt.Println("upgrade:", err)
            return
        }
        defer conn.Close()

        fmt.Printf("Received argument: %v\n", arg) // 输出传递的参数

        for {
            messageType, p, err := conn.ReadMessage()
            if err != nil {
                fmt.Println("read:", err)
                return
            }
            fmt.Printf("recv: %s\n", p)
            err = conn.WriteMessage(messageType, p)
            if err != nil {
                fmt.Println("write:", err)
                return
            }
        }
    }
}

func main() {
    http.HandleFunc("/echo", MyHandler("argument"))
    fmt.Println("Server starting on :12345")
    err := http.ListenAndServe(":12345", nil)
    if err != nil {
        panic("ListenAndServe: " + err.Error())
    }
}

登录后复制

在这个例子中，MyHandler 函数接受一个 interface{} 类型的参数 arg，并返回一个 http.HandlerFunc 类型的闭包。这个闭包捕获了 arg 参数，并在处理请求时可以使用它。

怪兽AI知识库

企业知识库大模型 + 智能的AI问答机器人

查看详情

在 main 函数中，我们使用 http.HandleFunc 将 /echo 路径与 MyHandler("argument") 返回的处理器函数关联起来。当收到对 /echo 的请求时，MyHandler 返回的闭包会被调用，并且可以访问传递给 MyHandler 的 "argument" 参数。

使用通道进行通信

如果你想在处理器中使用一个通道与其他部分程序通信，可以将通道作为参数传递给处理器：

package main

import (
    "fmt"
    "net/http"
    "github.com/gorilla/websocket"
)

// 自定义处理器，接受一个通道作为参数
func ChannelHandler(ch chan string) http.HandlerFunc {
    upgrader := websocket.Upgrader{
        CheckOrigin: func(r *http.Request) bool {
            return true // 允许所有来源，生产环境请修改
        },
    }
    return func(w http.ResponseWriter, r *http.Request) {
        conn, err := upgrader.Upgrade(w, r, nil)
        if err != nil {
            fmt.Println("upgrade:", err)
            return
        }
        defer conn.Close()

        // 从通道读取数据
        message := <-ch
        fmt.Printf("Received message from channel: %s\n", message)

        for {
            messageType, p, err := conn.ReadMessage()
            if err != nil {
                fmt.Println("read:", err)
                return
            }
            fmt.Printf("recv: %s\n", p)
            err = conn.WriteMessage(messageType, p)
            if err != nil {
                fmt.Println("write:", err)
                return
            }
        }
    }
}

func main() {
    // 创建一个通道
    messageChannel := make(chan string)

    // 将通道传递给处理器
    http.HandleFunc("/channel", ChannelHandler(messageChannel))

    // 启动一个 goroutine 向通道发送数据
    go func() {
        messageChannel <- "Hello from the other side!"
    }()

    fmt.Println("Server starting on :12345")
    err := http.ListenAndServe(":12345", nil)
    if err != nil {
        panic("ListenAndServe: " + err.Error())
    }
}

登录后复制

在这个例子中，ChannelHandler 函数接受一个字符串类型的通道 ch 作为参数，并在处理请求时从该通道读取数据。在 main 函数中，我们创建了一个通道 messageChannel，并将其传递给 ChannelHandler。同时，我们启动了一个 goroutine 向该通道发送消息。当收到对 /channel 的请求时，处理器会从通道读取消息并打印出来。