Get und Post in Gin beziehen sich auf unterschiedliche Methoden in HTTP-Anfragen. Wenn der Client eine HTTP-GET-Anfrage an den Server initiiert, gibt der Server die entsprechenden Ressourcen an den Client zurück. Wenn der Client eine HTTP-POST-Anfrage an den Server initiiert, verarbeitet der Server die vom Client als Teil der Anfrage gesendeten Daten .
Gin ist ein in der Go-Sprache geschriebenes Web-Framework, das HTTP-GET- und HTTP-Post-Anfragen unterstützt. Normalerweise wird HTTP GET verwendet, um Daten oder Ressourcen anzufordern, während HTTP POST verwendet wird, um Daten an den Server zu senden, beispielsweise ein Webformular.
In Gin können wir die GET-Methode verwenden, um einen Handler für eine HTTP-Get-Anfrage zu deklarieren, wie zum Beispiel den folgenden Code:
package main
import (
"github.com/gin-gonic/gin"
)
func main() {
r := gin.Default()
r.GET("/hello", func(c *gin.Context) {
c.String(200, "Hello, Gin!")
})
r.Run() // 启动服务器
}Im obigen Beispiel deklarieren wir einen Handler für die HTTP-Get-Anfrage und sein Routing-Pfad ist „/hello“. Wenn der Client eine GET-Anfrage für „/hello“ an den Server sendet, wird dieser Handler ausgeführt.
Die Get-Anfrage ist hier ein Fall ohne Parameter. Im tatsächlichen Geschäft kann es verschiedene Anfragen geben. Daher fügen wir hier hinzu, dass es eine weitere GET-Anfrage gibt, die ( localhost:8080/login?username= "xiaomi"&password="123456) ähnelt ") Wie erhalten Sie den Wert im Routing, wenn Sie auf einen URL-Link wie diesen zugreifen?
Das heißt, wie erhält der Server die Parameter des URL-Links?
In Gin können Sie die Param- oder Query-Methode verwenden, um die Abfrageparameter in der URL abzurufen. Die Param-Methode kann die Pfadparameter abrufen und die Query-Methode kann die Abfrageparameter abrufen.
Zum Beispiel:
package main
import (
"github.com/gin-gonic/gin"
)
func main() {
r := gin.Default()
// /book/123 动态路由
r.GET("/book/:id", func(c *gin.Context) {
id := c.Param("id")
c.String(200, "Book ID is "+id)
})
// /search?query=gin 路由携带参数
r.GET("/search", func(c *gin.Context) {
query := c.Query("query")
c.String(200, "Search query is "+query)
})
r.Run()
}Im obigen Beispiel verwenden wir die Param-Methode, um den Pfadparameter abzurufen, geben den Parameternamen über „:id“ an , verwenden c.Param(“id“) in der Prozessorfunktion, um den Parameterwert abzurufen , und geben ihn schließlich an zurück der Kunde. Wir verwenden auch die Query-Methode , um die Abfrageparameter abzurufen, verwenden „c.Query(“query“)“, um den Parameterwert mit dem Namen „query“ abzurufen , und geben ihn schließlich an den Client zurück.
Was wir hier beachten müssen, ist, dass die Anfangsbuchstaben der Methoden Param() und Query() alle Großbuchstaben sind . Gleichzeitig sind es diese beiden Methoden
[ c *gin.Context ] Integrierte Methode des C-Objekts.
Darüber hinaus können wir die POST-Methode auch verwenden, um einen Handler für HTTP-Post-Anfragen zu deklarieren, wie zum Beispiel den folgenden Code:
package main
import (
"github.com/gin-gonic/gin"
)
func main() {
r := gin.Default()
r.POST("/login", func(c *gin.Context) {
username := c.PostForm("username")
password := c.PostForm("password")
// 进行用户验证操作
c.String(200, "登录成功！")
})
r.Run() // 启动服务器
}
Im obigen Beispiel deklarieren wir einen Handler für HTTP-Post-Anfragen und sein Routing-Pfad ist „/login“. Wenn der Client eine POST-Anfrage für „/login“ an den Server sendet, wird dieser Handler ausgeführt. Im Prozessor können wir die vom Kunden über die c.PostForm-Methode übermittelten Formulardaten abrufen und entsprechend verarbeiten.
Ergänzende Erläuterung: Wenn die Post-Anfrage eine Anmelde- oder Registrierungsanforderung simuliert, handelt es sich um die Daten der Struktur. Wir müssen die Anforderungsparameter aus der Anforderung c.request.body abrufen und an den Client zurücksenden (unabhängig davon, ob sie erfolgreich ist). (oder nicht). Ein solcher Status muss auf die gleiche Weise gehandhabt werden, um mit der tatsächlichen Entwicklungsumgebung konsistent zu sein. Die folgenden Fälle:
package main
import (
"net/http"
"github.com/gin-gonic/gin"
)
// 定义一个 userinfo 表单结构体对象
type UserInfo struct {
UserName string `json:"username" form:"username"`
Password string `json:"password" form:"password"`
Age string `json:"age" form:"age"`
}
func main() {
// 定义一个路由引擎对象
router := gin.Default()
// 加载 渲染模板 全局
router.LoadHTMLGlob("*templates/**/*")
// 路由 get请求后 返回数据到模板渲染
router.GET("/", func(c *gin.Context) {
// c.JSON(200, gin.H{
// "message": "Hello, world!",
// })
c.HTML(http.StatusOK, "login/index.html", gin.H{
"title": "登录页面",
"content": "这是一个",
})
})
// get请求 c.Query（）方法获取url【/login?usename="小红"&password="123123"】 上的参数值：
router.GET("/login", func(c *gin.Context) {
username := c.Query("username")
password := c.Query("password")
// c.DefaultQuery()方法可以设定默认值，触发的条件是如果获取不到url上这个age参数的值，就返回约定的默认值18
age := c.DefaultQuery("age", "18") // 18 is default value for login form auth form auth
// 获取到url传入的参数跳转到 新的页面 首页 渲染到、default/index.html
c.HTML(http.StatusOK, "default/index.html", gin.H{
"name": username,
"password": password,
"age": age,
})
})
// GET / 动态路由链接 /logout/1233 其中的1233是这个url上的动态变量值,默认取值就是uid
router.GET("/logout/:uid", func(c *gin.Context) {
uid := c.Param("uid") // 获取动态路由url链接上的变量值 /logout/1233 这里的值为1233
status := "登出成功"
// c.String(http.StatusOK, "uid=%v 状态=%v", uid, status)
c.JSON(http.StatusOK, gin.H{
"status": status,
"uid": uid,
})
})
// 赋值结构体
router.GET("/register", func(ctx *gin.Context) {
// ctx.String(http.StatusOK,"成功！！")
ctx.HTML(http.StatusOK, "register/index.html", gin.H{})
})
router.POST("/doAdd", func(ctx *gin.Context) {
// post请求通过 c.PostForm()方法获取表单数据
// username := ctx.PostForm("username")
// password := ctx.PostForm("password")
// age := ctx.DefaultPostForm("age", "20")
// ctx.JSON(http.StatusOK, gin.H{
// "username": username,
// "password": password,
// "age": age,
// })
// post请求 通过 ctx.ShouldBind(&userInfo) 方法 结构体赋值
userInfo := &UserInfo{}
if err := ctx.ShouldBind(&userInfo); err == nil {
ctx.JSON(http.StatusOK, gin.H{
"userInfn": userInfo,
})
} else {
ctx.JSON(http.StatusBadRequest, gin.H{
"error": err.Error(),
})
}
})
router.Run(":8080")
}
Unter ihnen zeigen die Standardeinstellungen der HTML-Seite, die Anmeldung, der Registrierungsordner usw. nur die Bilddateistruktur an.
{
{define "register/index.html"}}
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>注册页面</title>
</head>
<h1>{
{"注册页面"}}</h1>
<form action="/doAdd" method="post">
用户名 <input type="text" name="username" id="username">
密码 <input type="text" name="password" id="password">
年龄 <input type="text" name="age" id="age">
<input type="submit" value="提交">
</form>
</body>
</html>
{
{end}}Wir können ShouldBind Methoden verwenden, um die Daten in der Anfrage an das Strukturobjekt zu binden. Unter der Annahme, dass es sich bei unserem Anforderungstext um Daten im JSON-Format handelt, können wir ihn an das Strukturobjekt binden. Die Schritte sind wie folgt:
1. Definieren Sie die Struktur
type User struct {
Name string `json:"name"`
Age int `json:"age"`
Password string `json:"password"`
}
2. ShouldBind Anwendung
func handlePostRequest(c *gin.Context) {
var user User
if err := c.ShouldBind(&user); err != nil {
c.AbortWithError(http.StatusBadRequest, err)
return
}
c.JSON(http.StatusOK, gin.H{
"name": user.Name,
"age": user.Age,
"password": user.Password,
})
}
Im obigen Beispiel wird eine Struktur definiert, Userum das Datenformat im Anforderungstext darzustellen. Verwenden Sie dann ShouldBind die Methode, um die Daten des Anforderungshauptteils an User das Objekt zu binden und festzustellen, ob die Bindung fehlschlägt.
ShouldBind Die Methode kann je nach Inhaltstyp automatisch verschiedene Bindungstypen durchführen und unterstützt vier Datentypen: JSON, XML und Form. Es ist zu beachten, dass Bind im Gegensatz zur Verwendungsmethode bei einem ShouldBind Fehler der Verwendungsmethode keine Ausnahme ausgelöst wird, sondern ein Fehlerobjekt zurückgegeben wird. Wenn Sie eine Ausnahme auslösen müssen, können Sie die Methode ShouldBindJSON oder verwenden ShouldBindXML .
Darüber hinaus können Sie ShouldBindUri Methoden verwenden, um die Daten in der URL an das Strukturobjekt zu binden. Diese Methode wird ShouldBind ähnlich wie die Methode verwendet. Zum Beispiel:
func handleGetRequest(c *gin.Context) {
var user User
if err := c.ShouldBindUri(&user); err != nil {
c.AbortWithError(http.StatusBadRequest, err)
return
}
c.JSON(http.StatusOK, gin.H{
"name": user.Name,
"age": user.Age,
})
}
Im obigen Beispiel verwenden wir ShouldBindUri eine Methode, um die Daten in der URL an User ein Objekt zu binden und dann User einen Teil der Daten im Objekt an den Client zurückzugeben.
Hier ist der endgültige HTML-Code für die einfache Registrierung. Sie können die Ressource aufrufen, um ihn herunterzuladen.
Das Obige sind die grundlegenden Schritte für die Verwendung des Gin-Frameworks zum Ausführen von Post- und Get-Anfragen. Durch das Erlernen dieser Grundkenntnisse können Sie weiter lernen, wie Sie erweiterte Funktionen wie Routing-Sprünge verwenden, um praktischere Anforderungen zu erfüllen.