goalng框架Gin解析

本文通过案例的形式，说明gin框架的基本用法，主要列举后端的案例，前端和相对简单的知识点未在此分析；

过完案例后可以有个基本的印象：就是封装和简便

package main

import (
	"fmt"
	"github.com/gin-gonic/gin"
	"github.com/gin-gonic/gin/binding"
	"github.com/gin-gonic/gin/testdata/protoexample"
	"github.com/go-playground/locales/en"
	"github.com/go-playground/locales/zh"
	"github.com/go-playground/locales/zh_Hant_TW"
	ut "github.com/go-playground/universal-translator"
	"github.com/go-playground/validator/v10"
	en_translations "github.com/go-playground/validator/v10/translations/en"
	zh_translations "github.com/go-playground/validator/v10/translations/zh"
	zh_tw_translations "github.com/go-playground/validator/v10/translations/zh_tw"
	"github.com/gorilla/sessions"
	"io"
	"log"
	"net/http"
	"os"
	"strings"
	"time"
)

func main() {
	JsonTransBind()
}

func Hello() {
	//创建路由
	r := gin.Default()
	//绑定路由规则执行的函数
	//gin.Context 封装了request和response
	r.GET("/", func(c *gin.Context) {
		c.String(http.StatusOK, "Hello World!!!!")
	})
	r.Run("localhost:8080")
}

func GinParam() {
	r := gin.Default()
	r.GET("/user/:name/*action", func(c *gin.Context) {
		name := c.Param("name")

		action := c.Param("action")
		fmt.Println("action:" + action)
		//解析
		action = strings.Trim(action, "/")
		c.String(http.StatusOK, "%s is %s", name, action)
	})
	r.Run(":8080")
}

func UrlParam() {
	r := gin.Default()
	r.GET("/user", func(c *gin.Context) {
		//指定默认值
		name := c.DefaultQuery("name", "gogo")
		c.String(http.StatusOK, "hello  %s", name)
	})
	r.Run(":8080")
}

// 表单参数
func PostForm() {
	r := gin.Default()
	r.POST("/form", func(c *gin.Context) {
		types := c.DefaultPostForm("type", "post")
		username := c.PostForm("username")
		password := c.PostForm("password")
		c.String(http.StatusOK, "%s %s type is %s ", username, password, types)
	})
	r.Run(":8080")
}

// 上传单个文件
func UploadFile() {
	r := gin.Default()

	//限制上传最大尺寸
	r.MaxMultipartMemory = 8 << 20

	r.POST("/upload", func(c *gin.Context) {
		file, err := c.FormFile("file")
		if err != nil {
			c.String(500, "上传图片出错")
		}
		c.SaveUploadedFile(file, file.Filename)
		c.String(http.StatusOK, file.Filename)
	})
	r.Run(":8080")
}

// 上传特定文件
func UploadSpecifyFile() {
	r := gin.Default()
	r.POST("/upload", func(c *gin.Context) {
		_, header, err := c.Request.FormFile("file")
		if err != nil {
			log.Println("Error when try to get file: %v", err)
		}
		//headers.Size 获取文件大小
		if header.Size > 1024*1024*2 {
			fmt.Println("文件太大了")
			return
		}
		//
		if header.Header.Get("Content-Type") != "image/png" {
			fmt.Println("文件格式错误")
			c.String(http.StatusOK, "文件格式错误")
			return
		}
		c.SaveUploadedFile(header, header.Filename)
		c.String(http.StatusOK, header.Filename)

	})
	r.Run(":8080")
}

// Json 数据解析和绑定
// 定义接收数据的结构体
type Login struct {
	// binding:"required"修饰的字段，若接收为空值，则报错，是必须字段
	User    string `form:"username" json:"user" uri:"user" xml:"user" binding:"required"`
	Pssword string `form:"password" json:"password" uri:"password" xml:"password" binding:"required"`
}

