三、请求与响应

3.1、请求数据

（1）获取基本请求数据

r.GET("/test", func(c *gin.Context) {
	// 获取基本请求信息
	fmt.Println(c.Request.Method)     // 获取请求方法，输出为 get
	fmt.Println(c.Request.URL)        // 获取请求路径，输出为 /test
	fmt.Println(c.Request.RemoteAddr) // 获取客户端 IP 地址，输出为 127.0.0.1:58581
	fmt.Println(c.ClientIP())         // 获取客户端 IP 地址，输出为 127.0.0.1

	// 获取请求头
	fmt.Println(c.Request.Header)         // 获取所有请求头信息
	fmt.Println(c.Request.Header["User-Agent"]) // 获取 User-Agent 请求头信息
	fmt.Println(c.GetHeader("User-Agent")) // 获取 User-Agent 请求头信息

	c.String(200, "test ok") // 返回响应内容 "test ok"，状态码为 200
})

（2）获取路径参数

获取URL路径参数，指的是获取/user/:id这类路由绑定的参数，这个例子，绑定了一个参数ID，获取URL路径参数常用函数：

// Param 返回具有给定键的路由参数的值
func(c*Context)Param(keystring)string

案例：

    r := gin.Default()
    r.GET("/user/:id", func(c *gin.Context) {
		// 获取URL参数ID
		id := c.Param("id")
	})

（3）获取查询参数

Get请求url例子：/path?kd=June

获取Get请求参数的常用函数：

func (c *Context) Query(key string) string {
	// Query 返回具有给定键的查询参数的值
	// 如果没有找到该参数，则返回空字符串
	return c.Request.URL.Query().Get(key)
}

func (c *Context) DefaultQuery(key, defaultValue string) string {
	// DefaultQuery 返回具有给定键的查询参数的值
	// 如果没有找到该参数，则返回默认值 defaultValue
	value := c.Request.URL.Query().Get(key)
	if value == "" {
		return defaultValue
	}
	return value
}

func (c *Context) GetQuery(key string) (string, bool) {
	// GetQuery 返回具有给定键的查询参数的值及其是否存在的布尔值
	// 如果找到该参数，则返回值和 true
	// 如果没有找到该参数，则返回空字符串和 false
	value := c.Request.URL.Query().Get(key)
	if value != "" {
		return value, true
	}
	return "", false
}

// 例⼦：
funcHandler(c *gin.Context){
    //获取name参数,通过Query获取的参数值是String类型。
    name:=c.Query("name")
    //获取name参数,跟Query函数的区别是，可以通过第⼆个参数设置默认值。
    name:=c.DefaultQuery("name","root")
    //获取id参数,通过GetQuery获取的参数值也是String类型,
    //区别是GetQuery返回两个参数，第⼀个是参数值，第⼆个参数是参数是否存在的bool值，可以⽤来判断参数是否存在。
    id,ok:=c.GetQuery("id")
    if!ok{
    //参数不存在
    }
}
// 提⽰：GetQuery函数，判断参数是否存在的逻辑是，参数值为空，参数也算存在，只有没有提交参数，才算参数不存在。

（4）获取PostForm数据

获取Post请求参数的常用函数：

func (c *Context) PostForm(key string) string {
	// PostForm 返回具有给定键的表单数据字段的值
	// 如果没有找到该字段，则返回空字符串
	return c.Request.PostFormValue(key)
}

func (c *Context) DefaultPostForm(key, defaultValue string) string {
	// DefaultPostForm 返回具有给定键的表单数据字段的值
	// 如果没有找到该字段，则返回默认值 defaultValue
	value := c.Request.PostFormValue(key)
	if value == "" {
		return defaultValue
	}
	return value
}

func (c *Context) GetPostForm(key string) (string, bool) {
	// GetPostForm 返回具有给定键的表单数据字段的值及其是否存在的布尔值
	// 如果找到该字段，则返回值和 true
	// 如果没有找到该字段，则返回空字符串和 false
	value := c.Request.PostFormValue(key)
	if value != "" {
		return value, true
	}
	return "", false
}

