[golang gin框架] 1.Gin环境搭建,程序的热加载,路由GET,POST,PUT,DELETE

一.Gin 介绍

Gin 是一个 Go (Golang) 编写的轻量级 http web 框架，运行速度非常快，如果你是性能和高效的追求者，推荐你使用 Gin 框架.
Gin 最擅长的就是 Api 接口的高并发，如果项目的规模不大，业务相对简单，这个时候
也推荐使用 Gin.
当某个接口的性能遭到较大挑战的时候，这个还是可以考虑使用 Gin 重写接口.
Gin 也是一个流行的 golang Web 框架，Github Strat 量已经超过了 50k.
Gin 的官网： https://gin-gonic.com/zh-cn/
Gin Github 地址： https://github.com/gin-gonic/gin

二.Gin 环境搭建

要安装 Gin 软件包，需要先安装 Go 并设置 Go 工作区

1. 下载并安装 gin

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

由于网络原因国内部分用户可能没法直接下载第三方包,go get 失败,Golang Gin中没法下载第三方包解决办法如下:

1.  
   //打开终端并执行
2.  
   go env -w GO111MODULE=on
3.  
   go env -w GOPROXY=https://goproxy.cn,direct

2.将 gin 引入到代码中

import "github.com/gin-gonic/gin"

3. 如果使用诸如 http.StatusOK 之类的常量，则需要引入 net/http 包

import "net/http"

4.新建main.go配置路由

1.  
   package main
2.  
    
3.  
   import (
4.  
       "github.com/gin-gonic/gin"
5.  
       "net/http"
6.  
   )
7.  
    
8.  
   func main() {
9.  
   // 创建gin的默认路由引擎
10.  
    r := gin.Default()
11.  
    // 配置路由
12.  
    r.GET("/", func(c *gin.Context) {
13.  
            c.JSON(200, gin.H{ // c.JSON：返回 JSON 格式的数据
14.  
            "message": "Hello world!", })
15.  
        })
16.  
     
17.  
    // 浏览器访问请求127.0.0.1:8080/ping路由时,调用回调函数
18.  
    r.GET("/ping", func(c *gin.Context) {
19.  
            //浏览器输出
20.  
            //c.JSON(200, gin.H{
21.  
            // "message": "pong",
22.  
            //})
23.  
            c.String(http.StatusOK, "值:%v", "你好")
24.  
        })
25.  
     
26.  
    //监听并在 0.0.0.0:8080 上启动服务(启动一个web服务)
27.  
    r.Run()
28.  
    // 监听并在 0.0.0.0:8000 上启动服务(启动一个web服务)
29.  
    //r.Run("8000")
30.  
    }

5.运行项目

go run main.go

6.要改变默认启动的端口

r.Run(":9000")

三.golang程序的热加载

所谓热加载就是当对代码进行修改时，程序能够自动重新加载并执行，这在开发中
是非常便利的，可以快速进行代码测试，省去了每次手动重新编译,beego 中可以使用官方给提供bee工具来热加载项目，但是 gin 中并没有官方提供的热加载工具，这个时候要实现热加载就可以借助第三方的工具

工具 1（推荐）：https://github.com/gravityblast/fresh

1.  
   //进入终端执行
2.  
   go get github.com/pilu/fresh
3.  
   //然后运行命令
4.  
   fresh
5.  
    
6.  
   //或者进入终端执行
7.  
   go install github.com/pilu/fresh@latest
8.  
   //然后运行命令
9.  
   fresh

工具 2：https://github.com/codegangsta/gin

1.  
   //进入终端执行
2.  
   go get -u github.com/codegangsta/gin
3.  
   //然后运行命令
4.  
   gin run main.go

四.Gin框架中的路由

1.路由概述

路由（Routing）是由一个 URI（或者叫路径）和一个特定的 HTTP 方法（GET、POST 等）
组成的，涉及到应用如何响应客户端对某个网站节点的访问 ,RESTful API 是目前比较成熟的一套互联网应用程序的 API 设计理论，所以在设计路由的时候建议参考 RESTful API 指南,在 RESTful 架构中，每个网址代表一种资源，不同的请求方式表示执行不同的操作：

1. 简单的路由配置

当用 GET 请求访问一个网址的时候

1.  
   r.GET("网址", func(c *gin.Context) {
2.  
       c.String(200, "Get")
3.  
   })

当用 POST 访问一个网址的时候

1.  
   r.POST("网址", func(c *gin.Context) {
2.  
       c.String(200, "POST")
3.  
   })

当用 PUT 访问一个网址的时候

1.  
   r.PUT("网址", func(c *gin.Context) {
2.  
       c.String(200, "PUT")
3.  
   })