func JsonTransBind() {
	r := gin.Default()
	r.POST("/loginJson", func(c *gin.Context) {
		//声明接收的变量
		var json Login
		//将request body中的数据按照JSON格式解析成结构体
		err := c.ShouldBindBodyWithJSON(&json)
		if err != nil {
			//返回错误信息，gin.H封装了生成JSON数据的工具
			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
			return
		}
		//判断用户名密码是否正确
		if json.User != "root" || json.Pssword != "admin" {
			c.JSON(http.StatusBadRequest, gin.H{"status": "304"})
			return
		}
		c.JSON(http.StatusOK, gin.H{"status": "200"})
	})
	r.Run(":8080")
}

// 表单数据解析和绑定
func FormTransBind() {

	r := gin.Default()
	r.POST("/loginForm", func(c *gin.Context) {
		var form Login
		// Bind()默认解析并绑定form格式
		// 根据请求头中content-type自动推断
		err := c.Bind(&form)
		if err != nil {
			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
			return
		}
		if form.User != "root" || form.Pssword != "admin" {
			c.JSON(http.StatusBadRequest, gin.H{"status": "304"})
		}
		c.JSON(http.StatusOK, gin.H{"status": "200"})
	})
	r.Run(":8080")
}

//URI数据解析和绑定

func URIBind() {
	r := gin.Default()
	r.GET("/:user/:password", func(c *gin.Context) {
		//声明接收的变量
		var login Login
		err := c.ShouldBindUri(&login)
		if err != nil {
			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
			return
		}
		if login.User != "root" || login.Pssword != "admin" {
			c.JSON(http.StatusBadRequest, gin.H{"status": "304"})
			return
		}
		c.JSON(http.StatusOK, gin.H{"status": "200"})
	})
	r.Run(":8080")
}

//各种数据格式的响应  json、结构体、XML、YAML类似于java的properties、ProtoBuf

func SomeStructResponse() {
	r := gin.Default()
	//json
	r.GET("/someJson", func(c *gin.Context) {
		c.JSON(200, gin.H{"message": "someJson", "status": 200})
	})
	//结构体响应
	r.GET("/someStruct", func(c *gin.Context) {
		var msg struct {
			Name     string
			Messsage string
			Number   int
		}
		msg.Number = 123
		msg.Messsage = "message"
		msg.Name = "root"
		c.JSON(200, msg)
	})

	//xml 响应
	r.GET("/someXML", func(c *gin.Context) {
		c.XML(200, gin.H{"message": "abc"})
	})
	// YAML响应
	r.GET("/someYAML", func(c *gin.Context) {
		c.YAML(200, gin.H{"name": "zhangsan"})
	})
	// protobuf格式,谷歌开发的高效存储读取的工具
	// 数组？切片？如果自己构建一个传输格式，应该是什么格式？
	r.GET("/someProtoBuf", func(c *gin.Context) {
		reps := []int64{int64(1), int64(2)}
		// 定义数据
		label := "label"
		// 传protobuf格式数据
		data := &protoexample.Test{
			Label: &label,
			Reps:  reps,
		}
		c.ProtoBuf(200, data)
	})
	r.Run(":8080")
}

// 同步异步
func Async() {
	r := gin.Default()
	// 1.异步
	r.GET("/long_async", func(c *gin.Context) {
		// 需要搞一个副本
		copyContext := c.Copy()
		// 异步处理
		go func() {
			time.Sleep(3 * time.Second)
			log.Println("异步执行：" + copyContext.Request.URL.Path)
		}()
	})
	// 2.同步
	r.GET("/long_sync", func(c *gin.Context) {
		time.Sleep(3 * time.Second)
		log.Println("同步执行：" + c.Request.URL.Path)
	})
	r.Run(":8080")
}

// 中间件

// 全局中间件 所有请求都经过此中间件

// 定义中间
func MiddleWare() gin.HandlerFunc {
	return func(c *gin.Context) {
		t := time.Now()
		fmt.Println("中间件开始执行了")
		// 设置变量到Context的key中，可以通过Get()取
		c.Set("request", "中间件")
		status := c.Writer.Status()
		fmt.Println("中间件执行完毕", status)
		t2 := time.Since(t)
		fmt.Println("time:", t2)
	}
}