// 例⼦：
funcHandler(c *gin.Context){
    //获取name参数,通过PostForm获取的参数值是String类型。
    name:=c.PostForm("name")
    //跟PostForm的区别是可以通过第⼆个参数设置参数默认值
    name:=c.DefaultPostForm("name","root")
    //获取id参数,通过GetPostForm获取的参数值也是String类型,
        //区别是GetPostForm返回两个参数，第⼀个是参数值，第⼆个参数是参数是否存在的bool值，可以⽤来判断参数是否存在。
    id,ok:=c.GetPostForm("id")
    if!ok{
    //参数不存在
    }
    // 获取PostForm的数组值
    names:=c.PostFormArray("names")
}

（5）ShouldBind函数

前面获取参数的方式都是一个个参数的读取。比较麻烦，Gin框架支持将请求参数自动绑到一个struct对象，这种方式支持Get/Post请求，也支持http请求body内容为JSON/XML格式的参数。

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

struct标签说明：

（1）json:"name" 数据格式为json格式，并且json字段名为name

（2）form:"name" 表单参数名为name

提⽰：你可以根据⾃⼰的需要选择⽀持的数据类型，例如需要⽀持json数据格式，可以这样定义字段标签:json:"name"

package main

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

type User struct {
	Name  string `json:"name" form:"name"`
	Age   int    `json:"age" form:"age"`
	Email string `json:"email" form:"email"`
}

func main() {
	// 1.创建路由
	r := gin.Default()
	// 初始化路由
	r.POST("/user", func(c *gin.Context) {
		user := User{}
		// 通过ShouldBind函数，请求参数绑定struct对象，处理JSON请求代码是一样的、
		// 如果是Post请求则根据Content-type判断，接受的是JSON数据，还是普通的HTTP请求参数，
		if c.ShouldBind(&user) == nil {
			// 绑定成功，打印请求参数
			log.Println("user", user)
		}
		c.JSON(200, gin.H{
			"msg":                "parser Success",
			"请求的Content-type": c.ContentType(),
			"解析后的数据":       user,
		})
	})

	r.Run(":8080")
}

ShouldBind有一系列函数，大致就是把前面的方式绑定到结构体的方式，如 如：ShouldBindUrl()、ShouldBindQuery()等等，用法和ShouldBind类似，这里就不展开介绍了。

提⽰：如果你通过http请求body传递json格式的请求参数，并且通过post请求的⽅式提交参数，则需要将Content-Type设置为 application/json,如果是xml格式的数据，则设置为application/xml

3.2、响应数据

3.2.1、响应不同的数据格式

（1）响应简单字符串

	r.GET("/str", func(c *gin.Context) {
		c.String(200,"hello world")
	})

（2）响应html页面

	r.LoadHTMLGlob("templates/*")
	r.GET("/index", func(c *gin.Context) {
		c.HTML(200,"index.html",nil)
	})

（3）响应json

	// 返回一个JSON数据
	r.GET("/json", func(c *gin.Context) {
		c.JSON(200, gin.H{
			"message": "json数据",
		})
	})

（4）响应xml数据

	// 返回一个xml数据
	r.GET("/xml", func(c *gin.Context) {
		c.XML(200,gin.H{"message":"XML消息"})
	})

（5）响应protobuf格式

func indexHandler(c *gin.Context) {
	c.XML(200, gin.H{"message": "消息"})
	c.YAML(200, gin.H{"message": "消息"})
	reps := []int64{int64(9), int64(55)}

	// 自定义数据
	lable := "你好啊，今天天气挺好的"

	// 传portbuf
	data := &protoexample.Test{
		Label: &lable,
		Reps:  reps,
	}
	fmt.Println(data)
	c.ProtoBuf(200, data)

}

3.2.2、静态文件]

	// 静态文件配置
	r.Static("/static","./static")

3.2.4、异步响应

package main

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

func main() {
	// 1.创建路由
	// 默认使用了2个中间件Logger(), Recovery()
	r := gin.Default()
	// 1.异步
	r.GET("/async", func(c *gin.Context) {
		// 需要搞一个副本
		copyContext := c.Copy()
		// 异步处理
		go func() {
			time.Sleep(3 * time.Second)
			log.Println("异步执行：" + copyContext.Request.URL.Path)
		}()

		c.JSON(200, gin.H{"msg": "异步执行中"})

	})
	// 2.同步
	r.GET("/sync", func(c *gin.Context) {
		time.Sleep(3 * time.Second)
		log.Println("同步执行：" + c.Request.URL.Path)
		c.JSON(200, gin.H{"msg": "同步执行结束"})
	})

	r.Run(":8080")
}