gin 路由处理&控制器

获取请求传参

获取get请求传参

Query和DefaultQuery

	router := gin.Default()

	// 127.0.0.1:8080/index?page=1&category=2
	router.GET("/index", func(context *gin.Context) {
		// 通过Query获取get请求url传入的参数
		page := context.Query("page")
		// 通过DefaultQuery获取url传入的参数，如果能获取到key对应的值，则使用该值，否则使用传入的默认值1
		category := context.DefaultQuery("category", "1")
		// 返回值 {"category": "2", "page": "1" }
		context.JSON(http.StatusOK, gin.H{"page": page, "category": category})

	})

	router.Run()

动态路由传值

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

	// 动态路由传值，通过:字段的方式，
	router.GET("/list/:id", func(context *gin.Context) {
		// 获取到url传入的值
		id := context.Param("id")
		context.JSON(http.StatusOK, gin.H{"id": id})

	})

	router.Run()

}

获取post请求传参

获取POST数据

	router.POST("/user", func(context *gin.Context) {
		// PostForm 获取表单传值，如果没有传，则是空
		username := context.PostForm("username")
		// DefaultPostForm 获取表单传值，如果能获取到，则用该值，否则使用传入的默认值
		nickname := context.DefaultPostForm("nickname", "小明")
		context.JSON(http.StatusOK, gin.H{"username": username, "nickname": nickname})
	})

获取Post Xml数据

如果用到 JSON 或 XML 来作为数据交互的格式， 可以在 gin 中使用 c.GetRawData()获取数据

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

type UserInfo struct {
	UserName string `xml:"username" json:"user"`
	NickName string `xml:"nickname" json:"nickname"`
}

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

	router.POST("/getUer", func(context *gin.Context) {
		user := &UserInfo{}

		// 返回一个byte类型的切片和一个error
		sliceByte, _ := context.GetRawData() // GetRawData 获取context.Request.Body 读取请求数据

		//Unmarshal作用是将xml数据解析为结构体，第一个参数是包含xml数据的字节数组，第二个是要解析为的目标结构体
		// Unmarshal返回一个error
		if err := xml.Unmarshal(sliceByte, &user); err == nil {
			context.JSON(http.StatusOK, user)

		} else {
			// 返回值400错误码，err.Error是具体错误
			context.JSON(http.StatusBadRequest, gin.H{"err": err.Error()})
		}

	})
	router.Run()

}

传值绑定到结构体

我们可以基于请求的 Content-Type 识别请求数据类型并利用反射机制自动提取请求中 QueryString、form 表单、JSON、XML 等参数到结构体中。 .ShouldBind()能够基于请求自动提取 JSON、form 表单和 QueryString 类型的数据，并把值绑定到指定的结构体对象

// 结构体
type UserInfo struct {
	UserName string `form:"username" json:"user"`
	NickName string `form:"nickname" json:"nickname"`
}

	router.GET("/getUser", func(context *gin.Context) {
		// 初始化结构体
		user := &UserInfo{}
		// ShouldBind接收一个指针地址，返回值是一个error
		// 判断err == nil 说明没有error
   
		if err := context.ShouldBind(&user); err == nil {
			context.JSON(http.StatusOK, user)

		} else {
			context.JSON(http.StatusOK, gin.H{"error": err})
		}

	})

路由分组

简单分组

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

	// 创建路由组
	defaultRouters := router.Group("/")
	{   // 访问路径是 /index
		defaultRouters.GET("/index", func(context *gin.Context) {
			context.String(http.StatusOK, "ok")

		})
	}

	// 创建路由组

	apiRouters := router.Group("api")
	{
		// 访问路径= api/list,
		apiRouters.GET("/list", func(context *gin.Context) {
			context.String(http.StatusOK, "ok")

		})
	}

	router.Run()

}

文件分组路由

1. 创建其他路由文件

package api

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

// router *gin.Engine ：main中创建的默认引擎
func ApiRoutersInit(router *gin.Engine) {
	// 创建路由组
	apiRouter := router.Group("api")
	{
		//  api/list
		apiRouter.GET("list", func(context *gin.Context) {
			context.String(http.StatusOK, "ok")
		})
	}

}

2. 在主路由调用并传入默认路由引擎

   package main
   
   import (
   	"github.com/gin-gonic/gin"
     // 其他路由所在的包
   	"golang_7/api"
   )
   
   func main() {
   	// 默认引擎
   	router := gin.Default()
   	// 调用其他文件定义的接收引擎的方法
   	api.ApiRoutersInit(router)
   	router.Run()
   
   }
   
   

控制器

路由分组中还需要处理对应的业务逻辑，控制器是用于处理请求的代码块或函数，它负责接收请求，处理请求中的数据并生成响应。控制器通常与路由关联，路由将请求分发给相应的控制器进行处理，两者配合可以路由只是处理路由，控制器来处理逻辑，业务抽离

业务推荐写法:路由分发交给路由处理，业务逻辑控制器处理

控制器分组

控制器方法

// 自定义apicontrollers包
package apicontrollers

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

func ApiGetInfo(context *gin.Context) {
	context.String(http.StatusOK, "ok")

}

在路由中注册控制器方法

package api

import (
	"github.com/gin-gonic/gin"
	// 引入apicontrollers包

	apicontrollers "golang_7/controllers/api"
)

// router *gin.Engine ：main中创建的默认引擎
func ApiRoutersInit(router *gin.Engine) {

	apiRouter := router.Group("api")
	{
		// 通过controllers包 引入 ApiGetInfo方法，ApiGetInfo不能+(), 有()是调用方法，没()是注册方法
		apiRouter.GET("list", apicontrollers.ApiGetInfo)

	}
}

控制器继承

把控制器方法改造成结构体

package apicontrollers

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

// 定义结构体
type ApiController struct {
}

// 定义结构体方法控制器
func (a ApiController) ApiGetInfo(context *gin.Context) {
	context.String(http.StatusOK, "ok")
}

// 定义结构体方法控制器
func (a ApiController) ApiSetInfo(context *gin.Context) {
	context.String(http.StatusOK, "ok")
}

使用结构体调用方法

package api

import (
	"github.com/gin-gonic/gin"
	// 引入apicontrollers包

	apicontrollers "golang_7/controllers/api"
)

// router *gin.Engine ：main中创建的默认引擎
func ApiRoutersInit(router *gin.Engine) {

	apiRouter := router.Group("api")
	{ 
    // apicontrollers包的ApiController结构体的ApiGetInfo方法
		apiRouter.GET("list", apicontrollers.ApiController{}.ApiGetInfo)

	}
}

控制器继承

父类控制器

package apicontrollers

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

// 定义一个base结构体
type BaseController struct {
}

// 定义 结构体方法-请求成功
func (b BaseController) success(ctx *gin.Context) {
	ctx.String(http.StatusOK, "ok")

}

// 定义 结构体方法-请求失败
func (b BaseController) error(ctx *gin.Context) {
	ctx.String(http.StatusBadRequest, "error")

}

子类控制器

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

// 定义结构体
type ApiController struct {
	// 嵌套BaseControll结构体
	BaseController BaseController
}

// 定义结构体方法控制器
func (a ApiController) ApiGetInfo(context *gin.Context) {
	// 调用嵌套继承的BaseController的success方法
	a.BaseController.success(context)
}

// 定义结构体方法控制器
func (a ApiController) ApiSetInfo(context *gin.Context) {
	context.String(http.StatusOK, "ok")
}