func GinMiddleWare() {
	r := gin.Default()
	// 注册中间件
	r.Use(MiddleWare())
	{
		r.GET("/ce", func(c *gin.Context) {
			// 取值
			req, _ := c.Get("request")
			fmt.Println("request:", req)
			// 页面接收
			c.JSON(200, gin.H{"request": req})
		})

	}
	r.Run(":8080")
}

//Next()方法

// 定义中间
func MiddleWareNext() gin.HandlerFunc {
	return func(c *gin.Context) {
		t := time.Now()
		fmt.Println("中间件开始执行了")
		// 设置变量到Context的key中，可以通过Get()取
		c.Set("request", "中间件")
		// 执行函数
		c.Next() //跳出此中间件执行，去执行正常的流程回来再继续执行下面的程序
		// 中间件执行完后续的一些事情
		status := c.Writer.Status()
		fmt.Println("中间件执行完毕", status)
		t2 := time.Since(t)
		fmt.Println("time:", t2)
	}
}

func GinMiddleWareNext() {
	r := gin.Default()
	r.Use(MiddleWare())
	{
		{
			r.GET("/ce", func(c *gin.Context) {
				// 取值
				req, _ := c.Get("request")
				fmt.Println("request:", req)
				// 页面接收
				c.JSON(200, gin.H{"request": req})
			})
		}
	}
	r.Run(":8080")
}

// 局部中间件
func MiddleWarePartition() {
	r := gin.Default()
	//局部中间件使用
	r.GET("/ce", MiddleWareNext(), func(c *gin.Context) {
		request, _ := c.Get("request")
		fmt.Println("request:", request)
		c.JSON(200, gin.H{"request": request})
	})
	r.Run(":8080")
}

//中间件练习  定义程序计时中间件，然后定义2个路由，执行函数后应该打印统计的执行时间，如下：

func timeUsed(c *gin.Context) {
	start := time.Now()
	c.Next()
	since := time.Since(start)
	fmt.Println("执行时间：", since)
}

func MiddleWareTest() {
	r := gin.Default()
	r.Use(timeUsed)
	//r.GET("/", func(c *gin.Context) {
	//	shopIndexHandler(c)
	//	shopHomeHandler(c)
	//})
	shoppingGroup := r.Group("/shopping")
	{
		shoppingGroup.GET("/index", shopIndexHandler)
		shoppingGroup.GET("/home", shopHomeHandler)
	}
	r.Run(":8080")
}

func shopIndexHandler(c *gin.Context) {
	time.Sleep(5 * time.Second)
}

func shopHomeHandler(c *gin.Context) {
	time.Sleep(3 * time.Second)
}

// 日志文件
func GinLog() {
	gin.DisableConsoleColor()
	// Logging to a file.
	f, _ := os.Create("gin.log")
	gin.DefaultWriter = io.MultiWriter(f)
	// 如果需要同时将日志写入文件和控制台，请使用以下代码。
	// gin.DefaultWriter = io.MultiWriter(f, os.Stdout)
	r := gin.Default()
	r.GET("/ping", func(c *gin.Context) {
		c.String(200, "pong")
	})
	r.Run(":8080")
}

//参数验证 用gin框架的数据验证，可以不用解析数据，减少if else，会简洁许多

// 结构体验证 与之前的结构体绑定是一样的  注意就是结构体tag写法有区别
// Person ..
type Person struct {
	//不能为空并且大于10
	Age      int       `form:"age" binding:"required,gt=10"`
	Name     string    `form:"name" binding:"required"`
	Birthday time.Time `form:"birthday" time_format:"2006-01-02" time_utc:"1"`
}

func CheckStruct() {
	r := gin.Default()
	r.GET("/struct", func(c *gin.Context) {
		var person Person
		if err := c.ShouldBind(&person); err != nil {
			c.String(500, fmt.Sprint(err))
			return
		}
		c.String(200, fmt.Sprintf("%#v", person))
	})
	r.Run(":8080")
}

