Gin框架（下）

最新推荐文章于 2023-10-29 11:41:29 发布

~庞贝

最新推荐文章于 2023-10-29 11:41:29 发布

阅读量590

点赞数 1

分类专栏： Golang Web 文章标签： golang 开发语言

本文链接：https://blog.csdn.net/qq_53267860/article/details/123024477

版权

Golang Web 专栏收录该内容

17 篇文章 1 订阅

订阅专栏

Gin文件上传

单个文件上传

文件上传前端页面代码：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>index</title>
</head>
<body>
    <form action="/upload" method="post" enctype="multipart/form-data">
        <input type="file" name="f1">
        <input type="submit" value="上传">
    </form>
</body>
</html>

后端gin框架部分代码：

package main

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

func main() {
   r := gin.Default()
   r.LoadHTMLFiles("./index.html")
   r.GET("/index", func(c *gin.Context) {
      c.HTML(http.StatusOK, "index.html", nil)
   })

   r.POST("/upload", func(c *gin.Context) {
      //从请求中读取文件
      f, err := c.FormFile("f1")
      if err != nil {
         c.JSON(http.StatusBadRequest, gin.H{
            "error": err.Error(),
         })
      } else {
         //将读取到的文件保存到本地（服务器本地）
         //dst := fmt.Sprintf("./%s", f.Filename)
         dst := path.Join("./", f.Filename)
         c.SaveUploadedFile(f, dst)
         c.JSON(http.StatusOK, gin.H{
            "status": "ok",
         })
      }

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

多个文件上传

func main() {
	router := gin.Default()
	// 处理multipart forms提交文件时默认的内存限制是32 MiB
	// 可以通过下面的方式修改
	// router.MaxMultipartMemory = 8 << 20  // 8 MiB
	router.POST("/upload", func(c *gin.Context) {
		// Multipart form
		form, _ := c.MultipartForm()
		files := form.File["file"]

		for index, file := range files {
			log.Println(file.Filename)
			dst := fmt.Sprintf("C:/tmp/%s_%d", file.Filename, index)
			// 上传文件到指定的目录
			c.SaveUploadedFile(file, dst)
		}
		c.JSON(http.StatusOK, gin.H{
			"message": fmt.Sprintf("%d files uploaded!", len(files)),
		})
	})
	router.Run()
}

重定向

HTTP重定向

HTTP 重定向很容易。内部、外部重定向均支持。

r.GET("/index", func(c *gin.Context) {
   //c.JSON(http.StatusOK, gin.H{
   // "status": "ok",
   //})
   c.Redirect(http.StatusMovedPermanently, "http://www.baidu.com")
})

路由重定向

路由重定向，使用HandleContext：

r.GET("/a", func(c *gin.Context) {
   //调转到 /b 对应的路由处理函数
   c.Request.URL.Path = "/b" //把请求的URL修改
   r.HandleContext(c)
})

r.GET("/b", func(c *gin.Context) {
   c.JSON(http.StatusOK, gin.H{
      "message": "ok",
   })
})

Gin路由

普通路由

r.GET("/index", func(c *gin.Context) {
   c.JSON(http.StatusOK, gin.H{
      "method": "GET",
   })
})

r.POST("/index", func(c *gin.Context) {
   c.JSON(http.StatusOK, gin.H{
      "method": "POST",
   })
})

r.PUT("/index", func(c *gin.Context) {
   c.JSON(http.StatusOK, gin.H{
      "method": "PUT",
   })
})

r.DELETE("/index", func(c *gin.Context) {
   c.JSON(http.StatusOK, gin.H{
      "method": "DELETE",
   })
})

此外，还有一个可以匹配所有请求方法的Any方法如下：

//请求方法集合
r.Any("/user", func(c *gin.Context) {

   switch c.Request.Method {
   case "GET":
      c.JSON(http.StatusOK, gin.H{"method": "GET"})
   case http.MethodPost:
      c.JSON(http.StatusOK, gin.H{"method": "POST"})
   }

   c.JSON(http.StatusOK, gin.H{
      "method": "Any",
   })
})

为没有配置处理函数的路由添加处理程序，默认情况下它返回404代码，下面的代码为没有匹配到路由的请求都返回views/404.html页面。

//NoRoute
r.NoRoute(func(c *gin.Context) {
   c.JSON(http.StatusNotFound, gin.H{"message": "http://www.baidu.com"})
})

路由组

我们可以将拥有共同URL前缀的路由划分为一个路由组。习惯性一对{}包裹同组的路由，这只是为了看着清晰，你用不用{}包裹功能上没什么区别。

//路由组
videoGroup := r.Group("/video")
{
   videoGroup.GET("/index", func(c *gin.Context) {
      c.JSON(http.StatusOK, gin.H{"msg": "/video/index"})
   })
   videoGroup.GET("/xxx", func(c *gin.Context) {
      c.JSON(http.StatusOK, gin.H{"msg": "/video/xxx"})
   })

}

路由组也是支持嵌套的，例如：

shopGroup := r.Group("/shop")
	{
		shopGroup.GET("/index", func(c *gin.Context) {...})
		shopGroup.GET("/cart", func(c *gin.Context) {...})
		shopGroup.POST("/checkout", func(c *gin.Context) {...})
		// 嵌套路由组
		xx := shopGroup.Group("xx")
		xx.GET("/oo", func(c *gin.Context) {...})
	}

路由原理

Gin框架中的路由使用的是httprouter这个库。

其基本原理就是构造一个路由地址的前缀树。

中间件

Gin框架允许开发者在处理请求的过程中，加入用户自己的钩子（Hook）函数。这个钩子函数就叫中间件，中间件适合处理一些公共的业务逻辑，比如登录认证、权限校验、数据分页、记录日志、耗时统计等。

定义中间件

Gin中的中间件必须是一个gin.HandlerFunc类型。例如我们像下面的代码一样定义一个统计请求耗时的中间件。

//定义一个中间件
func m1(c *gin.Context) {
   fmt.Println("m1")

   //计时
   start := time.Now()
   c.Next() //调用后续的处理函数
   //c.Abort()//阻止调用后续的处理函数
   cost := time.Since(start)
   fmt.Println(cost)
   fmt.Println("m1 out")
}

注册中间件

在gin框架中，我们可以为每个路由添加任意数量的中间件。

为全局路由注册

func main() {
	// 新建一个没有任何默认中间件的路由
	r := gin.New()
	// 注册一个全局中间件
	r.Use(StatCost())
	
	r.GET("/test", func(c *gin.Context) {
		name := c.MustGet("name").(string) // 从上下文取值
		log.Println(name)
		c.JSON(http.StatusOK, gin.H{
			"message": "Hello world!",
		})
	})
	r.Run()
}

为某个路由单独注册

// 给/test2路由单独注册中间件（可注册多个）
	r.GET("/test2", StatCost(), func(c *gin.Context) {
		name := c.MustGet("name").(string) // 从上下文取值
		log.Println(name)
		c.JSON(http.StatusOK, gin.H{
			"message": "Hello world!",
		})
	})

为路由组注册中间件

//路由组注册中间件方法1：
xxGroup := r.Group("/xx", outhMiddleware(true))
{
   xxGroup.GET("/index", func(c *gin.Context) {
      c.JSON(http.StatusOK, gin.H{"msg": "xxGroup"})
   })
}
//路由组注册中间件方法1：
xx2Group := r.Group("/xx2")
xx2Group.Use(outhMiddleware(true))
{
   xx2Group.GET("/index", func(c *gin.Context) {
      c.JSON(http.StatusOK, gin.H{"msg": "xx2Group"})
   })
}

中间件注意事项

gin默认中间件

gin.Default()默认使用了Logger和Recovery中间件，其中：

Logger中间件将日志写入gin.DefaultWriter，即使配置了GIN_MODE=release。
Recovery中间件会recover任何panic。如果有panic的话，会写入500响应码。

如果不想使用上面两个默认的中间件，可以使用gin.New()新建一个没有任何默认中间件的路由。

gin中间件中使用goroutine

当在中间件或handler中启动新的goroutine时，不能使用原始的上下文（c *gin.Context），必须使用其只读副本（c.Copy()）。

运行多个服务

package main

import (
	"log"
	"net/http"
	"time"

	"github.com/gin-gonic/gin"
	"golang.org/x/sync/errgroup"
)

var (
	g errgroup.Group
)

func router01() http.Handler {
	e := gin.New()
	e.Use(gin.Recovery())
	e.GET("/", func(c *gin.Context) {
		c.JSON(
			http.StatusOK,
			gin.H{
				"code":  http.StatusOK,
				"error": "Welcome server 01",
			},
		)
	})

	return e
}

func router02() http.Handler {
	e := gin.New()
	e.Use(gin.Recovery())
	e.GET("/", func(c *gin.Context) {
		c.JSON(
			http.StatusOK,
			gin.H{
				"code":  http.StatusOK,
				"error": "Welcome server 02",
			},
		)
	})

	return e
}

func main() {
	server01 := &http.Server{
		Addr:         ":8080",
		Handler:      router01(),
		ReadTimeout:  5 * time.Second,
		WriteTimeout: 10 * time.Second,
	}

	server02 := &http.Server{
		Addr:         ":8081",
		Handler:      router02(),
		ReadTimeout:  5 * time.Second,
		WriteTimeout: 10 * time.Second,
	}
   // 借助errgroup.Group或者自行开启两个goroutine分别启动两个服务
	g.Go(func() error {
		return server01.ListenAndServe()
	})

	g.Go(func() error {
		return server02.ListenAndServe()
	})

	if err := g.Wait(); err != nil {
		log.Fatal(err)
	}
}

~庞贝

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Gin框架（下）

目录Gin文件上传单个文件上传多个文件上传重定向HTTP重定向路由重定向Gin路由普通路由路由组路由原理中间件定义中间件注册中间件为全局路由注册为某个路由单独注册为路由组注册中间件中间件注意事项gin默认中间件gin中间件中使用goroutine运行多个服务Gin文件上传单个文件上传文件上传前端页面代码：<!DOCTYPE html><html lang="en"><head> <meta charset="UTF-8"> <
复制链接

扫一扫