GIN框架使用

最新推荐文章于 2024-09-13 18:52:52 发布
最新推荐文章于 2024-09-13 18:52:52 发布
阅读量920 收藏 10
点赞数 14
分类专栏： golang 文章标签： gin golang
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49132888/article/details/141323324
版权

hello word

go get -u github.com/gin-gonic/gin

package main

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

func main() {
    
    // 创建一个默认的路由
	r := gin.Default()

    // 注册一个路由规则 路径为/helloword http请求方法为 post 后边的函数用于写该接口的处理逻辑
	r.POST("/helloword", func(c *gin.Context) {
		c.JSON(200, gin.H{"status": "hello word"})
	})

    // 启动监听端口为 8080
	r.Run(":8080")
}

gin热加载

每次使用gin框架开发过程中修改代码都要手动重启，开发极为不便

推荐使用热加载技术

热加载就是当我们对代码进行修改时，程序能够自动重新加载并执行

安装

go get github.com/pilu/fresh

使用 fresh 替代 go run xxx

fresh

这样修改项目代码就会自动重启服务器

四大请求方式

get

获取资源

post

新建数据

put

修改数据

delete

删除数据

package main

import (
	"net/http"

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

func main() {
	r := gin.Default()

    // get请求
	r.GET("/get", func(c *gin.Context) {
		c.JSON(http.StatusOK, gin.H{"msg": "get"})
	})

    // post请求
	r.POST("/post", func(c *gin.Context) {
		c.JSON(http.StatusOK, gin.H{"msg": "post"})
	})

    // put 请求
	r.PUT("/put", func(c *gin.Context) {
		c.JSON(http.StatusOK, gin.H{"msg": "put"})
	})

    // delete 请求
	r.DELETE("/del", func(c *gin.Context) {
		c.JSON(http.StatusOK, gin.H{"msg": "del"})
	})

	r.Run(":8080")
}

响应数据

用结构体响应json数据

package main

import (
	"net/http"

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

type Params struct {
	UserName string `json:"username"`
	Age      int    `json:"age"`
	PassWord string `json:"-"` // 忽略转换为json
}

func main() {
	r := gin.Default()

	r.GET("/json", func(c *gin.Context) {
		p := &Params{
			UserName: "姓名",
			Age:      16,
			PassWord: "123456",
		}
		c.JSON(http.StatusOK, p)
	})

	r.Run(":8080")
}

用map响应json数据

package main

import (
	"net/http"

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

func main() {
	r := gin.Default()

	r.GET("/json", func(c *gin.Context) {

		userMap := map[string]string{
			"username": "姓名",
			"age":      "23",
			"password": "12344",
		}
		c.JSON(http.StatusOK, userMap)
	})

	r.Run(":8080")
}

直接响应json数据

package main

import (
	"net/http"

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

func main() {
	r := gin.Default()

	r.GET("/json", func(c *gin.Context) {

		c.JSON(http.StatusOK, gin.H{"key": "value", "key2": "value2"})
	})

	r.Run(":8080")
}

响应文件

重定向

301表示永久重定向

package main

import (
	"net/http"

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

func main() {
	r := gin.Default()

	r.GET("/redirect", func(c *gin.Context) {
		// 301表示永久重定向 302表示临时重定向
		c.Redirect(http.StatusMovedPermanently, "https://www.baidu.com/") // 301
	})

	r.Run(":8080")
}

302 表示临时重定向

package main

import (
	"net/http"

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

func main() {
	r := gin.Default()

	r.GET("/redirect", func(c *gin.Context) {
		// 301表示永久重定向 302表示临时重定向
		c.Redirect(http.StatusFound, "https://www.baidu.com/") // 301
	})

	r.Run(":8080")
}

获取请求参数

获取query参数

c.Query

发送

localhost:8080/query?id=1223 [get]

获取

package main

import (
	"net/http"

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

func main() {
	r := gin.Default()

	r.GET("/query", func(c *gin.Context) {
		id := c.Query("id")
		c.JSON(http.StatusOK, gin.H{"key": id})
	})

	r.Run(":8080")
}

c.GetQuery校验请求是否传递某个参数并且获取传递的值

如果没传id则报错

package main

import (
	"net/http"

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

func main() {
	r := gin.Default()

	r.GET("/query", func(c *gin.Context) {
		id, ok := c.GetQuery("id")

		if !ok {
			c.JSON(http.StatusNotFound, gin.H{"msg": "没有传id"})
		} else {
			c.JSON(http.StatusOK, gin.H{"data": id})
		}

	})

	r.Run(":8080")
}

c.DefaultQuery设置请求的默认值，如果没穿则设置一个默认值

package main

import (
	"net/http"

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

func main() {
	r := gin.Default()

	r.GET("/query", func(c *gin.Context) {
		id := c.DefaultQuery("id", "1") // 如果请求没穿id则设置默认值
		c.JSON(http.StatusOK, gin.H{"id": id})

	})

	r.Run(":8080")
}

获取path参数

c.Param

发送

localhost:8080/pathparams/12323

获取

package main

import (
	"net/http"

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

func main() {
	r := gin.Default()
	r.GET("/pathparams/:id", func(c *gin.Context) {
		id := c.Param("id")
		c.JSON(http.StatusOK, gin.H{"id": id})
	})
	r.Run(":8080")
}

获取请求头

获取请求头

c.GetHeader 获取一个具体的请求头

请求

localhost:8080/header

在请求头传参数

token: eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJVc2VyTmFtZSI6InJvb3QiLCJleHAiOjE3MjM1MzYzODksImlzcyI6IuacrOS6uiIsIm5iZiI6MTcyMzUzNDk0OX0.Xd9jzJw7doy6ibbv9XHOBskI63NGMh9CfvgJjB74Q7g

获取

package main

import (
	"net/http"

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

func main() {
	r := gin.Default()

	r.GET("/header", func(c *gin.Context) {
		token := c.GetHeader("token")
		c.JSON(http.StatusNotFound, gin.H{"token": token})

	})

	r.Run(":8080")
}

c.Request.Header 获取所有请求头

package main

import (
	"net/http"

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

func main() {
	r := gin.Default()

	r.GET("/header", func(c *gin.Context) {
		headers := c.Request.Header
		c.JSON(http.StatusOK, gin.H{"headers": headers})

	})

	r.Run(":8080")
}

设置请求头

c.Header 设置请求头

package main

import (
	"net/http"

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

func main() {
	r := gin.Default()

	r.GET("/header", func(c *gin.Context) {
		c.Header("Res-Header", "value")
		c.JSON(http.StatusOK, gin.H{"headers": "ok"})

	})

	r.Run(":8080")
}

bind 用结构体获取参数

gin 中的bind 可以方便的将前端 传递来的数据与结构体 进行 参数绑定，以及参数校验

使用这个功能，需要声明结构体，并在标签上加上 Tag

绑定body的请求参数

请求

localhost:8080/bind [post]

[body]
{
    "name": "小明",
    "age": 12,
    "sex": "男"
}

获取

package main

import (
	"net/http"

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

type UserInfo struct {
	Name string `json:"name`
	Aga  int    `json:"age`
	Sex  string `json:"sex`
}

func main() {
	r := gin.Default()
	r.POST("/bind", func(c *gin.Context) {
		var u UserInfo = UserInfo{}
		c.ShouldBindJSON(&u)
		c.JSON(http.StatusOK, gin.H{"data": u})
	})

	r.Run(":8080")
}

绑定query的请求参数

请求

localhost:8080/bind?name=小明&age=122&sex=男

响应

需要在结构体加 form 标签

package main

import (
	"net/http"

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

type UserInfo struct {
	Name string `json:"name" form:"name"`
	Aga  int    `json:"age" form:"age"`
	Sex  string `json:"sex" form:"sex"`
}

func main() {
	r := gin.Default()
	r.GET("/bind", func(c *gin.Context) {
		var u UserInfo = UserInfo{}
		c.ShouldBindQuery(&u)
		c.JSON(http.StatusOK, gin.H{"data": u})
	})

	r.Run(":8080")
}

绑定path中的参数

请求

localhost:8080/bind/姓名/15/男

响应

需要在结构体标签加上 uri 说明

package main

import (
	"net/http"

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

type UserInfo struct {
	Name string `json:"name" form:"name" uri:"name"`
	Aga  int    `json:"age" form:"age" uri:"age"`
	Sex  string `json:"sex" form:"sex" uri:"sex"`
}

func main() {
	r := gin.Default()
	r.GET("/bind/:name/:age/:sex", func(c *gin.Context) {
		var u UserInfo = UserInfo{}
		c.ShouldBindUri(&u)
		c.JSON(http.StatusOK, gin.H{"data": u})
	})

	r.Run(":8080")
}

bind校验

安装validator库

go get -u github.com/go-playground/validator/v10

在Gin框架中，数据绑定和验证是开发API时不可或缺的部分。Gin提供了强大的binding功能，允许我们将请求的数据绑定到结构体，并通过标签进行数据验证。本文将详细讲解如何在Gin中使用binding验证器进行数据验证，并提供代码示例帮助理解

具体使用

  1. 定义struct 数据模型配置验证字段
  2. 使用内置验证函数
  3. 错误处理

所有的验证规则都定义在binding标签内

自带验证器

常用验证器

  • required：字段是必填的。
  • email：验证字段是否是有效的电子邮件地址。
  • min：验证字段的值是否大于或等于指定的最小值（适用于数字和字符串）。
  • max：验证字段的值是否小于或等于指定的最大值（适用于数字和字符串）。
  • gte：验证字段的值是否大于或等于指定的最小值（适用于数字）。
  • lte：验证字段的值是否小于或等于指定的最大值（适用于数字）。
  • len：验证字段的长度是否等于指定值（适用于字符串、切片、数组、map）。
  • oneof：验证字段的值是否在指定的枚举值中。
  • uuid：验证字段是否是有效的 UUID。
  • ipv4 / ipv6 / ip：验证字段是否是有效的 IP 地址。
  • url：验证字段是否是有效的 URL。
验证器名称说明示例
-忽略字段binding:“-”
required必填字段binding:“required”
min最小长度binding:“min=10”
max最大长度binding:“max=10”
structonly如果有嵌套，可以决定只验证结构体上的binding:“structonly”
omitempty省略空，如果为空，则不会继续验证该字段上其他的规则，只有不为空才会继续验证其他的
len长度binding:“len=10”
eq等于binding:“eq=10”
ne不等于binding:“ne=10”
gt大于binding:“gt=10”
gte大于等于binding:“gte=10”
lt小于binding:“lt=10”
lte小于等于binding:“lte=10”
eqfield等于其他字段的值binding:“eqfield=ConfirmPassword”
nefield不等于其他字段的值
eqcsfield类似eqfield，它会验证相对于顶层结构提供的字段
necsfield
gtfield大于其他字段的值
gtefield大于等于其他字段的值
gtcsfield
gtecsfield
ltfield小于其他字段的值
ltefield
ltcsfield
ltecsfield
alpha字符串值仅包含字母字符
alphanum字符串值仅包含字母数字字符
numeric字符串值包含基本数字值。基本不包括指数等…
hexadecimal字符串值包含有效的十六进制
hexcolor验证字符串值包含有效的十六进制颜色, 包括井号(＃)
rgb字符串值包含有效的rgb颜色
rgba字符串值包含有效的rgba颜色
HSL字符串值包含有效的hsl颜色
hsla字符串值包含有效的hsla颜色
email字符串值包含有效的电子邮件
url字符串值包含有效的网址，必须包含http://等
uri字符串值包含有效的uri. 它将接受golang请求uri接受的任何uri
base64字符串值包含有效的base64值
contains字符串值包含子字符串值, contains=@
containsany包含所有，containsany =！@＃？
containsrune字符串值包含提供的符号 containsrune = @
excludes字符串值不包含子字符串值，excludes = @
excludeall排除所有
excluderune字符串值不包含提供的符号，excluderune = @
isbn国际标准书号，验证字符串值包含有效的isbn10或isbn13值
isbn10国际标准书号10, 验证字符串值包含有效的isbn10值
isbn13国际标准书号13, 字符串值包含有效的isbn13值
uuid字符串值包含有效的UUID
uuid3字符串值包含有效的版本3
uuid4字符串值包含有效的版本4
uuid5字符串值包含有效的版本
ascii字符串值仅包含ASCII字符. 注意：如果字符串为空, 则验证为true
asciiprint字符串值仅包含可打印的ASCII字符. 注意: 如果字符串为空，则验证为true
multibyte字符串值包含一个或多个多字节字符。注意：如果字符串为空，则验证为true
datauri字符串值包含有效的DataURI。注意：这还将验证数据部分是有效的base64
latitude纬度，字符串值包含有效的纬度
longitude经度，字符串值包含有效的经度
ssn字符串值包含有效的美国社会安全号码
ip字符串值包含有效的IP地址
ipv4字符串值包含有效的v4 IP地址
ipv6字符串值包含有效的v6 IP地址
cidr字符串值包含有效的CIDR地址
cidrv4字符串值包含有效的CIDR地址
cidrv6字符串值包含有效的v6 CIDR地址
tcp_addr字符串值包含有效的可解析TCP地址
dive嵌套验证

简单示例

package main

import (
	"net/http"

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

// 声明一个结构体用来接收请求参数
type User struct {
	Name  string `form:"name" json:"name" binding:"required"`
	Email string `form:"email" json:"email" binding:"required,email"`
	Age   int    `form:"age" json:"age" binding:"required,eq=10"`
}

func main() {
	r := gin.Default()
	// get请求
	r.GET("/test", func(c *gin.Context) {
		var user User
		if err := c.ShouldBindQuery(&user); err != nil {
			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
			return
		}
		c.JSON(http.StatusOK, gin.H{"message": "User created successfully!", "user": user})
	})
	r.Run(":8080")
}

自定义验证

可以通过实现 validator.Func 接口来定义自定义验证函数。以下是一个示例

package main

import (
	"net/http"
	"regexp"

	"github.com/gin-gonic/gin"
	"github.com/gin-gonic/gin/binding"
	"github.com/go-playground/validator/v10"
)

// 定义自定义验证函数
var validUsername validator.Func = func(fl validator.FieldLevel) bool {
	if username, ok := fl.Field().Interface().(string); ok {
		return regexp.MustCompile(`^[a-zA-Z0-9_]+$`).MatchString(username)
	}
	return false
}

// 声明一个结构体用来接收请求参数
type User struct {
	Username string `json:"username" binding:"required,validUsername" form:"username"`
	Email    string `json:"email" binding:"required,email" form:"email"`
}

func main() {
	r := gin.Default()

	// 获取默认验证器
	if v, ok := binding.Validator.Engine().(*validator.Validate); ok {
		// 注册自定义验证函数
		v.RegisterValidation("validUsername", validUsername)
	}

	// get请求
	r.GET("/test", func(c *gin.Context) {
		var user User
		if err := c.ShouldBindQuery(&user); err != nil {
			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
			return
		}
		c.JSON(http.StatusOK, gin.H{"message": "User created successfully!", "user": user})
	})
	r.Run(":8080")
}

嵌套结构体验证

Gin 也支持对嵌套结构体进行验证。例如

package main

import (
	"net/http"

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

type Address struct {
	Street string `json:"street" binding:"required"`
	City   string `json:"city" binding:"required"`
}

type User struct {
	Name    string    `json:"name" binding:"required"`
	Email   string    `json:"email" binding:"required,email"`
	Address []Address `json:"address" binding:"required,dive"`
}

func main() {
	r := gin.Default()

	// get请求
	r.POST("/test", func(c *gin.Context) {
		var user User
		if err := c.ShouldBindJSON(&user); err != nil {
			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
			return
		}
		c.JSON(http.StatusOK, gin.H{"message": "User created successfully!", "user": user})
	})
	r.Run(":8080")
}

转化中文

package main

import (
	"github.com/gin-gonic/gin"
	"github.com/gin-gonic/gin/binding"
	"github.com/go-playground/locales/zh"
	ut "github.com/go-playground/universal-translator"
	"github.com/go-playground/validator/v10"
	zh_translations "github.com/go-playground/validator/v10/translations/zh"
)

var (
	uni      *ut.UniversalTranslator
	validate *validator.Validate
	trans    ut.Translator
)

func Init() {
	//注册翻译器
	zh := zh.New()
	uni = ut.New(zh, zh)

	trans, _ = uni.GetTranslator("zh")

	//获取gin的校验器
	validate := binding.Validator.Engine().(*validator.Validate)
	//注册翻译器
	zh_translations.RegisterDefaultTranslations(validate, trans)
}

// Translate 翻译错误信息
func Translate(err error) map[string][]string {

	var result = make(map[string][]string)

	errors := err.(validator.ValidationErrors)

	for _, err := range errors {
		result[err.Field()] = append(result[err.Field()], err.Translate(trans))
	}
	return result
}

type Booking struct {
	CheckIn  string `form:"check_in" json:"check_in"  binding:"required,email" `
	CheckOut string `form:"check_out" json:"check_out"  binding:"required"`
}

func main() {
	Init()
	r := gin.Default()

	// get请求
	r.POST("/test", func(c *gin.Context) {
		var b Booking
		err := c.ShouldBindJSON(&b)
		if err == nil {
			c.JSON(200, gin.H{"message": "Success"})
			return
		} else {
			c.JSON(200, gin.H{"message": Translate(err)})
			return
		}
	})
	r.Run(":8080")
}

文件操作

c.FormFile 获取上传文件

请求

在这里插入图片描述

响应

package main

import (
	"net/http"

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

func main() {
	r := gin.Default()
	r.POST("/upload", func(c *gin.Context) {
		file, err := c.FormFile("file")
		if err != nil {
			c.JSON(http.StatusOK, gin.H{"msg": "上传失败"})
		} else {
			fileSize := file.Size / 1024
			c.JSON(http.StatusOK, gin.H{"msg": "上传成功", "fileSize": fileSize})
		}
	})

	r.Run(":8080")
}

c.SaveUploadedFile将上传的文件保存

package main

import (
	"net/http"

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

func main() {
	r := gin.Default()
	r.POST("/upload", func(c *gin.Context) {
		file, err := c.FormFile("file")
		if err != nil {
			c.JSON(http.StatusOK, gin.H{"msg": "上传失败"})
		} else {

			fileSize := file.Size / 1024
			path := "./file/" + file.Filename
            // file具体的文件 path是要保存到的路径
			c.SaveUploadedFile(file, path)
			c.JSON(http.StatusOK, gin.H{"msg": "上传成功", "fileSize": fileSize})
		}
	})

	r.Run(":8080")
}

c.File 下载文件

package main

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

func main() {
	r := gin.Default()
	r.GET("/download", func(c *gin.Context) {
		path := "file/内饰.pdf"
		c.Header("Content-Type", "application/octet-steam")
		c.Header("Content-Disposition", "attachment; filename="+"牛掰.pdf")
		c.Header("Content-Transfer-Encoding", "binary")
		c.File(path)
	})

	r.Run(":8080")
}

中间件

gin允许开发者在处理请求过程中，加入用户自己的狗子函数，这个函数就是中间件

中间件射虎处理公共的业务逻辑，比如登录验证，权限校验，数据分页，记录日志，统计耗时等

package main

import (
	"log"
	"net/http"

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

// 这个函数就是一个中间件
func m1(c *gin.Context) {
	log.Println("中间件执行了")
}

func main() {
	r := gin.Default()
	r.GET("/test", m1, func(c *gin.Context) {
		c.JSON(http.StatusOK, gin.H{"msg": "成功"})
	})

	r.Run(":8080")
}

c.Abort() 拦截请求往下执行

package main

import (
	"log"
	"net/http"

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

func m1(c *gin.Context) {
	c.Abort() // 拦截请求往下执行
}

func main() {
	r := gin.Default()
	r.GET("/test", m1, func(c *gin.Context) {
        // 这里不会执行
		c.JSON(http.StatusOK, gin.H{"msg": "成功"})
	})

	r.Run(":8080")
}

加入多个中间件

package main

import (
	"log"
	"net/http"

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

// 第一个中间件
func m1(c *gin.Context) {
	log.Println(" 第一个中间件执行了")
}

// 第二个中间件
func m2(c *gin.Context) {
	log.Println("第二个中间件执行了")
}

func main() {
	r := gin.Default()
	r.GET("/test", m1, m2, func(c *gin.Context) {
		c.JSON(http.StatusOK, gin.H{"msg": "成功"})
	})

	r.Run(":8080")
}

c.Next() 洋葱模型

package main

import (
	"log"
	"net/http"

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

// 第一个中间件
func m1(c *gin.Context) {
	log.Println(" 第一个中间件in")
	c.Next()
	log.Println(" 第一个中间件out")

}

func main() {
	r := gin.Default()
	r.GET("/test", m1, func(c *gin.Context) {
		log.Println("响应数据")
		c.JSON(http.StatusOK, gin.H{"msg": "成功"})
	})

	r.Run(":8080")
}

打印结果

11:11:57 app         | 2024/08/14 11:11:57  第一个中间件in
11:11:57 app         | 2024/08/14 11:11:57 响应数据
2024/08/14 11:11:57  第一个中间件out

注册全局中间件

package main

import (
	"log"
	"net/http"

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

// 第一个全局中间件
func global1(c *gin.Context) {
	log.Println(" 第1个中间件in")
	c.Next()
	log.Println(" 第1个中间件out")
}

// 第二个全局中间件
func global2(c *gin.Context) {
	log.Println(" 第2个中间件in")
	c.Next()
	log.Println(" 第2个中间件out")
}

func main() {
	r := gin.Default()
	r.Use(global1, global2)
	r.GET("/test", func(c *gin.Context) {
		log.Println("响应数据")
		c.JSON(http.StatusOK, gin.H{"msg": "成功"})
	})

	r.Run(":8080")
}

输出

第1个中间件in
第2个中间件in
响应数据
第2个中间件out
第1个中间件out

通过 c.Set c.Get 实现中间件传值

上一个中间件通过 c.Set方法可以在上下文对象中存入一个值

下游中间件通过 c.Get 方法从上下文对象取出

package main

import (
	"log"
	"net/http"

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

// 第一个全局中间件
func m1(c *gin.Context) {
	c.Set("key", "value")
	c.Next()
}

func main() {
	r := gin.Default()
	r.GET("/test", m1, func(c *gin.Context) {

		value, _ := c.Get("key")
		log.Printf("响应数据%v", value)
		c.JSON(http.StatusOK, gin.H{"msg": "成功", "data": value})
	})

	r.Run(":8080")
}

路由分组

package main

import (
	"net/http"

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

func main() {
	r := gin.Default()
	mainRouter := r.Group("/api")

	{
		mainRouter.GET("/get", func(c *gin.Context) {
			c.JSON(http.StatusOK, gin.H{"msg": "成功"})
		})
		mainRouter.POST("/post", func(c *gin.Context) {
			c.JSON(http.StatusOK, gin.H{"msg": "成功"})
		})
	}

	r.Run(":8080")
}

通过 r.Group(“/api”) 返回一个路由组对象

在通过调用组对象的 get post put …方法

这样请求就必须写成

localhost:8080/api/post [post]
localhost:8080/api/get [get]

分组嵌套

实际项目中通常会将接口进行分模块处理

比如用户模块的接口通常会写成

localhost:8080/api/user/xxx

文章模块的接口通常会写成

localhost:8080/api/article/xxx

具体实现

package main

import (
	"net/http"

	"github.com/gin-gonic/gin"
)
func main() {
	r := gin.Default()
	mainRouter := r.Group("/api")

	// 用户模块
	userRouter := mainRouter.Group("/user")
	{
		userRouter.GET("/:id", func(c *gin.Context) {
			c.JSON(http.StatusOK, gin.H{"msg": "调用用户模块"})
		})
	}

	// 文章模块
	articleRouter := mainRouter.Group("/article")
	{
		articleRouter.GET("/:id", func(c *gin.Context) {
			c.JSON(http.StatusOK, gin.H{"msg": "调用文章模块"})
		})
	}

	r.Run(":8080")
}

将路由文件抽离

实际项目不可能将所有路由都写在main文件中，一般会创建一个单独的包用来放各个模块的路由

创建 router 包 并创建 article.go 和 user.go

article.go

package router

import (
	"net/http"

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

// 创建用户路由
func InitArticleRouter(router *gin.RouterGroup) {
	// 用户模块
	userRouter := router.Group("/article")
	{
		userRouter.GET("/:id", func(c *gin.Context) {
			c.JSON(http.StatusOK, gin.H{"msg": "调用文章模块"})
		})
	}
}

user.go

package router

import (
	"net/http"

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

// 创建用户路由
func InitUserRouter(router *gin.RouterGroup) {
	// 用户模块
	userRouter := router.Group("/user")
	{
		userRouter.GET("/:id", func(c *gin.Context) {
			c.JSON(http.StatusOK, gin.H{"msg": "调用用户模块"})
		})
	}
}

main.go

package main

import (
	"gostudy/router"

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

func main() {
	r := gin.Default()
	mainRouter := r.Group("/api")

	{
		router.InitUserRouter(mainRouter)    // 初始化用户路由
		router.InitArticleRouter(mainRouter) // 初始化文章路由
	}

	r.Run(":8080")
}

闭包中间件

有时候我们希望在 r.use( ) 注册中间件时 里边传入的是一个函数

比如

func main() {
	r := gin.Default()
	r.Use(m1())
	r.GET("/test")
	r.Run(":8080")
}

这样就可以在注册中间件时候传入参数

比如

func main() {
	r := gin.Default()
	r.Use(m1("传入的参数"))
	r.GET("/test")
	r.Run(":8080")
}

具体实现

package main

import (
	"log"

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

func m1(str string) gin.HandlerFunc {
	return func(c *gin.Context) {
		log.Printf(str)
		c.Next()
	}
}

func main() {
	r := gin.Default()
	r.Use(m1("log info"))
	r.GET("/test")
	r.Run(":8080")
}

控制台打印

log info

hub.com/gin-gonic/gin"
)

// 创建用户路由
func InitArticleRouter(router *gin.RouterGroup) {
// 用户模块
userRouter := router.Group(“/article”)
{
userRouter.GET(“/:id”, func(c *gin.Context) {
c.JSON(http.StatusOK, gin.H{“msg”: “调用文章模块”})
})
}
}


user.go 

```go
package router

import (
	"net/http"

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

// 创建用户路由
func InitUserRouter(router *gin.RouterGroup) {
	// 用户模块
	userRouter := router.Group("/user")
	{
		userRouter.GET("/:id", func(c *gin.Context) {
			c.JSON(http.StatusOK, gin.H{"msg": "调用用户模块"})
		})
	}
}

main.go

package main

import (
	"gostudy/router"

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

func main() {
	r := gin.Default()
	mainRouter := r.Group("/api")

	{
		router.InitUserRouter(mainRouter)    // 初始化用户路由
		router.InitArticleRouter(mainRouter) // 初始化文章路由
	}

	r.Run(":8080")
}

闭包中间件

有时候我们希望在 r.use( ) 注册中间件时 里边传入的是一个函数

比如

func main() {
	r := gin.Default()
	r.Use(m1())
	r.GET("/test")
	r.Run(":8080")
}

这样就可以在注册中间件时候传入参数

比如

func main() {
	r := gin.Default()
	r.Use(m1("传入的参数"))
	r.GET("/test")
	r.Run(":8080")
}

具体实现

package main

import (
	"log"

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

func m1(str string) gin.HandlerFunc {
	return func(c *gin.Context) {
		log.Printf(str)
		c.Next()
	}
}

func main() {
	r := gin.Default()
	r.Use(m1("log info"))
	r.GET("/test")
	r.Run(":8080")
}

控制台打印

log info
code:404-not-found
关注
专栏目录
gin框架使用JWT鉴定权限
abcnull 的博客
02-10 2267
文章目录简介引入源码代码模型router 中写法middlerware 中写法ParseToken 解析 token string => *jwt.TokensecretKey 密钥AuthClaims 结构体GenerateToken 生成 *jwt.Tokenlogin 登录后响应头设置 cookie常规 HandlerFunc 使用用户信息 简介 目前主流的 gin 的鉴权框架有 github 上的 dgrijalva/jwt-go 和 golang-jwt/jwt，但是 dgrijalva/
从零开发区块链应用(六)--gin框架使用
J_Lee
01-20 681
文章目录一、Gin 框架介绍二、Gin安装三、Gin使用3.1 设置gin模式3.2 创建新路由3.3 创建多路由分组3.4 创建路由3.5 编写接口执行函数3.6 启动服务四、gin框架获取参数4.1 获取query参数4.2 获取form表单参数4.3 获取JSON参数 参考文档： Gin框架介绍及使用：https://www.tianyuan.fun/posts/golang/go-use-of-gin-framework.html 一、Gin 框架介绍 Gin 是一个用 Go 语言编写的 web
gin框架使用logrus日志模块
kogwang的博客
02-01 508
gin框架使用logrus日志模块，自定义输出格式
Gin框架的使用
m0_56137272的博客
09-10 2027
以上就是今天要讲的内容，本文仅仅简单介绍了Gin框架的使用，更多的用法请参考官方文档。
Gin框架使用gorm连接postgresql数据库
zhi0717的博客
03-29 481
以下是全部代码以及一个案例，在项目中自行把握文件结构，这里来案例代码都放在main所在的文中了。用常量存数据库配置信息（在企业级项目中应该去找配置信息，如ymal文件中，这里使用常量替代）搭建好gin框架后，输入命令安装gorm所需要的依赖。注意dialects的依赖中前面有一个 “_”其他数据库只需要更改一下数据库的名字。导入两个gorm所用到的依赖。
探索Gin框架：Golang使用Gin完成文件上传
热门推荐
qq_35716689的博客
02-02 37万+
Go标准库net/http对文件上传已经提供了非常完善的支持，Gin框架在其基础做了封装，使用更加简单便捷。作者：鼠鼠我捏，要死了捏
Gin框架使用教程
gitblog_00952的博客
08-08 832
Gin框架使用教程 gingin-gonic/gin: 是一个基于 Go 语言的 HTTP 框架，支持多种 HTTP 协议和服务。该项目提供了一个简单易用的 HTTP 框架，可以方便地实现 HTTP 服务的开发和部署，同时支持多种 HTTP 协议和服务。项目地址:https://gitcode.com/gh_mirrors/gi/gin 项目介绍 Gin 是一个用 Go (Golang) 编写的...
Golang-Gin框架示例二十多个源码
04-26
Gin框架基于Martini框架设计，使用了 httprouter 库作为路由解析器，提供了高性能的路由处理能力。在这个“Golang-Gin框架示例二十多个源码”中，你可以深入理解并学习如何利用Gin来构建各种类型的Web应用程序。 ...
gin框架简单使用示例
09-01
本示例将引导你了解如何开始使用Gin框架构建web应用。 首先，Gin框架的核心是基于Martini库设计的，但提供了更丰富的中间件支持和更友好的API接口。安装 Gin 可以通过 Go 的包管理器 `go get` 来完成： ```bash go ...
三十六、Gin注册功能-检查账号是否存在
Boo_T的博客
09-10 442
在register.go中进行调用IsExist方法。2、在cms.go中进行初始化数据库连接方法。1、在cms.go中添加数据库连接方法。
Go gin使用命令安装失败原因，及解决方法
weixin_47378963的博客
09-09 611
明明使用的是golang中的web框架gin文档中的命令来安装gin的，而且是直接复制的，可是为什么会安装失败，并且会提示go: go.mod file not found in current directory or any parent directory.因为go.mod文件是 Go 模块的基础，用于记录项目的依赖关系和其他元数据。成功的话，当前的工作目录中会多出一个go.mod的文件。之后，再次输入上面提到的的安装gin的命令。安装好之后，当前的工作目录就会多出一个go.sum的文件。
【Go】-基于Gin和GORM的小清单项目
knoci的博客
09-11 871
knoci/list: 基于Gin的待办清单小项目 (github.com)一个仿照github/Q1mi/bubble 做的一个gin框架练习这个项目是Gin和GORM的非常非常简单的小项目，适合新手入门。
golang学习笔记10——golang 的 Gin 框架，快速构建高效 Web 应用
GoppViper的博客
09-08 1520
Gin 是一个用 Go 语言编写的 HTTP Web 框架，它具有快速、高效、灵活等特点。Gin 基于 httprouter 实现了路由功能，并提供了中间件、请求处理、响应生成等一系列功能，使得开发者能够快速构建出高性能的 Web 应用。Gin 框架是一个非常强大的 Go 语言 Web 框架，它提供了丰富的功能和简洁的 API，使得开发者能够快速构建出高效的 Web 应用。本文介绍了 Gin 框架的基本使用方法，包括安装、创建 Web 应用、使用中间件和获取请求参数等。
三十七、Gin完成登陆功能
Boo_T的博客
09-11 393
这个方法意思是通过这个userid查询数据。
Gin-封装自动路由
qq_46100517的博客
09-09 629
路由分组、中间件、请求参数直接绑定结构体等
三十五、Gin注册功能实战
Boo_T的博客
09-10 517
bcrypt.GenerateFromPassword 进行密码加密，完成encryptPassword函数。若多次打印会发现结果是不一样的。
三十三、Gin的中间件
Boo_T的博客
09-09 437
在Gin框架中，中间件是用于处理请求和响应的功能模块，可以在处理请求之前或之后处理一些额外的操作。
gin配置swagger文档
最新发布
水痕
09-13 612
【代码】gin配置swagger文档。
Go语言 管道1
json_li的博客
09-11 649
本篇文章主要介绍Go语言 无缓冲管道和有缓冲管道概念，特点及其使用示例。
gin框架使用minio
07-28
在提供的引用中，没有提到关于gin框架使用minio的信息。因此，我无法回答关于gin框架使用minio的问题。如果您有其他关于gin框架或minio的问题，我将很乐意帮助您回答。 #### 引用[.reference_title] - *1* *2* *3* [Go语言 gin框架集成Casbin实现访问权限控制](https://blog.csdn.net/weixin_37717557/article/details/108983361)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control_2,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值