Gin知识点整理

最新推荐文章于 2024-08-30 21:54:54 发布

MCM Code

最新推荐文章于 2024-08-30 21:54:54 发布

阅读量310

点赞数 7

文章标签： gin

本文链接：https://blog.csdn.net/MCM0115/article/details/139502494

版权

文章目录

1.默认路由实例
2. 路由分组
3. 获取url的参数
4. 获取 get和post表单信息
5. gin返回protobuf
6. 表单验证
7. 表单验证错误翻译成中文

1.默认路由实例

router := gin.Default()

2. 路由分组

goodsGroup := router.Group("/goods")
{
    goodsGroup.Get("/list",goodList)
}

处理请求函数

func goodsList(c *gin.Context){
   c.JSON(200, gin.H{
      "name":"List",
      })
}

3. 获取url的参数

不设规则只是获取参数

goodsGroup := router.Group("/goods")
{
   goodsGroup.GET("/:id/:action",goodsDetail)
}

func goodsDetail(c *gin.Context){
    id := c.Param("id")
    action := c.Param("action")
    c.JSON(200,gin.H{
       "id": id,
       "action": action,
    })  
}

设规则

// 定义Person结构体，用于绑定URI参数
type Person struct{
  ID int `uri:"id" binding:"required"`
  Name string `uri:"name" binding:"required"`
}

