Gin框架入门

淡淡的烟草味﹌ 2023-02-14 01:22 206阅读 0赞

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4OTAwNTY1_size_16_color_FFFFFF_t_70_pic_center]  
环境：  
vscode,go1.14.3,gin1.4.0,

[root@go ~]# cat /etc/profile|tail -5
    # go enviroment
    export GOROOT=/usr/local/go
    export GOPATH=~/golib:~/goproject
    export GOBIN=~/gobin
    export PATH=$PATH:$GOROOT/bin:$GOBIN

**一、安装Gin及快速开始**  
**1.1 安装及环境配置**

[root@go ~]# mkdir $GOPATH/src/github/jstang007/gin_test_project
    [root@go ~]# cd $GOPATH/src/github/jstang007/gin_test_project 
    [root@go gin_test_project]# export GO111MODULE=on #开启go module环境变量 
    [root@go gin_test_project]# go mod init 
    [root@go gin_test_project]# go get -v github.com/gin-goniv/gin@v1.4

**1.2 快速启动**

[root@go gin_test_project]# mkdir start
    [root@go gin_test_project]# touch start/main.go
    [root@go gin_test_project]# vim start/main.go

package main
    import "github.com/gin-gonic/gin"
    func main() { 
    	r := gin.Default()
    	r.GET("/ping", func(c *gin.Context) { 
    		c.JSON(200, gin.H{ 
    			"message": "pong",
    		})
    	})
    	r.Run() // listen and serve on 0.0.0.0:8080
    }

[root@go gin_test_project]# go run start/main.go
    [root@go gin_test_project]# curl -X GET 127.0.0.1:8080/ping
    pong

--------------------

**二、请求路由**  
**2.1 设置多种请求类型**  
在项目目录下创建route\_type/main.go文件，并编辑

package main
    import "github.com/gin-gonic/gin"
    func main() { 
    	r := gin.Default()
    	r.GET("/get", func(c *gin.Context) { 
    		c.String(200, "GET")
    	})
    	r.POST("/post", func(c *gin.Context) { 
    		c.String(200, "post")
    	})
    	r.Handle("DELETE", "/delete", func(c *gin.Context) { 
    		c.String(200, "delete")
    	})
    	r.Any("/any", func(c *gin.Context) {  //支持get\post\del\put\alter
    		c.String(200, "any")
    	})
    	r.Run()
    }

测试：

[root@go gin_test_project]# curl -X DELETE127.0.0.1:8080/delete
    delete
    [root@go gin_test_project]# curl -X PUT 127.0.0.1:8080/any
    any

**2.2 绑定静态文件夹**  
创建文件夹route\_static，该文件夹树形结构：

- route_static
    	- accets
       		a.html
    	- static
       		b.html
    	favicon.ico
    	main.go

编辑main.go文件

package main
    import (
    	"net/http"
    	"github.com/gin-gonic/gin"
    )
    func main() { 
    	r := gin.Default()
    	r.Static("/accets", "./accets")
    	r.StaticFS("/static", http.Dir("static"))
    	r.StaticFile("/favicon.ico", "./favicon.ico") //设置单个静态文件
    	r.Run()
    }

**2.3 参数作为URI**  
创建目录route\_uri，route\_uri/main.go

package main
    import "github.com/gin-gonic/gin"
    func main() { 
    	r := gin.Default()
    	r.GET("/:name/:id", func(c *gin.Context) { 
    		c.JSON(200, gin.H{ 
    			"name": c.Param("name"), //value -key
    			"id":   c.Param("id"),  //末尾一定要由逗号
    		})
    	})
    	r.Run()
    } //http://192.168.27.145:8080/golang/1

**2.4 泛绑定**  
创建route\_generic目录和route\_generic/main.go文件

package main
    
    import "github.com/gin-gonic/gin"
    
    func main() { 
    	r := gin.Default()
    	r.GET("/user/*action", func(c *gin.Context) { 
    		c.String(200, "hello world")
    	})
    	r.Run()
    } //http://192.168.27.145:8080/user/111
    //http://192.168.27.145:8080/user/xxx

**三、获取请求参数**  
**3.1 获取GET的请求参数**  
创建param\_get文件夹和param\_get/main.go文件

package main
    import (
    	"net/http"
    	"github.com/gin-gonic/gin"
    )
    func main() { 
    	r := gin.Default()
    	r.GET("/test", func(c *gin.Context) { 
    		firstName := c.Query("first_name")                           //key
    		lastName := c.DefaultQuery("last_name", "last_default_name") //key, 默认value
    		c.String(http.StatusOK, "%s, %s", firstName, lastName)
    	})
    	r.Run()
    } //http://192.168.27.145:8080/test?first_name=xxx&last_name=yyy
    //http://192.168.27.145:8080/test?first_name=xxx