当用 DELETE 访问一个网址的时候

1.  
   r.DELETE("网址", func(c *gin.Context) {
2.  
       c.String(200, "DELETE")
3.  
   })

路由里面获取 Get 传值

1.  
   // 域名/news?aid=20
2.  
   r.GET("/news", func(c *gin.Context) {
3.  
       aid := c.Query("aid")
4.  
       c.String(200, "aid=%s", aid)
5.  
   })

动态路由

1.  
   // 域名/user/20
2.  
   r.GET("/user/:uid", func(c *gin.Context) {
3.  
       uid := c.Param("uid")
4.  
       c.String(200, "userID=%s", uid)
5.  
   })

完整的代码案例如下:

1.  
   package main
2.  
    
3.  
   import (
4.  
   _ "fmt"
5.  
   "github.com/gin-gonic/gin"
6.  
   "net/http"
7.  
   )
8.  
    
9.  
   func main() {
10.  
    r := gin.Default() // 创建gin的默认路由引擎
11.  
    //配置路由
12.  
    // 浏览器访问请求127.0.0.1:8080/ping路由时,调用回调函数
13.  
    r.GET("/ping", func(c *gin.Context) {
14.  
    //浏览器输出
15.  
    //c.JSON(200, gin.H{
16.  
    // "message": "pong",
17.  
    //})
18.  
    c.String(http.StatusOK, "值:%v", "你好")
19.  
    })
20.  
    r.GET("/news", func(c *gin.Context) {
21.  
    //使用http.StatusOK状态码
22.  
    c.String(http.StatusOK, "新闻页11面")
23.  
    })
24.  
    r.POST("/add", func(c *gin.Context) {
25.  
    c.String(200, "这是一个POST请求,主要用于增加数据")
26.  
    })
27.  
    r.PUT("/edit", func(c *gin.Context) {
28.  
    c.String(200, "这是一个PUT请求,主要用于修改数据")
29.  
    })
30.  
    r.DELETE("/delete", func(c *gin.Context) {
31.  
    c.String(200, "这是一个DELETE请求,主要用于增删除数据")
32.  
    })
33.  
    r.Run() // 监听并在 0.0.0.0:8080 上启动服务(启动一个web服务)
34.  
    }

3.c.String() c.JSON() c.JSONP() c.XML() c.HTML()

返回一个字符串

1.  
   r.GET("/news", func(c *gin.Context) {
2.  
       aid := c.Query("aid")
3.  
       c.String(200, "aid=%s", aid)
4.  
   })

返回一个 JSON 数据

1.  
       //方法一:自己拼接JSON
2.  
       r.GET("/json", func(c *gin.Context) {
3.  
   //返回json数据,使用 map[string]interface
4.  
   //c.JSON(返回的状态码, 任意类型的数据(如:map,struct,...)
5.  
   c.JSON(200, map[string]interface{}{
6.  
   "success": true,
7.  
   "msg": "你好",
8.  
   })
9.  
   })
10.  
        //方法二:gin中的H函数
11.  
    r.GET("/json2", func(c *gin.Context) {
12.  
    //返回json数据,使用gin中的H函数, gin.H 是 map[string]interface{}的缩写
13.  
    c.JSON(200, gin.H{
14.  
    "success": true,
15.  
    "msg": "你好gin",
16.  
    })
17.  
    })
18.  
        //方法三:使用结构体
19.  
    r.GET("/json3", func(c *gin.Context) {
20.  
    //实例化一个结构体
21.  
    a := &Article{
22.  
    Title: "标题",
23.  
    Desc: "说明",
24.  
    Content: "内容",
25.  
    }
26.  
    c.JSON(200, a)
27.  
    })

JSOPN: jsonp请求 主要用来解决跨域问题

1.  
       //jsonp请求 主要用来解决跨域问题
2.  
   //http://127.0.0.1:8080/jsonp?callback=call
3.  
   //call({"title":"标题-jsonp","desc":"说明-jsonp","content":"内容-jsonp"});
4.  
   r.GET("/jsonp", func(c *gin.Context) {
5.  
   //实例化一个结构体
6.  
   a := &Article{
7.  
   Title: "标题-jsonp",
8.  
   Desc: "说明-jsonp",
9.  
   Content: "内容-jsonp",
10.  
    }
11.  
    c.JSONP(200, a)
12.  
    })

返回 XML 数据

1.  
       //方法一:使用gin.H返回
2.  
       r.GET("/xml", func(c *gin.Context) {
3.  
   c.XML(http.StatusOK, gin.H{
4.  
   "success": true,
5.  
   "msg": "成功xml",
6.  
   })
7.  
   })
8.  
       //方法二:使用结构体
