GO语言GIN框架入门

Gin框架介绍

Gin是一个用Go语言编写的web框架。它是一个类似于martini但拥有更好性能的API框架, 由于使用了httprouter，速度提高了近40倍。
中文文档

Gin框架安装与使用

安装GIN

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


第一个Gin程序

package mainimport "github.com/gin-gonic/gin"func main() {
// 创建一个默认的路由引擎
engine := gin.Default()
// GET：请求方式；/hello：请求的路径
// 当客户端以GET方法请求/hello路径时，会执行后面的匿名函数
engine.GET("/hello", func(context *gin.Context) {
//返回JSON格式的数据
context.JSON(200, gin.H{
"message": "Hello ares!",
})
})
// 启动HTTP服务，默认在0.0.0.0:8080启动服务
engine.Run()
}
-----------------
$curl 127.0.0.1:8080/hello
{"message":"Hello ares!"}


Gin网络请求与路由处理

创建Engine

Engine被定义成一个结构体，默认可以使用gin.Default()和gin.New()创建。区别在于gin.Default()也适用gin.New()创建engine实例，但是会默认使用Logger和Recover中间件。
Logger是负责进行打印并输出日志的中间件,方便开发者进行程序调试; Recovery中间件的作如果程序执行过程中遇到panc中断了服务,则 Recovery会恢复程序执行,并返回服务器500内误。通常情况下,我们使用默认的gin.Defaul创建 Engine实例。

Handle处理Get请求

附带name默认值

engine := gin.Default()
//get，http://127.0.0.1:8080/hello?name=wx
engine.Handle("GET", "/hello", func(context *gin.Context) {
path := context.FullPath()
fmt.Println(path)
//获取name参数，默认为ares
name := context.DefaultQuery("name", "ares")
fmt.Println(name)
context.Writer.Write([]byte("Hello " + name))
})


通过 Handle方法第一个参数指定处理GET类型的请求,解析的接囗是/ hello。
Context是gin框架中封装的一个结构体,这是gn框架中最重要,最基础的一个结构体对象。该结构体可以提供我们操作请求,处理请求,获取数据等相关的操作,通常称之为上下文对象,简单说为我们提供操作环境可以通过 context. Query和 context. DefaultQuery获取GET请求携带的参数。
engine可以直接解析方法，按照以下方式。

//get，http://127.0.0.1:8080/hello?name=wx
engine.GET("/hello", func(context *gin.Context) {
fmt.Println(context.FullPath())
name := context.Query("name")
fmt.Println(name)
context.Writer.Write([]byte("hello" + name))
})


Handle处理Post，Delete请求

engine := gin.Default()
engine.POST("/login", func(context *gin.Context) {
fmt.Println(context.FullPath())
username, exist := context.GetPostForm("username")
if exist {
fmt.Println(username)
}
context.Writer.Write([]byte("hello" + username))
})
engine.DELETE("/user/:id", func(context *gin.Context) {
fmt.Println(context.FullPath())
//获取id
userID := context.Param("id")
fmt.Println(userID)
context.Writer.Write([]byte("删除id" + userID))
})
engine.Run()


Gin表单实体绑定

使用 PostForm这种单个获取属性和字段的方式,代码量较多,需要一个一个属性进行获取。而表单数据的提交,往往对应着完整的数据结构体定义,其中对应着表单的输入项。gin框架提供了数据结构体和表单提交数据绑定的功能,提高表单数据获取的效率。

ShouldBindQuery（Get）

ShouldBindQuery可以实现Get方式的数据请求绑定。

type Student struct {
Name string `form:"name"`
Classes string `form:"classes"`
}func main() {
engine := gin.Default()
//请求数据绑定,定义结构体
engine.GET("/hello", func(context *gin.Context) {
fmt.Println(context.FullPath()) var student Student
err := context.ShouldBindQuery(&student)
if err != nil {
log.Fatal(err.Error())
return
}
fmt.Println(student.Classes)
fmt.Println(student.Name)
context.Writer.Write([]byte("hello" + " " + student.Name + " " + student.Classes))
})
engine.Run()
}




ShouldBind（Post）

ShouldBind可以实现Post方式的数据请求绑定。

type Resiter struct {
Name string `form:"name"`
Password string `form:"password"`
}func main() {
engine := gin.Default()
engine.POST("/register", func(context *gin.Context) {
fmt.Println(context.FullPath())
var resiter Resiter
err := context.ShouldBind(&resiter)
if err != nil {
log.Fatal(err.Error())
return
}
fmt.Println(resiter.Name)
fmt.Println(resiter.Password)
context.Writer.Write([]byte(resiter.Name + " " +"resiter"))
})
engine.Run()
}




