Gin框架的初始化

有些项目中 初始化gin框架写的是： r := gin.New()

r.Use(logger.GinLogger(), logger.GinRecovery(true))

而不是r := gin.Default()

为什么呢？

点击进入Default源码发现其实他也是new+两个中间件，（Logger，Recovery）

default源码
func Default() *Engine {
    debugPrintWARNINGDefault()
    engine := New()
     engine.Use(Logger(), Recovery())
    return engine
}

但是中间件已经固定了，对于一些精细化开发来说换成new+自定义中间件则更有性价比；

自定义的：
	r := gin.New()
	r.Use(logger.GinLogger(), logger.GinRecovery(true)) //中间件
更精细化，这两个区别是一个用的是基础log，一个用的是gin框架特殊处理的log

项目结构

后端处理路线通常是先写router层：各种各样的路由信息，

再写controller层：

1 获取参数和参数校验 ：定义参数结构，接收参数并存放
2 业务处理 ：写到逻辑层
3 返回响应 ：可以写中间件方便多次处理

然后logic层：（举登录的例子）

1.一系列登录逻辑判断：
用户是否存在         sql写在dao层，供logic层调用
账号密码是否符合格式  可以不使用sql语句的，直接逻辑判断
判断完成生成对应uid   调用一系列外置方法
对数据进行加密        调用一系列外置方法
保存进数据库          调用dao层sql方法

然后是dao层，写各种数据库操作封装成的方法以供调用

在我看来，controller层最大，logic以实现controller层的业务而出现，dao层最小，以实现logic层中的数据库操作为己任；

所以每次写小需求，先写router层，再写controller层，再写logic层，然后是dao层

这样理解起来比盲目学习要好很多；

Query和Param的区别

虽然已经学了不知道多少遍了，但这两个老是弄反，再写一遍吧

Query:

• Query 用于获取 URL 查询参数。它从 URL 中解析参数，并返回一个字符串值。

如：

name := c.Query("name")

https://example.com/search?query=golang&page=1&limit=10

Param:

• Param 用于获取路径参数。路径参数是包含在 URL 中的参数，例如 /users/:id 中的 :id 就是路径参数。

如：

https://example.com/users/123
userID := c.Param("id") // Returns "123"

而shouldbindjson是什么呢？

ShouldBindJSON:

• ShouldBindJSON 用于将 JSON 数据绑定到结构体。它从请求的 JSON 主体中提取数据，并将其解析到指定的结构体中。

var user User
if err := c.ShouldBindJSON(&user); err == nil {
    // 处理 user 结构体中的数据
}

将 HTTP 请求体中的 JSON 数据绑定到变量 user。

注意点：ShouldBindJSON只能识别是不是json格式，并不能保证数据是否完全符合结构体格式，例如

这样写都会直接通过，

只有

会报错，所以需要手动去对数据进行业务判断（数据校验），例如数据不为空，数据类型不对，数据不符合格式等等，因此就引入了第三方的validator库进行爽歪歪！(^ ▽ ^)，ps:之后说这个库

binding就是gin框架参数校验的tag：required就是不能为空，不然直接结束

常用tag

1. form:
   • form:"fieldName" 表示该字段的值将从 HTTP 请求的表单数据中获取，其中 "fieldName" 是表单字段的名称。
2. query:
   • query:"paramName" 表示该字段的值将从 URL 查询参数中获取，其中 "paramName" 是查询参数的名称。
3. json:
   • json:"fieldName" 表示该字段的值将从 JSON 数据中获取，其中 "fieldName" 是 JSON 对象中的字段名。
4. uri:
   • uri:"paramName" 表示该字段的值将从 URL 的路径参数中获取，其中 "paramName" 是路径参数的名称。
5. binding:
   • binding:"required" 表示该字段是必需的，如果请求中缺少该字段，将返回错误。
6. xml:
   • xml:"fieldName" 表示该字段的值将从 XML 数据中获取，其中 "fieldName" 是 XML 对象中的字段名。
7. header:
   • header:"Header-Name" 表示该字段的值将从 HTTP 请求头中获取，其中 "Header-Name" 是请求头的名称。
8. time:
   • time_format:"2006-01-02" 表示该时间字段的格式，用于将字符串转换为时间类型。

