乘风原创程序

  • Gin框架介绍与使用
  • 2021/7/2 9:12:08
  • 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
    • 令牌桶 漏桶