//自定义验证
/*
   对绑定解析到结构体上的参数，自定义验证功能
   比如我们要对 name 字段做校验，要不能为空，并且不等于 admin ，类似这种需求，就无法 binding 现成的方法
   需要我们自己验证方法才能实现 官网示例（https://godoc.org/gopkg.in/go-playground/validator.v8#hdr-Custom_Functions）
   这里需要下载引入下 gopkg.in/go-playground/validator.v8
*/
type Person2 struct {
	Age int `form:"age" binding:"required,gt=10"`
	// 2、在参数 binding 上使用自定义的校验方法函数注册时候的名称
	Name    string `form:"name" binding:"NotNullAndAdmin"`
	Address string `form:"address" binding:"required"`
}

// 1、自定义的校验方法
func nameNotNullAndAdmin(fl validator.FieldLevel) bool {
	value := fl.Field().String()
	// 字段不能为空，并且不等于 admin
	return value != "" && value != "test"
}

func CheckSelf() {
	r := gin.Default()
	// 3、将我们自定义的校验方法注册到 validator中
	if v, ok := binding.Validator.Engine().(*validator.Validate); ok {
		// 这里的 key 和 fn 可以不一样最终在 struct 使用的是 key
		v.RegisterValidation("NotNullAndAdmin", nameNotNullAndAdmin)
	}
	/*
	   curl -X GET "http://127.0.0.1:8080/testing?name=&age=12&address=beijing"
	   curl -X GET "http://127.0.0.1:8080/testing?name=lmh&age=12&address=beijing"
	   curl -X GET "http://127.0.0.1:8080/testing?name=adz&age=12&address=beijing"
	*/
	r.GET("/Test", func(c *gin.Context) {
		var person Person
		if e := c.ShouldBind(&person); e == nil {
			c.String(http.StatusOK, "%v", person)
		} else {
			c.String(http.StatusOK, "person bind err:%v", e.Error())
		}
	})
	r.Run(":8080")
}

//多语言翻译验证
/*
当业务系统对验证信息有特殊需求时，
例如：返回信息需要自定义，手机端返回的信息需要是中文而pc端发挥返回的信息需要时英文，
如何做到请求一个接口满足上述三种情况。
*/
var (
	Uni      *ut.UniversalTranslator
	Validate *validator.Validate
)

type User struct {
	Username string `form:"user_name" validate:"required"`
	Tagline  string `form:"tag_line" validate:"required,lt=10"`
	Tagline2 string `form:"tag_line2" validate:"required,gt=1"`
}

func CheckLanguages() {
	en := en.New()
	zh := zh.New()
	zh_tw := zh_Hant_TW.New()
	Uni = ut.New(en, zh, zh_tw)
	Validate = validator.New()

	route := gin.Default()
	route.GET("/gintest", startPage)
	route.POST("/gintest", startPage)
	route.Run(":8080")
}
func startPage(c *gin.Context) {
	//这部分应放到中间件中
	locale := c.DefaultQuery("locale", "zh")
	trans, _ := Uni.GetTranslator(locale)
	switch locale {
	case "zh":
		zh_translations.RegisterDefaultTranslations(Validate, trans)
		break
	case "en":
		en_translations.RegisterDefaultTranslations(Validate, trans)
		break
	case "zh_tw":
		zh_tw_translations.RegisterDefaultTranslations(Validate, trans)
		break
	default:
		zh_translations.RegisterDefaultTranslations(Validate, trans)
		break
	}

	//自定义错误内容
	Validate.RegisterTranslation("required", trans, func(ut ut.Translator) error {
		return ut.Add("required", "{0} must have a value!", true) // see universal-translator for details
	}, func(ut ut.Translator, fe validator.FieldError) string {
		t, _ := ut.T("required", fe.Field())
		return t
	})

	//这块应该放到公共验证方法中
	user := User{}
	c.ShouldBind(&user)
	fmt.Println(user)
	err := Validate.Struct(user)
	if err != nil {
		errs := err.(validator.ValidationErrors)
		sliceErrs := []string{}
		for _, e := range errs {
			sliceErrs = append(sliceErrs, e.Translate(trans))
		}
		c.String(200, fmt.Sprintf("%#v", sliceErrs))
	}
	c.String(200, fmt.Sprintf("%#v", "user"))
}