这些标签值用于告诉 Gin 框架在处理请求时如何从不同的数据源（如表单、查询参数、JSON 数据等）中提取和绑定数据。在使用 Gin 进行参数绑定时，可以根据请求中的数据类型和来源选择适当的标签。

接下来是重头戏validator库的说明，validator使用起来还是非常方便的，就是配置麻烦了一点（只是亿点点…）

validator 提供了许多内置的验证规则，如 required、min、max、email、url 等，同时也支持使用正则表达式、自定义函数等进行验证。使用 validator 可以有效地提高应用程序的数据完整性和安全性。

而当不符合validator的tag规则时，返回的错误也是由validator库内置的，比如

我们需要将其改成中文并符合我们自己的代码习惯（这种配置配一次就行了，以后项目框架基本不会变，validator的代码也几乎不需要变化）；

例如说自动翻译成中文，将特定字段格式转为json供前端使用，去掉结构体名称，处理复杂逻辑时候的结构体转换，咳咳，想要完美道阻且艰，错误信息完美到这里已经差不多了（还有很多优化空间阿伟！）

然后是固定代码格式：（只包含了初始化翻译器，可以自动翻译中文，把结构体字段转为json给前端看）

最后还是只有两个功能，可以直接使用哦~~

package controller

import (
    "fmt"
    "reflect"
    "strings"

    "github.com/gin-gonic/gin/binding"
    "github.com/go-playground/locales/en"
    "github.com/go-playground/locales/zh"
    ut "github.com/go-playground/universal-translator"
    "github.com/go-playground/validator/v10"
    enTranslations "github.com/go-playground/validator/v10/translations/en"
    zhTranslations "github.com/go-playground/validator/v10/translations/zh"
)

// 这种初始化代码，知道意思就行，因为每次的项目这个都是提前写好的；
// 定义一个全局翻译器T
var trans ut.Translator

// InitTrans 初始化翻译器
func InitTrans(locale string) (err error) {
    // 修改gin框架中的Validator引擎属性，实现自定制
    if v, ok := binding.Validator.Engine().(*validator.Validate); ok {
       // 注册一个获取json tag的自定义方法
       v.RegisterTagNameFunc(func(fld reflect.StructField) string {
          name := strings.SplitN(fld.Tag.Get("json"), ",", 2)[0]
          if name == "-" {
             return ""
          }
          return name
       })

       zhT := zh.New() // 中文翻译器
       enT := en.New() // 英文翻译器

       // 第一个参数是备用（fallback）的语言环境
       // 后面的参数是应该支持的语言环境（支持多个）
       // uni := ut.New(zhT, zhT) 也是可以的
       uni := ut.New(enT, zhT, enT)

       // locale 通常取决于 http 请求头的 'Accept-Language'
       var ok bool
       // 也可以使用 uni.FindTranslator(...) 传入多个locale进行查找
       trans, ok = uni.GetTranslator(locale)
       if !ok {
          return fmt.Errorf("uni.GetTranslator(%s) failed", locale)
       }

       // 注册翻译器
       switch locale {
       case "en":
          err = enTranslations.RegisterDefaultTranslations(v, trans)
       case "zh":
          err = zhTranslations.RegisterDefaultTranslations(v, trans)
       default:
          err = zhTranslations.RegisterDefaultTranslations(v, trans)
       }
       return
    }
    return
}

使用的时候举例子：

controller/user的post登陆请求

func SignUpHandler(c *gin.Context) {
    //1 获取参数和参数校验
    p := new(models.ParamSignUp) //声明参数p是接收账号密码时的类型
    err := c.ShouldBindJSON(&p)  //获取参数传给p
    if err != nil {
       zap.L().Error("SignUp with invalid param", zap.Error(err)) //用日志输出
       //判断err是不是validator.ValidationErrors 类型,不是的话就不翻译了
       errs, ok := err.(validator.ValidationErrors)
       if !ok { //不是validator类型,正常响应
          c.JSON(http.StatusOK, gin.H{
             "msg": err.Error(),
          })
       }
       //是validator类型的,进行翻译操作
       c.JSON(http.StatusOK, gin.H{
          "msg": errs.Translate(trans),
       })
       return
    }

只用判断是不是validator类型，是的话返回err.Translate(trans)就好了

至于为什么不做其他的处理直到完美，首先代码复杂了，其次对效率也有不小的影响，有这两步已经差不多了；