Error Handling

[!TIP] This document is machine-translated by Google. If you find grammatical and semantic errors, and the document description is not clear, please PR

Error handling is an indispensable part of service. In normal business development, we can think that the http status code is not in the 2xx series, it can be regarded as an http request error. It is accompanied by error messages in response, but these error messages are all returned in plain text. In addition, I will define some business errors in the business, and the common practice is to pass The two fields code and msg are used to describe the business processing results, and it is hoped that the response can be made with the json response body.

Business error response format

  • Business processing is normal

    1.   {
    2.     "code": 0,
    3.     "msg": "successful",
    4.     "data": {
    5.       ....
    6.     }
    7.   }

  • Business processing exception

    1.   {
    2.     "code": 10001,
    3.     "msg": "something wrong"
    4.   }

login of user api

Previously, when we handled the login logic when the username did not exist, an error was directly returned. Let’s log in and pass a username that does not exist to see the effect.

  1. curl -X POST \
  2.   http://127.0.0.1:8888/user/login \
  3.   -H 'content-type: application/json' \
  4.   -d '{
  5.     "username":"1",
  6.     "password":"123456"
  7. }'
  1. HTTP/1.1 400 Bad Request
  2. Content-Type: text/plain; charset=utf-8
  3. X-Content-Type-Options: nosniff
  4. Date: Tue, 09 Feb 2021 06:38:42 GMT
  5. Content-Length: 19
  7. Username does not exist

Next we will return it in json format

Custom error

  • First add a baseerror.go file in common and fill in the code

    1.   $ cd common
    2.   $ mkdir errorx&&cd errorx
    3.   $ vim baseerror.go
    1.   package errorx
    3.   const defaultCode = 1001
    5.   type CodeError struct {
    6.       Code int    `json:"code"`
    7.       Msg  string `json:"msg"`
    8.   }
    10.   type CodeErrorResponse struct {
    11.       Code int    `json:"code"`
    12.       Msg  string `json:"msg"`
    13.   }
    15.   func NewCodeError(code int, msg string) error {
    16.       return &CodeError{Code: code, Msg: msg}
    17.   }
    19.   func NewDefaultError(msg string) error {
    20.       return NewCodeError(defaultCode, msg)
    21.   }
    23.   func (e *CodeError) Error() string {
    24.       return e.Msg
    25.   }
    27.   func (e *CodeError) Data() *CodeErrorResponse {
    28.       return &CodeErrorResponse{
    29.           Code: e.Code,
    30.           Msg:  e.Msg,
    31.       }
    32.   }

  • Replace errors in login logic with CodeError custom errors

    1.   if len(strings.TrimSpace(req.Username)) == 0 || len(strings.TrimSpace(req.Password)) == 0 {
    2.           return nil, errorx.NewDefaultError("Invalid parameter")
    3.       }
    5.       userInfo, err := l.svcCtx.UserModel.FindOneByNumber(req.Username)
    6.       switch err {
    7.       case nil:
    8.       case model.ErrNotFound:
    9.           return nil, errorx.NewDefaultError("Username does not exist")
    10.       default:
    11.           return nil, err
    12.       }
    14.       if userInfo.Password != req.Password {
    15.           return nil, errorx.NewDefaultError("User password is incorrect")
    16.       }
    18.       now := time.Now().Unix()
    19.       accessExpire := l.svcCtx.Config.Auth.AccessExpire
    20.       jwtToken, err := l.getJwtToken(l.svcCtx.Config.Auth.AccessSecret, now, l.svcCtx.Config.Auth.AccessExpire, userInfo.Id)
    21.       if err != nil {
    22.           return nil, err
    23.       }
    25.       return &types.LoginReply{
    26.           Id:           userInfo.Id,
    27.           Name:         userInfo.Name,
    28.           Gender:       userInfo.Gender,
    29.           AccessToken:  jwtToken,
    30.           AccessExpire: now + accessExpire,
    31.           RefreshAfter: now + accessExpire/2,
    32.       }, nil

  • Use custom errors

    1.   $ vim service/user/cmd/api/user.go
    1.   func main() {
    2.       flag.Parse()
    4.       var c config.Config
    5.       conf.MustLoad(*configFile, &c)
    7.       ctx := svc.NewServiceContext(c)
    8.       server := rest.MustNewServer(c.RestConf)
    9.       defer server.Stop()
    11.       handler.RegisterHandlers(server, ctx)
    13.       // Custom error
    14.       httpx.SetErrorHandler(func(err error) (int, interface{}) {
    15.           switch e := err.(type) {
    16.           case *errorx.CodeError:
    17.               return http.StatusOK, e.Data()
    18.           default:
    19.               return http.StatusInternalServerError, nil
    20.           }
    21.       })
    23.       fmt.Printf("Starting server at %s:%d...\n", c.Host, c.Port)
    24.       server.Start()
    25.   }

  • Restart service verification

    1.   $ curl -i -X POST \
    2.     http://127.0.0.1:8888/user/login \
    3.     -H 'content-type: application/json' \
    4.     -d '{
    5.           "username":"1",
    6.           "password":"123456"
    7.   }'
    1.   HTTP/1.1 200 OK
    2.   Content-Type: application/json
    3.   Date: Tue, 09 Feb 2021 06:47:29 GMT
    4.   Content-Length: 40
    6.   {"code":1001,"msg":"Username does not exist"}