**3.2 获取POST的请求**  
创建param\_post文件夹和param\_post/main.go文件

package main
    import (
    	"net/http"
    	"github.com/gin-gonic/gin"
    )
    func main() { 
    	r := gin.Default()
    	r.POST("/test", func(c *gin.Context) { 
    		firstName := c.DefaultPostForm("first_name","golang")//key, 默认value
    		lastName := c.PostFrom("last_name")
    		c.String(http.StatusOK, "%s, %s", firstName, lastName)
    	})
    	r.Run()
    }//curl -X POST 127.0.0.1:8080/test?first_name=xxx

**3.3 获取Body请求参数**

package main
    import (
    	"bytes"
    	"io/ioutil"
    	"net/http"
    	"github.com/gin-gonic/gin"
    )
    func main() { 
    	r := gin.Default()
    	r.POST("/test", func(c *gin.Context) { 
    		bodyBytes, err := ioutil.ReadAll(c.Request.Body)
    		if err != nil { 
    			c.String(http.StatusBadRequest, err.Error())
    			c.Abort()
    		}
    		//调用完read之后，PostFrom里数值被清空，需要重新写入到c.Request.Body
    		c.Request.Body = ioutil.NopCloser(bytes.NewBuffer(bodyBytes))
    		firstName := c.PostForm("first_name")
    		lastName := c.DefaultPostForm("last_name", "last_default_name")
    		c.String(http.StatusOK, "%s, %s, %s", firstName, lastName, string(bodyBytes))
    	})
    	r.Run()
    } // curl -X POST 127.0.0.1:8080/test -d '{"name":"golang"}'
    //curl -X POST "127.0.0.1:8080/test" -d 'first_name=xxx&last_name=yyy'
    //xxx, yyy, first_name=xxx&last_name=yyy

**3.4 获取参数bind绑定结构**

package main
    import (
    	"fmt"
    	"time"
    	"github.com/gin-gonic/gin"
    )
    //Person 人
    type Person struct { 
    	Name     string    `form:"name"`
    	Address  string    `form:"address"`
    	Birthday time.Time `form:"birthday" time_format:"2006-01-02"`
    }
    func main() { 
    	r := gin.Default()
    	r.GET("/testing", testing)
    	r.POST("/testing", testing)
    	r.Run()
    }
    func testing(c *gin.Context) { 
    	var person Person
    	//这里是根据请求content-type来做不同的binding操作
    	if err := c.ShouldBind(&person); err == nil { 
    		fmt.Printf("====%v====", person)
    		c.String(200, "%v", person)
    	} else { 
    		c.String(200, "<bind error>:%v", err.Error())
    	}
    }
    //curl -X GET "http://127.0.0.1:8080/testing?name=xxx&address=China&birthday=2000-04-25"
    //{xxx China 2000-04-25 00:00:00 +0800 CST}
    //curl -X POST 127.0.0.1:8080/testing -d "name=jack&address=China&birthday=2020-02-02"
    //{jack China 2020-02-02 00:00:00 +0800 CST}
    //curl -H "Content-type:application/json" -X POST 127.0.0.1:8080/testing -d '{"name":"rose","address":"US"}'
    //{rose US}

--------------------

**四、验证请求参数**  
获取的参数是否合法，如何定义验证规则  
**4.1 结构体binding验证**

package main
    import "github.com/gin-gonic/gin"
    //Person A
    type Person struct { 
    	Age     int    `form:"age" binding:"required,gt=10"`
    	Name    string `form:"name" binding:"required"`
    	Address string `form:"address" binding:"required"`
    }
    func main() { 
    	r := gin.Default()
    	r.GET("/testing", func(c *gin.Context) { 
    		var person Person
    		if err := c.ShouldBind(&person); err != nil { 
    			c.String(500, "%v", err.Error())
    			c.Abort()
    			return
    		}
    		c.String(200, "%v", person)
    	})
    	r.Run()
    }
    
    // curl -X GET "http://127.0.0.1:8080/testing?age=11&name=knho&address=cn"
    //{11 knho cn}
    // curl -X GET "http://127.0.0.1:8080/testing?age=10&name=knho&address=cn"
    //Key: 'Person.Age' Error:Field validation for 'Age' failed on the 'gt' tag{10 knho cn}
    // curl -X GET "http://127.0.0.1:8080/testing?age=12&name=knho"
    //Key: 'Person.Address' Error:Field validation for 'Address' failed on the 'required' tag
    //https://godoc.org/gopkg.in/go-playground/validator.v8

**4.2 自定义验证**

