GO语言GIN框架入门

Gin框架介绍

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

Gin框架安装与使用

安装GIN

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

第一个Gin程序

package main

import "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()

}