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

Question

我正在尝试编写简单的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)

Answer 1

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

迭代变量可以使用短变量声明(:=)的形式由"range"子句声明.在这种情况下,它们的类型被设置为相应迭代值的类型,它们的范围是"for"语句的块; 它们在每次迭代中重复使用.

(强调我的)

这种行为,以及您在闭包内捕获变量的事实是所有处理程序引用最后一个变量的值的原因.

函数文字是闭包:它们可以引用周围函数中定义的变量.然后,这些变量在周围函数和函数文本之间共享,只要它们可访问,它们就会存在.

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

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