func main(){
  router := gin.Default()
  router.GET("/:name/:id",func(c *gin.Context) {
       var person Person
       if err := c.ShouldBindUri(&person); err != nil {
          c.Status(404)
          return
       }
       c.JSON(http.StatusOK,gin.H{
         "name":person.Name,
         "id": person.ID,
        })   
   })
   router.Run()

4. 获取 get和post表单信息

router.POST("/post",getPost)

func getPost(c *gin.Context) {
   id := c.Query("id")
   page := c.DefaultQuery("page","0")
   name := c.PostForm("name")
   message := c.DefaultPostForm("message","信息")
   c.JSON(http.StatusOK,gin.H{
      "id": id,
      "page":page,
      "name":name,
      "message":message,
   })
 }

5. gin返回protobuf

router.GET("/someProtoBuf",returnProto)

func returnProto(c *gin.Context){
   course := []string{"python","go","微服务"}
   user := &proto.Teacher{
     Name: "bobby",
     Course: course,
   }
   c.ProtoBuf(http.StatusOK,user)
}

6. 表单验证

package main

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

// LoginForm 定义了登录请求的数据结构和验证规则
type LoginForm struct {
	User     string `json:"user" binding:"required,min=3,max=10"` // 用户名字段，必填，长度3到10
	Password string `json:"password" binding:"required"`          // 密码字段，必填
}

// SignUpForm 定义了注册请求的数据结构和验证规则
type SignUpForm struct {
	Age        uint8  `json:"age" binding:"gte=1,lte=130"`                    // 年龄字段，范围1到130
	Name       string `json:"name" binding:"required,min=3"`                  // 名字字段，必填，至少3个字符
	Email      string `json:"email" binding:"required,email"`                 // 邮箱字段，必填，必须是有效的邮箱格式
	Password   string `json:"password" binding:"required"`                    // 密码字段，必填
	Repassword string `json:"repassword" binding:"required,eqfield=Password"` // 重复密码字段，必填，必须和密码字段一致
}

func main() {
	router := gin.Default() // 创建一个默认的 Gin 路由器实例

	router.POST("/loginJSON", func(c *gin.Context) { // 定义一个处理 POST /loginJSON 请求的路由
		var loginForm LoginForm
		if err := c.ShouldBind(&loginForm); err != nil { // 绑定请求数据到 loginForm 结构体，并验证
			fmt.Println(err.Error())             // 输出错误信息到控制台
			c.JSON(http.StatusBadRequest, gin.H{ // 返回 400 状态码和错误信息
				"error": err.Error(),
			})
			return
		}
		c.JSON(http.StatusOK, gin.H{ // 返回 200 状态码和成功信息
			"msg": "登录成功",
		})
	})

	router.POST("/signup", func(c *gin.Context) { // 定义一个处理 POST /signup 请求的路由
		var signUpForm SignUpForm
		if err := c.ShouldBind(&signUpForm); err != nil { // 绑定请求数据到 signUpForm 结构体，并验证
			fmt.Println(err.Error())             // 输出错误信息到控制台
			c.JSON(http.StatusBadRequest, gin.H{ // 返回 400 状态码和错误信息
				"error": err.Error(),
			})
			return
		}
		c.JSON(http.StatusOK, gin.H{ // 返回 200 状态码和成功信息
			"msg": "注册成功",
		})
	})

	router.Run(":8080") // 启动 HTTP 服务器，监听端口 8080
}

7. 表单验证错误翻译成中文

package main

import (
	"fmt"
	"github.com/gin-gonic/gin"
	"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"
	en_translations "github.com/go-playground/validator/v10/translations/en"
	zh_translations "github.com/go-playground/validator/v10/translations/zh"
	"net/http"
)

// LoginForm 定义了登录请求的数据结构和验证规则
type LoginForm struct {
	User     string `json:"user" binding:"required,min=3,max=10"` // 用户名字段，必填，长度3到10
	Password string `json:"password" binding:"required"`          // 密码字段，必填
}

// SignUpForm 定义了注册请求的数据结构和验证规则
type SignUpForm struct {
	Age        uint8  `json:"age" binding:"gte=1,lte=130"`                    // 年龄字段，范围1到130
	Name       string `json:"name" binding:"required,min=3"`                  // 名字字段，必填，至少3个字符
	Email      string `json:"email" binding:"required,email"`                 // 邮箱字段，必填，必须是有效的邮箱格式
	Password   string `json:"password" binding:"required"`                    // 密码字段，必填
	Repassword string `json:"repassword" binding:"required,eqfield=Password"` // 重复密码字段，必填，必须和密码字段一致
}

var trans ut.Translator // 声明一个全局变量，用于存储翻译器

// InitTrans 初始化翻译器
func InitTrans(locale string) (err error) {
	// 修改 gin 框架中的 validator 引擎属性，实现定制
	if v, ok := binding.Validator.Engine().(*validator.Validate); ok {
		zhT := zh.New()                       // 创建中文翻译器
		enT := en.New()                       // 创建英文翻译器
		uni := ut.New(enT, zhT, zhT)          // 创建 Universal Translator
		trans, ok = uni.GetTranslator(locale) // 获取指定语言的翻译器
		if !ok {
			return fmt.Errorf("uni.GetTranslator(%s)", locale) // 获取翻译器失败时返回错误
		}
		switch locale {
		case "en":
			en_translations.RegisterDefaultTranslations(v, trans) // 注册英文翻译
		case "zh":
			zh_translations.RegisterDefaultTranslations(v, trans) // 注册中文翻译
		default:
			en_translations.RegisterDefaultTranslations(v, trans) // 默认注册英文翻译
		}
		return
	}
	return
}

func main() {
	if err := InitTrans("zh"); err != nil { // 初始化翻译器，选择中文
		fmt.Println("初始化翻译器错误") // 初始化失败时输出错误信息
		return
	}
	router := gin.Default() // 创建一个默认的 Gin 路由器实例

	router.POST("/loginJSON", func(c *gin.Context) { // 定义一个处理 POST /loginJSON 请求的路由
		var loginForm LoginForm
		if err := c.ShouldBind(&loginForm); err != nil { // 绑定请求数据到 loginForm 结构体，并验证
			errs, ok := err.(validator.ValidationErrors) // 判断错误类型是否为验证错误
			if !ok {                                     // 如果不是验证错误
				c.JSON(http.StatusBadRequest, gin.H{
					"error": err.Error(), // 返回错误信息
				})
			}
			fmt.Println(err.Error())             // 输出错误信息到控制台
			c.JSON(http.StatusBadRequest, gin.H{ // 返回 400 状态码和翻译后的错误信息
				"error": errs.Translate(trans),
			})
			return
		}
		c.JSON(http.StatusOK, gin.H{ // 返回 200 状态码和成功信息
			"msg": "登录成功",
		})
	})

	router.POST("/signup", func(c *gin.Context) { // 定义一个处理 POST /signup 请求的路由
		var signUpForm SignUpForm
		if err := c.ShouldBind(&signUpForm); err != nil { // 绑定请求数据到 signUpForm 结构体，并验证
			errs, ok := err.(validator.ValidationErrors) // 判断错误类型是否为验证错误
			if !ok {                                     // 如果不是验证错误
				c.JSON(http.StatusBadRequest, gin.H{
					"error": err.Error(), // 返回错误信息
				})
			}
			fmt.Println(err.Error())             // 输出错误信息到控制台
			c.JSON(http.StatusBadRequest, gin.H{ // 返回 400 状态码和翻译后的错误信息
				"error": errs.Translate(trans),
			})
			return
		}
		c.JSON(http.StatusOK, gin.H{ // 返回 200 状态码和成功信息
			"msg": "注册成功",
		})
	})

	router.Run(":8080") // 启动 HTTP 服务器，监听端口 8080
}