package main
    import (
    	"net/http"
    	"reflect"
    	"time"
    	"gopkg.in/go-playground/validator.v8"
    
    	"github.com/gin-gonic/gin"
    	"github.com/gin-gonic/gin/binding"
    )
    //Booking x
    type Booking struct { 
    	CheckIn  time.Time `form:"check_in" binding:"required,bookabledate" time_format:"2006-01-02"`
    	CheckOut time.Time `form:"check_out" binding:"required,gtfield=CheckIn" time_format:"2006-01-02"`
    }
    
    func bookableDate(
    	v *validator.Validate, topStruct reflect.Value, currentStructOrField reflect.Value,
    	field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string,
    ) bool { 
    	if date, ok := field.Interface().(time.Time); ok { 
    		today := time.Now()
    		if today.Unix() > date.Unix() { 
    			return false
    		}
    	}
    	return true
    }
    func main() { 
    	r := gin.Default()
    	if v, ok := binding.Validator.Engine().(*validator.Validate); ok { 
    		v.RegisterValidation("bookabledate", bookableDate)
    	}
    	r.GET("/bookable", getBookable)
    	r.Run()
    }
    func getBookable(c *gin.Context) { 
    	var b Booking
    	if err := c.ShouldBindWith(&b, binding.Query); err == nil { 
    		c.JSON(http.StatusOK, gin.H{ "message": "Booking dates are valid!"})
    	} else { 
    		c.JSON(http.StatusBadRequest, gin.H{ "error": err.Error()})
    	}
    }
    
    //1、当check_in是未来日期，并比check_out早时
    // curl -X GET "127.0.0.1:8080/bookable?check_in=2020-07-01&check_out=2020-07-08"
    // {"message":"Booking dates are valid!"}
    //2、当check_in是未来日期，并比check_out晚时
    //curl -X GET "127.0.0.1:8080/bookable?check_in=2020-07-09&check_out=2020-07-08"
    // {"error":"Key: 'Booking.CheckOut' Error:Field validation for 'CheckOut' failed on the 'gtfield' tag"}
    //3、当check_in是已过日期
    //curl -X GET "127.0.0.1:8080/bookable?check_in=2020-05-09&check_out=2020-07-08"
    // {"error":"Key: 'Booking.CheckIn' Error:Field validation for 'CheckIn' failed on the 'bookabledate' tag"}

**4.3 支持多语言错误信息**

package main
    import (
    	"github.com/gin-gonic/gin"
    	"github.com/go-playground/locales/en"
    	"github.com/go-playground/locales/zh"
    	ut "github.com/go-playground/universal-translator"
    	"gopkg.in/go-playground/validator.v9"
    	en_translations "gopkg.in/go-playground/validator.v9/translations/en"
    	zh_translations "gopkg.in/go-playground/validator.v9/translations/zh"
    )
    // Person x
    type Person struct { 
    	Age     int    `form:"age" validate:"required,gt=10"`
    	Name    string `form:"name" validate:"required"`
    	Address string `form:"address" validate:"required"`
    }
    // ut
    var (
    	Uni      *ut.UniversalTranslator
    	Validate *validator.Validate
    )
    //验证信息多语言化
    func main() { 
    	Validate = validator.New() //创建验证器
    	en := en.New()
    	zh := zh.New()
    	Uni = ut.New(zh, en) //创建翻译器
    	r := gin.Default()
    	r.GET("/test", startPage)
    	r.POST("/test", startPage)
    	r.Run()
    }
    func startPage(c *gin.Context) { 
    	locale := c.DefaultQuery("locale", "zh") //获取uri中locale的值
    	trans, _ := Uni.GetTranslator(locale)    //在翻译器中挑选locale
    	switch locale { 
    	case "zh":
    		zh_translations.RegisterDefaultTranslations(Validate, trans) //将对应翻译器注册到验证器中
    	case "en":
    		en_translations.RegisterDefaultTranslations(Validate, trans)
    	default:
    		zh_translations.RegisterDefaultTranslations(Validate, trans)
    	}
    	var person Person
    	if err := c.ShouldBind(&person); err != nil {  //绑定结构体
    		c.String(500, "%v\n", err.Error())
    		c.Abort()
    		return
    	}
    	if err := Validate.Struct(person); err != nil {  //验证结构体
    		errs := err.(validator.ValidationErrors)
    		sliceErrs := []string{ }
    		for _, e := range errs { 
    			sliceErrs = append(sliceErrs, e.Translate(trans))
    		}
    		c.String(500, "%v\n", sliceErrs)
    		c.Abort()
    		return
    	}
    	c.String(200, "%v\n", person)
    }

--------------------

**五、中间件**  
基于gin服务器和执行的回调函数的中间层，可以作为请求拦截、日志打印等功能  
**5.1 使用Gin中间件**

