Question

我有一个结构性问题：我不知道现在该如何构建它（我可以找到可以在其他模型上使用的解决方案）。

我正在使用标准的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个（不同的队列，不同的config），但是要使用相同的globalvar结构。

但是这个只有一个我可以设置的处理程序-我将如何添加多个处理程序（我不希望多个服务器，必须在同一端口上运行）可以理解其处理不同globalvars变量的处理程序？

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

Answer 1

看看net.http.ServeMux类型：

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

ServeMux本身就是http.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软件包级别的功能http.ListenAndServe和http.Handle，这些功能将为您创建服务器和默认的ServeMux。

// 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的一个小示例，其中两个Handler服务于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值，因此很好。但是，一旦对变量/字段进行写操作，就需要正确的同步。

Http.Server {}-多个处理程序？

1 个答案: