0
0

golang——Gin框架及路由介绍

一. 框架介绍

  1.     Gin是一个轻量级的Go语言Web框架，它具有高性能和简洁的设计。由于其快速的路由匹配和处理性能，Gin成为Go语言中最受欢迎的Web框架之一。
  3.     特点：
  • 快速和轻量：Gin框架的设计注重性能和效率，采用了一些优化措施，使其成为一个快速而轻量级的框架。
  • 路由和中间件：Gin提供了强大的路由功能，支持参数传递，路由分组等特性。同时，它支持中间件的使用，可以方便的在请求处理过程中执行一系列的操作，比如身份验证，日志记录等。
  • json解析：Gin内置了对json的解析和序列化支持，使得处理json数据变得简单而高效。
  • 支持插件：Gin允许开发者通过插件来扩展框架的功能，这样可以根据项目的需求进行灵活定制。

文档：

二. 安装

  1.     要安装Gin软件包，您需要安装Go并首先设置Go工作区。
  • 命令安装Gin
  1. go get github.com/gin-gonic/gin@latest
  • 导入代码
  1. import "github.com/gin-gonic/gin"

三. 第一个Gin应用

  1. package main
  3. import (
  4.     "net/http"
  6.     "github.com/gin-gonic/gin"
  7. )
  9. func main() {
  10.     //将应用切换到“发布模式”以提升性能
  11.     gin.SetMode(gin.ReleaseMode)
  12.     //创建路由
  13.     r := gin.Default()
  14.     //绑定路由规则，执行函数
  15.     //gin.Context，封装了request和response
  16.     r.GET("/", func(c *gin.Context) {
  17.         c.String(http.StatusOK, "hello world")
  18.     })
  20.     //监听端口，默认绑定端口8080
  21.     r.Run(":8080")
  22. }

代码解释：

  • gin.Default：创建一个Gin引擎。gin.Default()返回一个带有默认中间件的Gin引擎，包括Logger和Recovery中间件，用于日志记录和恢复。
  • r.Get("/", func(c *gin.Context){...})：定义了一个GET方法的路由，当访问路径是"/"时，执行后面的回调函数。
  • c.String(http.StatusOK, "hello world")：在回调函数中，通过c.String方法返回一个字符串"hello world"并设置HTTP状态码为200 OK。
  • s.Run(":8080")：启动Web服务，监听在0.0.0.0:8080。如果不指定端口号，默认使用8080端口。此时，你可以通过浏览器或HTTP客户端访问http://localhost:8080，将会得到"hello world"的响应。

四. 应用举例

  1.     以下项目都是使用Gin框架开发的：
  • gorush：Go 编写的通知推送服务器。
  • fnproject：容器原生，云 serverless 平台。
  • photoprism：基于 Go 和 Google TensorFlow 实现的个人照片管理工具。
  • krakend：拥有中间件的超高性能 API 网关。
  • picfit：Go 编写的图像尺寸调整服务器。
  • gotify：基于 WebSocket 进行实时消息收发的简单服务器。
  • cds：企业级持续交付和 DevOps 自动化开源平台。

五. Gin入门

  • gin.Engine

    1.   在Gin里面，一个Web服务器被抽象成了Engnie。你可以在一个应用里面创建多个Engine实例，监听不同的端口。Engine承担了路由注册，接入中间件的核心职责。
    3.   它组合了RouterGroup，RouterGroup才是实现路由功能的核心组件。

  • gin.Context

    1.   gin.Context是Gin里面的核心类型。字面意思是"上下文"，在Gin里面的核心职责是：

  • 处理请求

  • 返回响应

六. 路由

6.1 介绍

  • gin框架中采用的路由库是基于httprouter做的
  • 地址为：https://github.com/julienschmidt/httprouter
  • 支持Restful风格的API，意思是"表面层状态转化"，是一个互联网应用程序的API设计理念：URL定位资源。
  • 可以创建路由组，为了管理相同的URL。
  1. package main
  3. import (
  4.     "net/http"
  6.     "github.com/gin-gonic/gin"
  7. )
  9. func main() {
  10.     //将应用切换到“发布模式”以提升性能
  11.     gin.SetMode(gin.ReleaseMode)
  12.     //创建路由
  13.     //默认使用了两个中间件Logger()，Recovery()
  14.     r := gin.Default()
  16.     r.GET("/hello1", func(c *gin.Context) {
  17.         c.String(http.StatusOK, "hello1")
  18.     })
  19.     r.GET("/hello2", func(c *gin.Context) {
  20.         c.String(http.StatusOK, "hello2")
  21.     })
  23.     //路由组1
  24.     v1 := r.Group("/v1")
  25.     {
  26.         v1.GET("/hellov1", func(c *gin.Context) {
  27.             c.String(http.StatusOK, "hello v1")
  28.         })
  29.         v1.GET("hellov11", func(c *gin.Context) {
  30.             c.String(http.StatusOK, "hello v11")
  31.         })
  32.     }
  34.     //路由组2
  35.     v2 := r.Group("/v2")
  36.     {
  37.         v2.GET("/hellov2", func(c *gin.Context) {
  38.             c.String(http.StatusOK, "hello v2")
  39.         })
  41.         v2.POST("/hellov22", func(c *gin.Context) {
  42.             c.String(http.StatusOK, "hello v22")
  43.         })
  44.     }
  46.     //监听端口，默认绑定端口8080
  47.     r.Run(":8080")
  48. }

6.2 API参数

  • 可以通过Context的Param方法来获取API参数
  1. package main
  3. import (
  4.     "fmt"
  5.     "net/http"
  6.     "strings"
  8.     "github.com/gin-gonic/gin"
  9. )
  11. func main() {
  12.     r := gin.Default()
  14.     r.GET("/user/:name/*action", func(c *gin.Context) {
  15.         name := c.Param("name")
  16.         action := c.Param("action")
  18.         fmt.Println(name, ":", action) //对于url /user/wy/aa 打印 wy : /aa
  19.         //去除/
  20.         action = strings.Trim(action, "/")
  21.         c.String(http.StatusOK, name+" is "+action)
  22.     })
  23.     r.Run()
  24. }

6.3 URL参数

  • URL参数可以通过DefaultQuery()或Query方法获取
  • DefaultQuery()若参数不存在，返回默认值。Query()若参数不存在，返回空串。
  1. package main
  3. import (
  4.     "net/http"
  6.     "github.com/gin-gonic/gin"
  7. )
  9. func main() {
  10.     r := gin.Default()
  12.     r.GET("/user", func(c *gin.Context) {
  13.         name := c.Query("name")
  14.         action := c.DefaultQuery("action", "")
  16.         c.String(http.StatusOK, name+" is "+action)
  17.     })
  18.     r.Run()
  19. }

6.4 表单参数

  • 表单传输参数为POST请求，http常见的传输格式为四种：- application/json- application/x-www-form-urlencode- application/xml- mulipart/form-data
  • 表单参数可以通过PostForm()方法获取，该方法默认解析的是x-www-form-urlencode或form-data格式的参数。

POST请求的html代码：

  1. <!--test.html-->
  2. <!DOCTYPE html>
  3. <html lang="en">
  4. <head>
  5. <meta charset="UTF-8">
  6. <meta name="viewport" content="width=device-width, initial-scale=1.0">
  7. <meta http-equiv="X-UA-Compatible" content="ie=edge">
  8. <title>Document</title>
  9. </head>
  10. <body>
  11. <form action="/form" method="post"
  12. action="application/x-www-form-urlencoded">
  13. 用户名：<input type="text" name="username" placeholder="请输入你的用户名">
  14. <br>密&nbsp;&nbsp;&nbsp;码：<input type="password" name="userpassword"
  15. placeholder="请输入你的密码"> <br>
  16. <input type="submit" value="提交">
  17. </form>
  18. </body>
  19. </html>

服务端代码

  1. package main
  3. import (
  4.     "net/http"
  6.     "github.com/gin-gonic/gin"
  7. )
  9. func main() {
  10.     r := gin.Default()
  12.     //设置HTML文件所在目录
  13.     r.LoadHTMLGlob("./*.html")
  14.     //设置GET方法路由，成功返回test.html文件
  15.     r.GET("/", func(c *gin.Context) {
  16.         c.HTML(http.StatusOK, "test.html", nil)
  17.     })
  19.     //设置POST方法路由
  20.     r.POST("/form", func(c *gin.Context) {
  21.         //设置没有传的参数的默认值
  22.         types := c.DefaultPostForm("type", "post")
  23.         username := c.PostForm("username")
  24.         password := c.PostForm("userpassword")
  26.         c.String(http.StatusOK, "username:%s, userpassword:%s, types:%s", username, password, types)
  27.     })
  29.     r.Run()
  30. }

演示：

6.5 上传文件

上传单个文件：

  • multipart/form-data格式用于上传文件
  • gin文件上传与原生的net/http方法类似，不同在于gin吧原生的request封装到了c.Request中。
  1. package main
  3. import (
  4.     "net/http"
  6.     "github.com/gin-gonic/gin"
  7. )
  9. func main() {
  10.     r := gin.Default()
  12.     //设置HTML文件所在目录
  13.     r.LoadHTMLGlob("./*.html")
  14.     //设置GET方法路由，成功返回test.html文件
  15.     r.GET("/", func(c *gin.Context) {
  16.         c.HTML(http.StatusOK, "test.html", nil)
  17.     })
  19.     //设置POST方法路由
  20.     r.MaxMultipartMemory = 8 << 20 //限制上传最大尺寸
  21.     r.POST("/upload", func(c *gin.Context) {
  22.         //用于获取表单信息中file格式的参数，并且返回一个文件流
  23.         file, err := c.FormFile("file") //html中的name
  24.         if err != nil {
  25.             c.String(500, "上次图片错误")
  26.         }
  27.         //参数1为指定需要保存操作的文件，参数2为指定保存路径。
  28.         c.SaveUploadedFile(file, file.Filename)
  29.         //返回文件名
  30.         c.String(http.StatusOK, file.Filename)
  32.     })
  34.     r.Run()
  35. }

