Go Http.Server{}-多处理器'；s

我有一个结构性的问题：我不知道如何处理我现在构建它的方式（我可以找到解决方案，我可以看到它与其他模型一起工作）

我使用的是标准的Net/Http，我使用以下代码启动服务器：

gv := GlobalVars{
    jobs:             make(chan QueueElement),
    appConfig:        appConfig,
}

go worker(&gv)

server := http.Server{
    Handler: &gv,
    Addr:    ":" + appConfig.Port,
}

log.Fatal(server.ListenAndServe())

然后我有一个处理程序来检查案例中的所有路由：

func (gv *GlobalVars) ServeHTTP(w http.ResponseWriter, r *http.Request) {

}

应用程序正在启动一些将作业传递到队列的api

我的问题是，我需要启动其中的3个（不同的队列，不同的配置），但要使用相同的globalvar结构

但是这一个只有一个我可以设置的处理程序-我如何添加多个处理程序（我不想要多个服务器，必须在同一个端口上运行）来理解它对不同globalvars变量的寻址

server := http.Server{
    Handler: &gv,
    Addr:    ":" + appConfig.Port,
}

请查看类型：

ServeMux是一个HTTP请求多路复用器。它将每个传入请求的URL与已注册模式的列表相匹配，并为与URL最匹配的模式调用处理程序

ServeMux本身就是一个

http.Handler

，通过请求路由多路传输到不同的子Handler。 根据我对您问题的理解，您希望在同一台服务器上有不同的处理程序，并且每个处理程序使用不同的配置来处理不同的队列

使用ServeMux可以轻松实现这一点：

gv1 := GlobalVars{
    jobs:             make(chan QueueElement),
    appConfig:        appConfig1,
}
gv2 := GlobalVars{
    jobs:             make(chan QueueElement),
    appConfig:        appConfig2,
}
gv3 := GlobalVars{
    jobs:             make(chan QueueElement),
    appConfig:        appConfig3,
}

sm := http.NewServeMux()
// Let gv{1,2,3} handle routes{1,2,3} respectively
sm.Handle("/route1", &gv1)
sm.Handle("/route2", &gv2)
sm.Handle("/route3", &gv3)

// Register the ServeMux as the sole Handler. It will delegate to the subhandlers.
server := http.Server{
    Handler: sm,
    Addr:    ":" + globalAppConfig.Port,
}

注意，您不必自己构造

http.Server

。如果您只需要一台服务器，那么可以使用http包级别的函数，这些函数负责为您创建一台服务器和默认ServeMax

// same GlobalVars as above
// ...

// Instead of creating a ServeMux we can use the global DefaultServeMux
http.Handle("/route1", &gv1)
http.Handle("/route2", &gv2)
http.Handle("/route3", &gv3)

// Calling the package level ListenAndServe uses the single global server.
// Passing nil as the Handler uses the DefaultServeMux as Handler on which we registered the Handlers above.
log.Fatal(http.ListenAndServe(":" + globalAppConfig.Port, nil)

更新

标准的

ServeMux

的一个小示例，其中有两个

处理程序

s服务于3条路由

// Keeping this type simple for the example
type GlobalVars struct {
    appConfig string
}

// This method makes every GlobalVars a net.http.Handler
func (gv *GlobalVars) ServeHTTP(w http.ResponseWriter, req *http.Request) {
    fmt.Fprintf(w, "%s here. Receiving request for %s\n", gv.appConfig, req.URL.Path)
}

func main() {
    gv1 := &GlobalVars{
        appConfig: "gv1",
    }
    gv2 := &GlobalVars{
        appConfig: "gv2",
    }

    // Handle requires a route and a Handler, our gvs are Handlers.
    // gv1 handles two routes, while gv2 handles only one.
    http.Handle("/route1", gv1)
    http.Handle("/route2", gv1)
    http.Handle("/route3", gv2)

    log.Fatal(http.ListenAndServe(":8000", nil))
}

如果我依次呼叫所有三条路线，我将收到以下响应：

$ curl localhost:8000/route1
gv1 here. Receiving request for /route1
$ curl localhost:8000/route2
gv1 here. Receiving request for /route2
$ curl localhost:8000/route3
gv2 here. Receiving request for /route3

这说明了如何将有状态变量用作处理程序（例如GlobalVars类型的变量）

---

注意：处理程序方法

ServeHTTP

具有用于

GlobalVars

的指针接收器。这意味着该方法可能会更改

GlobalVars

变量。HTTP处理程序是并发执行的（假设在很短的时间内对同一个处理程序发出多个请求，您会希望尽可能保持响应）。本例只读取appConfig值，因此没有问题。但是，一旦对变量/字段的写入进入混合状态，您就需要进行适当的同步。

这3个队列是否都接收相同的请求，还是希望它们各自处理不同的请求？相同的结构和工作代码，但3个队列中的每一个都有不同的工作程序（每个队列1个）我的问题是关于服务传入的请求。当一个请求被发送到您的服务器时，会发生什么？这三个队列是否都应该处理该请求？或者一个请求应该总是由一个队列来处理吗？啊，对不起，不会有一组api与每个队列关联，与每个队列关联的工作进程将执行不同的外部进程。看起来很酷！我会尝试一下-我可以为每个gv添加更多的路由，对吗？当然，只需在多个不同的路由上注册相同的gv处理程序。在这里尝试一下，但有一件事我不确定，那就是它怎么知道该去哪里？或者requesthandler ex/route2与/route3相比有什么不同？我不确定我是否在关注您，但您的意思是如何ServeMax决定调用哪个处理程序实现？它是基于传入请求URL路径来实现的。我仍然不完全确定您在问什么，但我还是添加了一个小示例；）