9.  
       r.GET("/xmlStruct", func(c *gin.Context) {
10.  
    //实例化一个结构体
11.  
    a := &Article{
12.  
    Title: "标题-xmlStruct",
13.  
    Desc: "说明-xmlStruct",
14.  
    Content: "内容-xmlStruct",
15.  
    }
16.  
    c.XML(200, a)
17.  
    })

返回HTML数据

1.  
     //初始化路由
2.  
   r := gin.Default()
3.  
       //加载templates文件中所有模板文件,以便后续c.HTML()渲染文件时使用
4.  
   r.LoadHTMLGlob("templates/*")
5.  
       r.GET("/news", func(c *gin.Context) {
6.  
   //使用模板文件渲染HTML文件
7.  
   //前提: r.LoadHTMLGlob("templates/*")
8.  
   //HTML(状态码, 要渲染的文件名, 加载的参数)
9.  
   c.HTML(http.StatusOK, "news.html", gin.H{
10.  
    "title": "我是一个news",
11.  
    })
12.  
    })

完整代码案例如下:

1.  
   package main
2.  
    
3.  
   import (
4.  
   "github.com/gin-gonic/gin"
5.  
   "net/http"
6.  
   )
7.  
    
8.  
   type Article struct {
9.  
   Title string `json:"title"`
10.  
    Desc string `json:"desc"`
11.  
    Content string `json:"content"`
12.  
    }
13.  
     
14.  
    func main() {
15.  
    //初始化路由
16.  
    r := gin.Default()
17.  
    //加载templates文件中所有模板文件,以便后续c.HTML()渲染文件时使用
18.  
    r.LoadHTMLGlob("templates/*")
19.  
    //配置路由
20.  
    r.GET("/", func(c *gin.Context) {
21.  
    c.String(200, "首页")
22.  
    })
23.  
    r.GET("/json", func(c *gin.Context) {
24.  
    //返回json数据,使用 map[string]interface
25.  
    //c.JSON(返回的状态码, 任意类型的数据(如:map,struct,...)
26.  
    c.JSON(200, map[string]interface{}{
27.  
    "success": true,
28.  
    "msg": "你好",
29.  
    })
30.  
    })
31.  
    r.GET("/json2", func(c *gin.Context) {
32.  
    //返回json数据,使用gin中的H函数
33.  
    c.JSON(200, gin.H{
34.  
    "success": true,
35.  
    "msg": "你好gin",
36.  
    })
37.  
    })
38.  
    r.GET("/json3", func(c *gin.Context) {
39.  
    //实例化一个结构体
40.  
    a := &Article{
41.  
    Title: "标题",
42.  
    Desc: "说明",
43.  
    Content: "内容",
44.  
    }
45.  
    c.JSON(200, a)
46.  
    })
47.  
    //jsonp请求 主要用来解决跨域问题
48.  
    //http://127.0.0.1:8080/jsonp?callback=call
49.  
    //call({"title":"标题-jsonp","desc":"说明-jsonp","content":"内容-jsonp"});
50.  
    r.GET("/jsonp", func(c *gin.Context) {
51.  
    //实例化一个结构体
52.  
    a := &Article{
53.  
    Title: "标题-jsonp",
54.  
    Desc: "说明-jsonp",
55.  
    Content: "内容-jsonp",
56.  
    }
57.  
    c.JSONP(200, a)
58.  
    })
59.  
    r.GET("/xml", func(c *gin.Context) {
60.  
    c.XML(http.StatusOK, gin.H{
61.  
    "success": true,
62.  
    "msg": "成功xml",
63.  
    })
64.  
    })
65.  
    r.GET("/news", func(c *gin.Context) {
66.  
    //使用模板文件渲染HTML文件
67.  
    //前提: r.LoadHTMLGlob("templates/*")
68.  
    //HTML(状态码, 要渲染的文件名, 加载的参数)
69.  
    c.HTML(http.StatusOK, "news.html", gin.H{
70.  
    "title": "我是一个news",
71.  
    })
72.  
    })
73.  
    r.GET("/goods", func(c *gin.Context) {
74.  
    //使用模板文件渲染HTML文件
75.  
    //前提: r.LoadHTMLGlob("templates/*")
76.  
    //HTML(状态码, 要渲染的文件名, 加载的参数)
77.  
    c.HTML(http.StatusOK, "goods.html", gin.H{
78.  
    "title": "我是一个goods",
79.  
    "price": 12.99,
80.  
    })
81.  
    })
82.  
    r.Run() // 启动一个web服务
83.  
    }

[下一节][golang gin框架] 2.Gin HTML模板渲染以及模板语法,自定义模板函数,静态文件服务