BindJSON（处理json格式数据）

结构体格式务必正确。

type Person struct {
Name string `form:"name"`
Age int `form:"age"`
}func main() {
engine := gin.Default()
engine.POST("/add", func(context *gin.Context) {
fmt.Println(context.FullPath())
var person Person
err := context.BindJSON(&person)
if err != nil {
log.Fatal(err.Error())
return
}
fmt.Println("name:", person.Name)
fmt.Println("age:", person.Age)
context.Writer.Write([]byte("添加" + " " + person.Name))
}) engine.Run()
}




Gin多数据格式返回请求结果

[]byte切片类型

func main() {
engine := gin.Default()
engine.GET("/byte", func(context *gin.Context) {
fmt.Println(context.FullPath())
fullpath := context.FullPath()
context.Writer.Write([]byte(fullpath))
})
engine.Run()
}


Json类型

项目开发中，json格式使用更为普遍。
Gin为了方便开发者更方便的使用该框架进行项目开发,直接支持将返回数据组装成JSON格式进行返回。
Gin框架中的context包含的JsoN方法可以将结构体类型的数据转换成JSON格式的结构化数据,然后返回给客户端。

type Stu struct {
Name string
Id int
Extra string
}func main() {
engine := gin.Default()
//map类型
//调用JSON将map类型数据转换为json格式返回给前端，第一个参数200表示设置请求返回的状态码，和http请求状态码一样
engine.GET("/hellojson", func(context *gin.Context) {
fmt.Println(context.FullPath())
fullpath := context.FullPath()
context.JSON(200, map[string]interface{}{
"code": 1,
"msg": "ok",
"date": fullpath,
})
})
//结构体类型
engine.GET("/helloStruct", func(context *gin.Context) {
fmt.Println(context.FullPath())
fullpath := context.FullPath()
var stu Stu
stu.Name = "ares"
stu.Id = 1
stu.Extra = fullpath
context.JSON(200, &stu)
})
engine.Run()
}
------------------------
$ curl 127.0.0.1:8080/hellojson
{"code":1,"date":"/hellojson","msg":"ok"}
$ curl 127.0.0.1:8080/helloStruct
{"Name":"ares","Id":1,"Extra":"/helloStruct"}


HTML模板

Gin框架还支持返回HTML格式的数据，可以直接渲染HTML页面。需要将静态资源路径设置正确才会生效。


func main() {
engine := gin.Default()
//加载html路径
engine.LoadHTMLGlob("./html/*")
//engine.LoadHTMLGlob("../html/*")
//加载静态资源路径
engine.Static("/image", "./image")
engine.GET("/html", func(context *gin.Context) {
fullpath := "路径" + context.FullPath()
fmt.Println(fullpath) context.HTML(http.StatusOK, "index.html", gin.H{
"fullpath": fullpath,
})
})
engine.Run()
}


html页面：

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>GIN ares</title>
</head>
<body>
<h1>GIN</h1>
{{.fullpath}}
<br>
<img src="../image/shui.jpeg">
</body>
</html>




使用路由组分类处理请求

实际项目中，均为模块化开发，同一模块内的功能接口庙会有相同的接口前缀，如下：

注册:127.0.0.1:8080/user/register
登录:127.0.0.1:8080/user/login
删除：127.0.0.1:8080/user/delete


GIN框架中可使用路由组来实现路由分类。

//定义user结构体
type User struct {
Name string `form:"name"`
}//简洁main函数，把登录handle单独拿出来
func loginHandle(context *gin.Context) {
fullpath := "登录" + context.FullPath()
fmt.Println(fullpath)
var user User
err := context.ShouldBind(&user)
if err != nil {
log.Fatal(err.Error())
return
}
context.Writer.Write([]byte(fullpath + " " + user.Name))
}//删除handle
func deleteHandle(context *gin.Context) {
fullpath := "删除" + context.FullPath()
ID := context.Param("id")
fmt.Println(fullpath + " " + ID)
context.Writer.Write([]byte(fullpath + " " + ID))
}
func main() {
engine := gin.Default() routeGroup := engine.Group("/user")
//注册
routeGroup.POST("/register", func(context *gin.Context) {
fullpath := "注册" + context.FullPath()
fmt.Println(fullpath)
context.Writer.Write([]byte(fullpath))
})
//登录
routeGroup.POST("/login", loginHandle)
//删除
routeGroup.POST("/delete", deleteHandle)
engine.Run()
}