Golang自动生成HTTP输入输出处理样板代码插件库VarHandler的使用

VarHandler是一个用于简化Golang HTTP开发过程的工具，它可以自动生成HTTP输入输出处理的样板代码，同时保持HTTP兼容性。

核心功能

VarHandler能够自动生成以下HTTP处理步骤：

1. 从HTTP请求获取参数并验证
2. 处理验证错误
3. 调用业务函数
4. 处理业务函数返回的错误
5. 生成HTTP响应

响应类型

业务函数可以有以下几种返回形式：

func F(x X, y Y) (err error)                                   // 默认成功状态码200
                                                               // 未知错误返回500

func F(x X, y Y) (status int, err error)                       // 设置返回状态码

func F(x X, y Y) (response interface{}, err error)             // 特定响应

func F(x X, y Y) (response interface{}, status int, err error) // 设置状态码和响应

参数处理

函数可以接受一个或多个参数，这些参数需要定义对应的HTTP实例化器：

HTTPX(r *http.Request) (x X, err error)

错误处理

如果实例化过程中发生错误：

HandleHttpErrorWithDefaultStatus(w, r, http.StatusBadRequest, err) // 会被调用

如果业务函数返回错误：

HandleHttpErrorWithDefaultStatus(w, r, http.StatusInternalServerError, err) // 会被调用

完整示例

传统方式

myHttpHandler(w http.ResponseWriter, r *http.Request) {
    var x X
    err := json.NewDecoder(r.Body).Decode(x)
    if err != nil {
       // 错误处理
       return
    }
    err := validate(x)
    if err != nil {
       // 错误处理
       return
    }
    // 重复处理y和z
    // 从zz包获取zz
    response, status, err := F(x, y, z, zz)
    if err != nil {
        // 返回500错误
    }
    w.WriteHeader(status)
    json.NewEncoder(w).Encode(response)
}

使用VarHandler的方式

//go:generate varhandler -func F
package server

import "github.com/azr/generators/varhandler/examples/z"

func F(x X, y Y, z *Z, zz z.Z) (resp interface{}, status int, err error) {...}

// HTTP实例化器:

func HTTPX(r *http.Request) (x X, err error)   { err = json.NewDecoder(r.Body).Decode(&x) }
func HTTPY(r *http.Request) (Y, error)         {...}
func HTTPZ(r *http.Request) (*Z, error)        {...}
func z.HTTPZ(r *http.Request) (z.Z, error)     {...}

VarHandler会生成以下代码：

1. 调用HTTPX、HTTPY、HTTPX和z.HTTPZ及其错误检查
2. 调用F(x, y, z, zz)
3. 根据F的返回参数生成HTTP响应代码

生成的代码示例

func FHandler(w http.ResponseWriter, r *http.Request) {
    var err error
    x, err := HTTPX(r)
    if err != nil {
       HandleHttpErrorWithDefaultStatus(w, r, http.StatusBadRequest, err)
       return
    }
    y, err := HTTPY(r)
    if err != nil {
       HandleHttpErrorWithDefaultStatus(w, r, http.StatusBadRequest, err)
       return
    }
    z, err := HTTPZ(r)
    if err != nil {
       HandleHttpErrorWithDefaultStatus(w, r, http.StatusBadRequest, err)
       return
    }
    zz, err := z.HTTPZ(r)
    if err != nil {
       HandleHttpErrorWithDefaultStatus(w, r, http.StatusBadRequest, err)
       return
    }
    resp, status, err := F(x, y, z, zz)
    if err != nil {
       HandleHttpErrorWithDefaultStatus(w, r, http.StatusInternalServerError, err)
       return
    }
    if status != 0 { // 如果F返回了状态码
       w.WriteHeader(status)
    }
    if resp != nil { // 如果F返回了响应对象
       HandleHttpResponse(w, r, resp)
    }
}

// 辅助函数

func HandleHttpErrorWithDefaultStatus(w http.ResponseWriter, r *http.Request, status int, err error) {
    type HttpError interface {
       HttpError() (error string, code int)
    }
    type SelfHttpError interface {
       HttpError(w http.ResponseWriter)
    }
    switch t := err.(type) {
    default:
       w.WriteHeader(status)
    case HttpError:
       err, code := t.HttpError()
       http.Error(w, err, code)
    case http.Handler:
       t.ServeHTTP(w, r)
    case SelfHttpError:
       t.HttpError(w)
    }
}

func HandleHttpResponse(w http.ResponseWriter, r *http.Request, resp interface{}) {
    type Byter interface {
       Bytes() []byte
    }
    type Stringer interface {
       String() string
    }
    switch t := resp.(type) {
    default:
       // 未知类型
    case http.Handler:
       t.ServeHTTP(w, r) // 响应对象知道如何处理自己
    case Byter:
       w.Write(t.Bytes())
    case Stringer:
       w.Write([]byte(t.String()))
    case []byte:
       w.Write(t)
    }
}