结合gin配置统一结果响应,统一异常处理

package config

import (
	"encoding/json"
	"net/http"
)

var (
	// OK
	OK = response(http.StatusOK, "ok")
)

type Response struct {
	Code int         `json:"code"` // 错误码
	Msg  string      `json:"msg"`  // 错误描述
	Data interface{} `json:"data"` // 返回数据
}

// 自定义响应信息
func (res *Response) WithMsg(message string) Response {
	return Response{
		Code: res.Code,
		Msg:  message,
		Data: res.Data,
	}
}

// 追加响应数据
func (res *Response) WithData(data interface{}) Response {
	return Response{
		Code: res.Code,
		Msg:  res.Msg,
		Data: data,
	}
}

// ToString 返回 JSON 格式的错误详情
func (res *Response) ToString() string {
	err := &struct {
		Code int         `json:"code"`
		Msg  string      `json:"msg"`
		Data interface{} `json:"data"`
	}{
		Code: res.Code,
		Msg:  res.Msg,
		Data: res.Data,
	}
	raw, _ := json.Marshal(err)
	return string(raw)
}

// 构造函数
func response(code int, msg string) *Response {
	return &Response{
		Code: code,
		Msg:  msg,
		Data: nil,
	}
}

func load(c *gin.Context) error {
	c.JSON(http.StatusOK, config.OK.WithData(...))
	return nil
}

package config

import (
	"github.com/gin-gonic/gin"
)

// APIException 错误的结构体,继承Response
type APIException struct {
	*Response
}

// 实现error接口
func (e *APIException) Error() string {
	return e.Msg
}

func newAPIException(code int, msg string) *APIException {
	return &APIException{
		&Response{
			Code: code,
			Msg:  msg,
		},
	}
}
// 这里单独定义一个和gin HandlerFunc相同的type,供后续使用
type HandlerFunc func(c *gin.Context) error

package config

import (
	"github.com/gin-gonic/gin"
	"net/http"
)

// Wrapper 统一异常处理
func Wrapper(handler HandlerFunc) func(c *gin.Context) {
	return func(c *gin.Context) {
		var (
			err error
		)
		err = handler(c)
		if err != nil {
			var apiException *APIException
			// APIException异常
			if h, ok := err.(*APIException); ok {
				apiException = h
			} else if e, ok := err.(error); ok {
				if gin.Mode() == "debug" {
					// 错误
					apiException = ServerErrorWithMsg(e.Error())
				} else {
					// 未知错误
					apiException = UnknownError(e.Error())
				}
			} else {
				apiException = ServerError()
			}
			c.JSON(http.StatusOK, apiException)
			return
		}
	}
}

// ServerError 500 错误处理
func ServerError() *APIException {
	return newAPIException(http.StatusInternalServerError, http.StatusText(http.StatusInternalServerError))
}

// ServerErrorWithMsg 500 错误处理
func ServerErrorWithMsg(msg string) *APIException {
	return newAPIException(http.StatusInternalServerError, msg)
}

// NotFound 404 错误
func NotFound() *APIException {
	return newAPIException(http.StatusNotFound, http.StatusText(http.StatusNotFound))
}

// UnknownError 未知错误
func UnknownError(message string) *APIException {
	return newAPIException(http.StatusForbidden, message)
}

// ParameterError 参数错误
func ParameterError(message string) *APIException {
	return newAPIException(http.StatusBadRequest, message)
}

// HandleNotFound method/request not found处理
func HandleNotFound(c *gin.Context) {
	handleErr := NotFound()
	c.JSON(handleErr.Code, handleErr)
}

func Route(e *gin.RouterGroup) {
	e.POST("/", config.Wrapper(load))
}

func load(c *gin.Context) error {
}