如何使用 gorilla/mux 在多个文件中拆分 URL？

Question

我的目录结构如下：

myapp/
|
+-- moduleX
|      |
|      +-- views.go
|
+-- start.go

应用程序从start.go 开始，然后我从那里配置所有路由并从moduleX/views.go 导入处理程序，如下所示：

package main

import (
    "net/http"
    "github.com/gorilla/mux"
    "myapp/moduleX"
)

func main() {
    r := mux.NewRouter()
    http.Handle("/static/", http.StripPrefix("/static/", http.FileServer(http.Dir("./templates/static/"))))
    r.HandleFunc("/", moduleX.SomePostHandler).Methods("POST")
    r.HandleFunc("/", moduleX.SomeHandler)
    http.Handle("/", r)
    http.ListenAndServe(":8080", nil)
}

现在我想添加更多模块并问自己是否（以及如何）可以在urls.go 文件中定义模块中的url，并以某种方式将它们“导入”到start.go。具体来说，我希望start.go 只需一个导入或某种module.GetURLs 函数即可知道所有somemodule/urls.go 文件中的所有URL。

Answer 1

为什么不让处理程序将自己插入到路由表中？

如果您在自己的 go 文件中定义每个处理程序，请为每个文件使用 `init()` 函数将处理程序添加到全局路由表中

比如：

---

main.go:

type route{
    method string
    path string
    handler func(w http.ResponseWriter, r *http.Request)
}
var routes = make([]route,0)

func registerRoute(r route){
    routes = append(routes,r)
}

func server(){
    r := mux.NewRouter()
    http.Handle("/static/", http.StripPrefix("/static/", http.FileServer(http.Dir("./templates/static/"))))
    // set up all the registered routes
    for _, rt = range(routes){
        r.HandleFunc(rt.path,rt.handler).Methods(rt.Method)
    }
    // and there's usually some other stuff that needs to go in here

    //before we finally serve the content here!
    http.ListenAndServe(":8080", nil)
}

---

你的模块.go：

func init(){
    r = route{
        method="GET",
        path="/yourmodule/path/whatever",
        handler=yourHandlerFunc,
    }
    registerRoute(r)
}

func yourHandlerFunc(w http.ResponseWriter, r *http.Request){
    //awesome web stuff goes here
}

---

在执行包 main() 之前，会为包中的每个文件调用 init()，因此您可以确保在启动服务器之前注册所有处理程序。

这种模式可以扩展以允许根据需要发生更棘手的注册gubbins，因为模块本身现在负责自己的注册，而不是试图将所有特殊情况塞进一个注册函数中

Answer 2

编辑：

要一次性创建一组mux.Route，您可以定义一个自定义类型（以下示例中的handler）并执行以下操作：

package main

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

type handler struct {
    path    string
    f       http.HandlerFunc
    methods []string
}

func makeHandlers(hs []handler, r *mux.Router) {
    for _, h := range hs {
        if len(h.methods) == 0 {
            r.HandleFunc(h.path, h.f)
        } else {
            r.HandleFunc(h.path, h.f).Methods(h.methods...)
        }
    }
}

// create some example handler functions

func somePostHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprint(w, "POST Handler")
}

func someHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprint(w, "Normal Handler")
}

func main() {
    //define some handlers
    handlers := []handler{{path: "/", f: somePostHandler, methods: []string{"POST"}}, {path: "/", f: someHandler}}
    r := mux.NewRouter()
    http.Handle("/static/", http.StripPrefix("/static/", http.FileServer(http.Dir("./templates/static/"))))
    // Initialise the handlers
    makeHandlers(handlers, r)
    http.Handle("/", r)
    http.ListenAndServe(":8080", nil)
}

Playground

原始答案：

如果他们在same package 中，则不需要import。

您可以在urls.go 中定义URL 变量，然后在views.go（或package moduleX 中的另一个文件）中定义逻辑，只要它们具有相同的package 声明即可。

例如：

// moduleX/urls.go

package moduleX

var (
    urls = []string{"http://google.com/", "http://stackoverflow.com/"}
)

然后：

// moduleX/views.go (or some other file in package moduleX)

package moduleX

func GetUrls() []string {
    return urls
}

然后：

// start.go

package main

import (
    "fmt"
    "myapp/moduleX"
)

func main() {
    for _, url := range moduleX.GetUrls() {
        fmt.Println(url)
    }
}

或者，更简单的是，通过给它一个大写的名称，从 moduleX 包中导出变量。

例如：

// moduleX/urls.go

package moduleX

var URLs = []string{"http://google.com/", "http://stackoverflow.com/"}

然后：

// start.go

package main    

import (
    "fmt"
    "myapp/moduleX"
)

func main() {
    for _, url := range moduleX.URLs {
        fmt.Println(url)
    }
}

看看any of the Go source to see how they handle the same problem。一个很好的例子是the SHA512 source，其中冗长的变量存储在sha512block.go，逻辑在sha512.go。