演示：

上传特定文件：

  1.     有的用户上传文件需要限制文件的类型以及上传文件的大小，可以基于原生的函数写法自己写一个可以限制大小以及文件类型的上传函数。

  1. package main
  3. import (
  4.     "net/http"
  6.     "github.com/gin-gonic/gin"
  7. )
  9. func main() {
  10.     r := gin.Default()
  12.     r.LoadHTMLGlob("./*.html")
  13.     r.GET("/", func(c *gin.Context) {
  14.         c.HTML(http.StatusOK, "test.html", nil)
  15.     })
  17.     r.POST("/upload", func(c *gin.Context) {
  18.         _, header, err := c.Request.FormFile("file")
  19.         if err != nil {
  20.             c.String(405, "文件错误")
  21.             return
  22.         }
  24.         if header.Size > 1024*1024*2 {
  25.             c.String(406, "文件太大")
  26.             return
  27.         }
  29.         if header.Header.Get("Content-Type") != "image/png" {
  30.             c.String(407, "只允许上传图片")
  31.             return
  32.         }
  34.         c.SaveUploadedFile(header, header.Filename)
  35.         c.String(http.StatusOK, header.Filename)
  36.     })
  38.     r.Run()
  39. }

上传多个文件：

  1. package main
  3. import (
  4.     "fmt"
  5.     "net/http"
  7.     "github.com/gin-gonic/gin"
  8. )
  10. func main() {
  11.     r := gin.Default()
  13.     r.LoadHTMLGlob("./*.html")
  14.     r.GET("/", func(c *gin.Context) {
  15.         c.HTML(http.StatusOK, "test.html", nil)
  16.     })
  17.     //限制表单上传大小8MB 默认32MB
  18.     r.MaxMultipartMemory = 8 << 20 * 2
  19.     r.POST("/upload", func(c *gin.Context) {
  20.         //用于获取multipart表单。当用户通过表单上传文件时，浏览器通常会将表单编码为multipart/form-data格式。
  21.         form, err := c.MultipartForm()
  22.         if err != nil {
  23.             c.String(http.StatusBadRequest, fmt.Sprintf("get a %v", err))
  24.             return
  25.         }
  26.         //获取所有文件
  27.         files := form.File["files"]
  28.         //遍历所有文件
  29.         for _, file := range files {
  30.             if err := c.SaveUploadedFile(file, file.Filename); err != nil {
  31.                 c.String(http.StatusBadRequest, fmt.Sprintf("upload get a %v", err))
  32.                 return
  33.             }
  34.         }
  35.         c.String(http.StatusOK, fmt.Sprintf("upload %d files ok", len(files)))
  36.     })
  38.     r.Run()
  39. }

6.6 路由原理

  1.     httprouter会将所有路由规则构造一棵前缀树。
  3.     例如有root，and，as，at，cn，com

6.7 路由拆分与注册

  • 基本的路由注册

    1.    下面最基础的gin路由注册方式，使用于路由条目比较少的简单项目或者项目demo。
  1. package main
  3. import (
  4.     "fmt"
  5.     "net/http"
  7.     "github.com/gin-gonic/gin"
  8. )
  10. func sayHello(c *gin.Context) {
  11.     c.JSON(http.StatusOK, gin.H{
  12.         "message": "hello go",
  13.     })
  14. }
  16. func main() {
  17.     r := gin.Default()
  18.     r.GET("/hello", sayHello)
  19.     if err := r.Run(); err != nil {
  20.         fmt.Printf("startup server err : %v", err)
  21.     }
  22. }

  • 路由拆分成单独文件或包 

    1.   当项目的规模增大后，就不适合继续在项目的main.go文件中实现路由注册相关逻辑了，我们会倾向于把路由部分的代码都拆分出来，形成一个单独的文件或包。

  • 形成单独文件

  • 形成独立的包

  • 拆分成多个文件

    1.   当业务规模继续膨胀，单独的一个router文件或包已经满足不了我们的需求了。 因为我们把所有的路由注册都写在一个SetRouter函数中的话会很复杂。
    3.   我们可以将其拆分为多个文件。

  • 路由拆分到不同APP 

    1.   有时候项目规模太大，那么我们就更倾向于把业务拆分的更加详细，例如把不同的业务代码拆分成不同的APP。
    3.   因此我们在项目目录下单独定义一个app目录，用来存放我们不同业务线的代码文件，这样就很容易进行横向扩展。

目录结构：

app/blog:

代码如下：

gin/app/shop:

gin/router/router.go

gin/main.go

标签： golang gin
本文转载自: https://blog.csdn.net/weixin_57023347/article/details/139745932
版权归原作者 两片空白 所有， 如有侵权，请联系我们删除。
登录后发布评论

“golang——Gin框架及路由介绍”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？