package main
    import (
    	"io"
    	"os"
    	"github.com/gin-gonic/gin"
    )
    func main() { 
    	f, _ := os.Create("gin.log")
    	gin.DefaultWriter = io.MultiWriter(f)
    	gin.DefaultErrorWriter = io.MultiWriter(f)
    	r := gin.New()                      //default默认实现两个中间件: Logger+Recovery
    	r.Use(gin.Logger(), gin.Recovery()) //设置中间件
    	r.GET("/test", func(c *gin.Context) { 
    		name := c.DefaultQuery("name", "middleware_gin")
    		panic("主动触发错误\n") //没有使用Recovery中间间将会死掉服务, Recovery会捕获错误,让服务不至于挂掉
    		c.String(200, "%s", name)
    	})
    	r.Run()
    }

**5.2 自定义ip白名单中间件**

package main
    import "github.com/gin-gonic/gin"
    //IPAuthMiddleware x
    func IPAuthMiddleware() gin.HandlerFunc { 
    	return func(c *gin.Context) { 
    		ipList := []string{ "127.0.0.1"}
    		flag := false
    		clientIP := c.ClientIP()
    		for _, host := range ipList { 
    			if clientIP == host { 
    				flag = true
    				break
    			}
    		}
    		if !flag { 
    			c.String(401, "%s, not in iplist", clientIP)
    			c.Abort()
    		}
    	}
    }
    func main() { 
    	r := gin.Default()
    	r.Use(IPAuthMiddleware())
    	r.GET("/test", func(c *gin.Context) { 
    		c.String(200, "golang")
    	})
    	r.Run()
    }
    //curl -X GET "http://192.168.27.145:8080/test"
    // 192.168.27.145, not in iplist
    //curl -X GET "http://127.0.0.1:8080/test"
    //golang

--------------------

**六、其他补充**  
**6.1 优雅关停**  
指服务停止时，如果请求未处理完毕，会有一个超时等待时间，去完成后续的处理，保证服务不在中间中断停止  
原始服务器关闭和优雅关闭区别：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4OTAwNTY1_size_16_color_FFFFFF_t_70_pic_center 1]

package main
    import (
    	"context"
    	"log"
    	"net/http"
    	"os"
    	"os/signal"
    	"syscall"
    	"time"
    
    	"github.com/gin-gonic/gin"
    )
    func main() { 
    	r := gin.Default()
    	r.GET("test", func(c *gin.Context) { 
    		time.Sleep(10 * time.Second)
    		c.String(200, "golang")
    	})
    	srv := &http.Server{ 
    		Addr:    ":8085",
    		Handler: r,
    	}
    	go func() {  //将srv放入协程
    		if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed { 
    			log.Fatalf("listen: %s\n", err)
    		}
    	}()
    	quit := make(chan os.Signal)
    	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM) //无法捕获kill -9
    	<-quit                                               //一直等待关闭
    	log.Println("shutdown server ...")
    
    	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
    	defer cancel() //直到cancel方法执行完
    	if err := srv.Shutdown(ctx); err != nil { 
    		log.Fatalf("server shutdown:", err)
    	}
    	log.Println("server exiting")
    }

访问url后立即结束服务(ctrl+c)  
**6.2 模板渲染**

目录:
    - teamplate_drawing
    	- teamplate
    		index.html
      	main.go

package main
    import "github.com/gin-gonic/gin"
    func main() { 
    	r := gin.Default()
    	r.LoadHTMLGlob("teamplate/*") //将模板文件夹载入到gin框架
    	r.GET("/", func(c *gin.Context) { 
    		c.HTML(200, "index.html", gin.H{ 
    			"title": "index.html",
    		})
    	})
    	r.Run()
    }

**6.3 自动证书配置**  
指无需配置任何证书，即可自动下载证书，过期自动续约的功能

package main
    
    import "github.com/gin-gonic/gin"
    
    /* * 废弃 engine := gin.Default() //证书位置使用的是相对路径 _ = http.ListenAndServeTLS(":443", "cert/www.domain.cn.crt", "cert/www.domain.cn.key", engine) */
    func main() { 
    	r := gin.Default()
    	r.GET("/test", func(c *gin.Context) { 
    		c.String(200, "golang")
    	})
    	autotls.Run(r, "zan71.com")
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4OTAwNTY1_size_16_color_FFFFFF_t_70_pic_center]: https://img-blog.csdnimg.cn/20200530104914221.PNG?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4OTAwNTY1,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4OTAwNTY1_size_16_color_FFFFFF_t_70_pic_center 1]: https://img-blog.csdnimg.cn/20200530195715782.PNG?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4OTAwNTY1,size_16,color_FFFFFF,t_70#pic_center