简化 Go 中的 REST 处理程序创建（避免冗长代码）？

Go 中冗长的 REST 处理程序代码可以简化为可重用的函数。通过提取通用逻辑并将其传递给每个处理程序，可以消除重复代码。利用泛型，所有处理程序实现只需一行，甚至可以通过从逻辑函数创建处理程序来摆脱处理程序函数。对于不支持泛型的 Go 版本，可以使用类似的解决方案，使用接口和反射来处理不同的请求和响应类型。

目前我的处理程序有太多重复代码：

type GuestMux struct {
  http.ServeMux
}

func main() {
    guestMux := NewGuestMux()
    http.ListenAndServe(":3001", guestMux)
}

func NewGuestMux() *GuestMux {
    var guestMux = &GuestMux{}
    guestMux.HandleFunc("/guest/createguest", createGuestHandler)
    guestMux.HandleFunc("/guest/updateguest", updateGuestHandler)
    guestMux.HandleFunc("/guest/getguest", getGuestHandler)

    return guestMux
}

func createGuestHandler(w http.ResponseWriter, r *http.Request) {
  var createGuestReq CreateGuestRequest
  reqBody, err := ioutil.ReadAll(r.Body)
  if err != nil {
    log.Println(err)
    w.WriteHeader(http.StatusInternalServerError)
    return
  }
  err = json.Unmarshal(reqBody, &createGuestReq)
  if err != nil {
    log.Println(err)
    w.WriteHeader(http.StatusBadRequest)
    return
  }
  resp, err := CreateGuest(&createGuestReq)
  if err != nil {
    log.Println(err)
    w.WriteHeader(http.StatusInternalServerError)
    return
  }
  w.Header().Set("Content-Type", "application/json")
  json.NewEncoder(w).Encode(resp)
}

func updateGuestHandler(w http.ResponseWriter, r *http.Request) {
  var updateGuestReq UpdateGuestRequest
  reqBody, err := ioutil.ReadAll(r.Body)
  if err != nil {
    log.Println(err)
    w.WriteHeader(http.StatusInternalServerError)
    return
  }
  err = json.Unmarshal(reqBody, &updateGuestReq)
  if err != nil {
    log.Println(err)
    w.WriteHeader(http.StatusBadRequest)
    return
  }
  resp, err := UpdateGuest(&updateGuestReq)
  if err != nil {
    log.Println(err)
    w.WriteHeader(http.StatusInternalServerError)
    return
  }
  w.Header().Set("Content-Type", "application/json")
  json.NewEncoder(w).Encode(resp)
}

func getGuestHandler(w http.ResponseWriter, r *http.Request) {
  // almost the same as above two handlers, just different method to call and 
    // its parameter type
    ...
}

有没有更好的方法来编写处理程序 createguesthandler、updateguesthandler 和 getguesthandler 而不是重复类似的代码块 3 次。我想我可以使用 interface 但不知道如何写。我有大约 20 个处理程序，因此重复的代码似乎并不真正可维护。

//stackoverflow 不允许使用太多代码而不是细节来提问，所以...这里详细，那里详细，甚至更多详细...//

正确答案

您可以将通用逻辑移至单独的函数，并将每个处理程序中特定的所有内容传递给它。

假设您有以下类型和函数：

type createguestrequest struct{}
type updateguestrequest struct{}
type createguestresponse struct{}
type updateguestresponse struct{}

func createguest(v *createguestrequest) (resp *createguestresponse, err error) {
    return nil, nil
}

func updateguest(v *updateguestrequest) (resp *updateguestresponse, err error) {
    return nil, nil
}

允许泛型

如果允许泛型，您可以将所有代码从处理程序中提取出来：

func handle[req any, resp any](w http.responsewriter, r *http.request, logicfunc func(dst req) (resp, error)) {
    var dst req
    if err := json.newdecoder(r.body).decode(&dst); err != nil {
        log.printf("decoding body failed: %v", err)
        w.writeheader(http.statusinternalservererror)
        return
    }
    resp, err := logicfunc(dst)
    if err != nil {
        log.println(err)
        w.writeheader(http.statusinternalservererror)
        return
    }
    w.header().set("content-type", "application/json")
    if err := json.newencoder(w).encode(resp); err != nil {
        log.printf("encoding response failed: %v", err)
    }
}

func createguesthandler(w http.responsewriter, r *http.request) {
    handle(w, r, createguest)
}

func updateguesthandler(w http.responsewriter, r *http.request) {
    handle(w, r, updateguest)
}

如您所见，所有处理程序实现都只是一行！我们现在甚至可以摆脱处理程序函数，因为我们可以从逻辑函数创建处理程序（例如 createguest()、updateguest())。

这就是它的样子：

func createhandler[req any, resp any](logicfunc func(dst req) (resp, error)) http.handlerfunc {
    return func(w http.responsewriter, r *http.request) {
        var dst req
        if err := json.newdecoder(r.body).decode(&dst); err != nil {
            log.printf("decoding body failed: %v", err)
            w.writeheader(http.statusinternalservererror)
            return
        }
        resp, err := logicfunc(dst)
        if err != nil {
            log.println(err)
            w.writeheader(http.statusinternalservererror)
            return
        }
        w.header().set("content-type", "application/json")
        if err := json.newencoder(w).encode(resp); err != nil {
            log.printf("encoding response failed: %v", err)
        }
    }
}

并使用它：

func newguestmux() *guestmux {
    var guestmux = &guestmux{}
    guestmux.handlefunc("/guest/createguest", createhandler(createguest))
    guestmux.handlefunc("/guest/updateguest", createhandler(updateguest))

    return guestmux
}

没有泛型

此解决方案不使用泛型（并且也适用于旧的 go 版本）。

func handle(w http.ResponseWriter, r *http.Request, dst interface{}, logicFunc func() (interface{}, error)) {
    if err := json.NewDecoder(r.Body).Decode(dst); err != nil {
        log.Printf("Decoding body failed: %v", err)
        w.WriteHeader(http.StatusInternalServerError)
        return
    }
    resp, err := logicFunc()
    if err != nil {
        log.Println(err)
        w.WriteHeader(http.StatusInternalServerError)
        return
    }
    w.Header().Set("Content-Type", "application/json")
    if err := json.NewEncoder(w).Encode(resp); err != nil {
        log.Printf("Encoding response failed: %v", err)
    }
}

func createGuestHandler(w http.ResponseWriter, r *http.Request) {
    var createGuestReq CreateGuestRequest
    handle(w, r, &createGuestReq, func() (interface{}, error) {
        return CreateGuest(&createGuestReq)
    })
}

func updateGuestHandler(w http.ResponseWriter, r *http.Request) {
    var updateGuestReq UpdateGuestRequest
    handle(w, r, &updateGuestReq, func() (interface{}, error) {
        return UpdateGuest(&updateGuestReq)
    })
}

这里有很多方法可以避免重复，例如，您可以使用装饰器模式，您可以在其中定义如何解码/编码以及其他不包含业务逻辑的步骤。

您可以检查两种有趣的方法： 一张来自mat：https://pace.dev/blog/2018/05/09/how-I-write-http-services-after-eight-years.html

另一个是 go-kit 包（你可以在 github 上查看），但我建议你查看有关如何编写装饰器而不是安装库的想法，这对于你的实现来说可能是一种矫枉过正。

理论要掌握，实操不能落！以上关于《简化 Go 中的 REST 处理程序创建（避免冗长代码）？》的详细介绍，大家都掌握了吧！如果想要继续提升自己的能力，那么就来关注golang学习网公众号吧！