如何在golang中动态编写http.HandleFunc()?

时间:2018-03-10 01:12:26

标签: api http go

我正在尝试编写简单的http服务器,它将为API提供请求。这是一个代码:

type Config struct {
    ListenPort int `json:"listenPort"`
    Requests   []struct {
        Request      string `json:"request"`
        ResponceFile string `json:"responceFile"`
    } `json:"requests"`
}
...

func main() {
    ...
    startServer(config)
}

func startServer(config Config) {
    http.HandleFunc(apiPrefix+config.Requests[0].Request,
        func(w http.ResponseWriter, r *http.Request) {
            var dataStruct interface{}
            err := loadJSON(config.Requests[0].ResponseFile, &dataStruct)
            if err != nil {
                w.Write([]byte("Oops! Something was wrong"))
            }
            data, _ := json.Marshal(dataStruct)
            w.Header().Set("Content-Type", "application/json")
            w.Write(data)
        })

    http.HandleFunc(apiPrefix+config.Requests[1].Request,
        func(w http.ResponseWriter, r *http.Request) {
            var dataStruct interface{}
            err := loadJSON(config.Requests[1].ResponseFile, &dataStruct)
            if err != nil {
                w.Write([]byte("Oops! Something was wrong"))
            }
            data, _ := json.Marshal(dataStruct)
            w.Header().Set("Content-Type", "application/json")
            w.Write(data)
        })

    http.HandleFunc("/", http.NotFound)

    port := ""
    if config.ListenPort != 0 {
        port = fmt.Sprintf(":%v", config.ListenPort)
    } else {
        port = ":8080"
    }

    fmt.Printf("Started @%v\n", port)
    log.Fatal(http.ListenAndServe(port, nil))
}

func loadJSON(filePath string, retStruct interface{}) error {
    fmt.Println(filePath)
    fileJSON, err := ioutil.ReadFile(filePath)
    json.Unmarshal(fileJSON, retStruct)
    return err
}

这是配置,其中描述了应通过特定请求返回的文件:

{
    "listenPort": 8080,
    "requests": [
        {
            "request": "switches/brocade",
            "responseFile": "switches.json"
        },
        {
            "request": "smth",
            "responseFile": "smth.json"
        }
    ]
}

所以问题是:为什么这段代码与代码顶部不一样?它只返回最后一个响应文件,在config.json中描述来自该文件的所有请求?或者,编写动态定义的处理程序的正确方法是什么?

func startServer(config Config) {
    for _, req := config.Requests {
        http.HandleFunc(apiPrefix+req.Request,
            func(w http.ResponseWriter, r *http.Request) {
                var dataStruct interface{}
                err := loadJSON(req.ResponseFile, &dataStruct)
                if err != nil {
                    w.Write([]byte("Oops! Something was wrong"))
                }
                data, _ := json.Marshal(dataStruct)
                w.Header().Set("Content-Type", "application/json")
                w.Write(data)
            })
    }

    http.HandleFunc("/", http.NotFound)

2 个答案:

答案 0 :(得分:4)

这是因为Go的范围循环重新使用声明的变量req

  

迭代变量可以由"范围"声明。使用a的子句   形式为short variable declaration(:=)。在这种情况下,他们的类型是   设置为相应迭代值的类型,它们的scope是   " for"声明;它们在每次迭代中重复使用

(强调我的)

此行为以及您在闭包中捕获变量的事实是所有处理程序引用最后一个变量的值的原因。

  

函数文字是闭包:它们可以引用中定义的变量   周围的功能。然后在这些变量之间共享这些变量   周围函数和函数文字,它们存活下来   只要他们可以访问。

要解决此问题,您可以从循环内的迭代变量创建一个新变量,并让闭包使用它。

https://play.golang.org/p/GTNbf1eeFKV

答案 1 :(得分:1)

您应该使用http.Handle

type APIHandleFunc struct {
    ResponseFile string
}

func (api *APIHandleFunc) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    http.ServeFile(w, r, api.ResponseFile)
}

// StartServer .
func StartServer(config Config) {
    for _, req := range config.Requests {
        http.Handle(apiPrefix+"/"+req.Request, &APIHandleFunc{req.ResponceFile}/*new handler*/)
    }
    http.HandleFunc("/", http.NotFound)
}

如果您只将json写入响应,请使用http.ServeFile