我二次封装了一下字节跳动的 hertz 框架

老麦

发布于 2024-03-22 05:57:11

27100

代码可运行

文章被收录于专栏：Go与云原生Go与云原生

运行总次数：0

代码可运行

大家好，我是老麦，一个运维老兵，现在专注于 Golang，DevOps，云原生基础设施建设。

我二次封装了一下字节跳动的 hertz 框架

a gin webserver which bases on cloudwebgo/hertz
inspired by cobra for the RouterGroup management

项目地址: https://github.com/go-jarvis/hertzer

1. Usage

go to example/demo

go get -u github.com/go-jarvis/hertzer

2. Server

func main() {

// define a server
 s := &hertzer.Server{
  Listen: ":8081",
 }

// set server options, sam eas hertz
 s.WithOptions(
  server.WithBasePath("/api"),
  server.WithIdleTimeout(10),
 )

// add middlewares, same as the hertz
 s.Use(prefunc(), postfunc())

// handle a router handler
 s.Handle(&Ping{})

// Run server
 if err := s.Run(); err != nil {
  panic(err)
 }
}

3. Router Handler

Main Router HandlerFunc

type Ping struct {
 httpx.MethodPost `route:"/ping/:name"` // define method and path

// define the body
 Name      string  `path:"name"`
 Age       int     `query:"age"`
 AuthToken string  `header:"AuthToken"`
 Address   Address `json:"address"`
 Score     int     `json:"score" form:"score"`
}


// Handle method must exists.
// reqeust data will be binded into p automaticly.
// it can be used directly.
func (p *Ping) Handle(ctx context.Context, arc *app.RequestContext) (any, error) {

 fmt.Println(p.Address)

 ret := resp.NewStatusResponse(consts.StatusAccepted, *p)
 return ret, nil
}

So that, the default handler will be like:

// r.Handle(httpMethod, relativePath string, handlers ...app.HandlerFunc)
r.Handle("POST","/ping/:name", handler)

3.1. Hanlder's HandlerFuncChain

Add the PreHandlers and PostHandlers to combine the HandlerFunc Chain. NOTE: PreHandlers and PostHandlers as optional.

func (Ping) PreHandlers() []app.HandlerFunc {
 return []app.HandlerFunc{
  prefunc(),
 }
}

func (Ping) PostHandlers() []app.HandlerFunc {
 return []app.HandlerFunc{
  postfunc(),
 }
}

The Registered Router will be like

// r.Handle(httpMethod, relativePath string, handlers ...app.HandlerFunc)
r.Handle("POST","/ping/:name", [pre...,] handler, [post...])

3.2 RouterGroup

As metioned before, the RouterGroups like the carriages of a train. They are not only mounted one by one, and but also can be mounted to any RouterGroup.

NOTE: The Mounted Ring is forbidden. And Directed Acyclic Graph(DAG) of RouterGroups are required.

Using v1:=hertzer.NewRouterGroup(v1) to create a new RouterGroup
Using v2.AddGroup(v2) to add children RouterGroup(s).

// define a server
 s := &hertzer.Server{
  Listen: ":8081",
 }

// define Router Groups
 v1 := hertzer.NewRouterGroup("/v1")
 v1.Handle(&Ping{})

 v2 := hertzer.NewRouterGroup("/v2")

// mount children RouterGroup(s)
 s.AddGroup(v1)
 v1.AddGroup(v2)
 s.AddGroup(v2)

4. Response and Error

By default,

func (p *Ping) Handle(...) (result any, err error) {}

Typically, the response will be

if the error is nil:
- status code = 200 // http.StatusOK
- the data is "result"
if the error is not nil:
- status code = 500 // http.StatusInternalServerError
- the data is "err.Error()"

the 3rd response is special, Router Binding error. + status code = 400 // StatusBadRequest + the data is actual value of binding error

4.1. Status Reponse

However, you may use resp.NewStatusResponse to set the HTTP Status Code whatever you need.

// define
func NewStatusResponse(code int, meta interface{}) StatusResponse {
 return &statusResponse{
  code: code,
  meta: meta,
 }
}

// usage
ret := resp.NewStatusResponse(consts.StatusBadGateway, *p)
return ret, nil

4.2. Status Error

By the way, you can use errors.New to create a status error.

// define
func New(err error, meta any) *StatusError {
 return &StatusError{
  Err:  err,
  Meta: meta,
  Message: "",
 }
}

// usage
serr := errors.New(err, *p)
serr = serr.SetMessage("Error Message")