Gin

// 初识 Gin框架
//下载（可能会下载不全。缺什么get什么即可）
//go get -u -v github.com/gin-gonic/gin

package main

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

func main() {

	r := gin.Default()

	r.GET("/", func(c *gin.Context) {

		c.JSON(http.StatusOK, map[string]string{"name": "zjhah"})
	})

	err := r.Run()
	log.Fatalln(err)
	//
}

Gin框架的热加载 realize

// 下载 
go get github.com/oxequa/realize

// 下载之后
realize init 初始化 直接下步一步退出即可 
realize start  就是直接将gin运行起来 进行热加载

• Gin框架—log (Gin 框架 - 使用 logrus 进行日志记录)

约定日志格式字段:

请求时间, 日志级别, 状态码, 执行时间, 请求IP, 请求方式,请求路由

Logrus

API的URL设计规则restful api

1. api有版本信息

/v1/xxxx

/v2/xxx

2.尽可能的使用复数, 含义明确 名词最好

/v1/users

/v1/topics

3.使用GET参数规划数据展现规则

/v1/users

/v1/users?limit=10 //只显示10条

• 路由组

	router := gin.Default()

	r := router.Group("/v1/")  // group组
	r.GET("/", FirstJson)
	r.POST("/", PostTest)
	_ = router.Run(":9000")

• api参数

// 这是api参数

r.GET("/:name", FirstJson)

c.param("name")

• URL参数

?key=xxx & name=xxx

• 表单取文件

r.Post("/v1/:file")

file := c.Formfile("file")

_ := c.saveUploadFile(file, file.FileName)

• 表单上传多个文件

// 设置上传的文件的最大容量
r.MaxMultipartMemory = 8*1024

// 获取多个文件
form, _ := c.MultipartForm()
files := form.File["file"]
然后循环像上边单个存一样

• 接收数据的结构体

package main

import (
	"fmt"
	"github.com/gin-gonic/gin"
	_ "github.com/sirupsen/logrus"
	_ "log"
	"net/http"
)

// 接收数据的结构体
type Option struct {
	User     string `form:"username" json:"username" uri:"user" xml:"user" binding:"required"` // binding必须不能为空
	Password string `form:"password" json:"password" xml:"password" uri:"password"`
}

func main() {

	// 创建路由
	// default 创建的路由默认使用了两个中间件 logger()日志  recovery() 自动恢复
	router := gin.Default()

	// 原生的是这个 是不会使用这两个中间件的
	// router := gin.New()

	router.Use(gin.Logger())
	r := router.Group("/v1")
	{
		
		r.POST("/JsonTest", JsonTest)
	}

	_ = router.Run(":9000")
	//
}

func JsonTest(c *gin.Context) {

	// Bind() 默认解析并绑定form格式
	// 根据请求头中的 content-type 判断数据类型
	var Form Option
	errs := c.Bind(&Form)
	if errs != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": errs.Error()})
	}
	fmt.Println(Form)

	// 声明接收的变量  json绑定
	var jsonData Option

	// 接收到的数据 绑定到jsonData结构体  ShouldBindJSON
	err := c.ShouldBindJSON(&jsonData)
	fmt.Println(jsonData)
	if err != nil {
		// gin.H 封装了生成json数据的工具
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}

	if jsonData.User != "root" || jsonData.Password != "123" {
		c.JSON(http.StatusBadRequest, gin.H{"status_code": "302"})
		return
	}
	c.JSON(http.StatusOK, gin.H{"status": 200})

}

• HTML模版渲染 类似于python render

// 加载模版文件
//	router.LoadHTMLFiles("templates/index.html")
	router.LoadHTMLGlob("templates/*")


// 	返回状态码。返回html渲染文件。返回想要在html文件中所需要的数据
c.HTML("200", "index.html", gin.H{"title": "ccn"})

• 重定向

r.GET("/redirect", Redirects)

func Redirects(c *gin.Context) {
	c.Redirect(http.StatusMovedPermanently, "http://www.taobao.com/")

}

• 同步异步

// 异步
func Async(c *gin.Context) {
	// go routine 机制可以方便的实现异步处理
	// 注意: 在启动新的goroutine时, 不应该使用原始上下文, 必须使用他的只读副本
	copyContent := c.Copy()
	
  // go func 处理的就是要处理的数据之类的 例如上传文件, 修改数据, 添加数据
	go func() {
		time.Sleep(5 * time.Second)
		fmt.Println(copyContent.Request.Method, copyContent.Request.Header, copyContent.Request.RemoteAddr, copyContent.Request.RequestURI)

	}()
	c.JSON(http.StatusOK, gin.H{"name": 123})

}

// 正常的都是同步

• gin中间件

//gin可以构建中间件, 但它只对注册过的路由函数起作用
//对于分组路由, 嵌套使用中间件, 可以限定中间件的作用范围
//中间件分为全局中间件, 单个路由中间件和群组中间件
//gin中间件必须是一个gin.HandlerFun类型


// 全局中间件所有的中间件都会经过

func GinMiddleWare() gin.HandlerFunc {

	return func(c *gin.Context) {
		fmt.Println("中间件开始执行")
		// 设置变量到context的key中, 后边可以通过Get()获取
		c.Set("request", "中间件")
		// 执行router绑定的函数
		c.Next()
    // 执行完中间件后执行的代码
		status := c.Writer.Status()
		fmt.Println(status)
	}
}


c.GET("request")

• gin生成接口文档 swagger
• JSON web token JWT