//会话控制
/*
Cookie介绍
HTTP是无状态协议，服务器不能记录浏览器的访问状态，也就是说服务器不能区分两次请求是否由同一个客户端发出
Cookie就是解决HTTP协议无状态的方案之一，中文是小甜饼的意思
Cookie实际上就是服务器保存在浏览器上的一段信息。浏览器有了Cookie之后，每次向服务器发送请求时都会同时将该信息发送给服务器，服务器收到请求后，就可以根据该信息处理请求
Cookie由服务器创建，并发送给浏览器，最终由浏览器保存
Cookie的用途
测试服务端发送cookie给客户端，客户端请求时携带cookie
*/

/*
Cookie的缺点
不安全，明文
增加带宽消耗
可以被禁用
cookie有上限
*/

//Cookie的使用  服务端发送cookie给客户端，客户端请求时携带cookie

func TestCookie() {
	r := gin.Default()
	r.GET("cookie", func(c *gin.Context) {
		// 获取客户端是否携带cookie
		cookie, err := c.Cookie("key_cookie")
		if err != nil {
			cookie = "NotSet"
			// 给客户端设置cookie
			//  maxAge int, 单位为秒
			// path,cookie所在目录
			// domain string,域名
			//   secure 是否智能通过https访问
			// httpOnly bool  是否允许别人通过js获取自己的cookie
			c.SetCookie("key_cookie", "value_cookie", 60, "/",
				"localhost", false, true)
		}
		fmt.Printf("cookie的值是： %s\n", cookie)
	})
	r.Run(":8080")
}

func AuthMiddleWare() gin.HandlerFunc {
	return func(c *gin.Context) {
		// 获取客户端cookie并校验
		if cookie, err := c.Cookie("abc"); err == nil {
			if cookie == "123" {
				c.Next()
				return
			}
		}
		// 返回错误
		c.JSON(http.StatusUnauthorized, gin.H{"error": "err"})
		// 若验证不通过，不再调用后续的函数处理
		c.Abort()
		return
	}
}

func CookieAuth() {
	r := gin.Default()
	r.GET("/login", func(c *gin.Context) {
		// 设置cookie
		c.SetCookie("abc", "123", 60, "/",
			"localhost", false, true)
		// 返回信息
		c.String(200, "Login success!")
	})
	r.GET("/home", AuthMiddleWare(), func(c *gin.Context) {
		c.JSON(200, gin.H{"data": "home"})
	})
	r.Run(":8080")
}

//Sessions
/*
gorilla/sessions为自定义session后端提供cookie和文件系统session以及基础结构。
主要功能是：
简单的API：将其用作设置签名（以及可选的加密）cookie的简便方法。
内置的后端可将session存储在cookie或文件系统中。
Flash消息：一直持续读取的session值。
切换session持久性（又称"记住我"）和设置其他属性的便捷方法。
旋转身份验证和加密密钥的机制。
每个请求有多个session，即使使用不同的后端也是如此。
自定义session后端的接口和基础结构：可以使用通用API检索并批量保存来自不同商店的session。
*/

// 初始化一个cookie存储对象
// something-very-secret应该是一个你自己的密匙，只要不被别人知道就行
var store = sessions.NewCookieStore([]byte("something-very-secret"))

func GinSession() {
	http.HandleFunc("/save", SaveSession)
	http.HandleFunc("/get", GetSession)
	err := http.ListenAndServe(":8080", nil)
	if err != nil {
		fmt.Println("HTTP server failed,err:", err)
		return
	}
}

func SaveSession(w http.ResponseWriter, r *http.Request) {
	// Get a session. We're ignoring the error resulted from decoding an
	// existing session: Get() always returns a session, even if empty.

	//　获取一个session对象，session-name是session的名字
	session, err := store.Get(r, "session-name")
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	// 在session中存储值
	session.Values["foo"] = "bar"
	session.Values[42] = 43
	// 保存更改
	session.Save(r, w)

	// 删除
	// 将session的最大存储时间设置为小于零的数即为删除
	//session.Options.MaxAge = -1
	//session.Save(r, w)
}
func GetSession(w http.ResponseWriter, r *http.Request) {
	session, err := store.Get(r, "session-name")
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	foo := session.Values["foo"]
	fmt.Println(foo)
}