^-^
【go工程组件】高性能web框架gin
最近更新：2024-12-10   |   字数总计：2.2k   |   阅读估时：11分钟   |   阅读量：次
  1. 高性能web框架gin
    1. RESTful API与API版本控制
      1. RESTful API
      2. 安装gin框架
      3. 简单gin示例
      4. 使用多版本API示例
        1. 定义业务对象
        2. 定义路由
        3. 启用服务
    2. 模型绑定、参数验证及文件上传
      1. 模型绑定、参数验证
      2. 文件上传
    3. 中间件编程及jwt身份认证
      1. 跨域处理中间件
      2. 身份认证中间件
        1. jwt插件
        2. 认证中间件
        3. 模拟登录接口
      3. 在路由中应用中间件
      4. 测试身份认证
    4. Protobuf消息传输
      1. 定义消息
      2. 生成代码
      3. 使用protobuf格式返回数据
      4. 测试结果(protobuf反序列化)

高性能web框架gin

  • go语言编写的web框架，适用于web后台开发

RESTful API与API版本控制

RESTful API

  1. 一个约定或者规范
  2. 每一个url都是一个资源，所以资源的url是一个名词如/user而不是/getuser
  3. 我们要对资源做的事情，通过http method来表示，如get、put、post

安装gin框架

1
go get -u github.com/gin-gonic/gin

简单gin示例

  • main.go
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    package main

    import (
    	"gin/routers"

    	"github.com/gin-gonic/gin"
    )

    func main() {
    	r := gin.Default()
    	r.GET("/ping", func(ctx *gin.Context) {
    		ctx.JSON(http.StatusOK, gin.H{
    			"message": "pong",
    		})
    	})
    	r.Run()
    }

使用多版本API示例

定义业务对象

  1. course
  2. user
  3. upload
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    // course.go
    package course

    import (
    	"net/http"

    	"github.com/gin-gonic/gin"
    )

    func Add(c *gin.Context) {
    	c.JSON(http.StatusOK, gin.H{
    		"method": c.Request.Method,
    		"path":   c.Request.URL.Path,
    	})
    }

    func Get(c *gin.Context) {
    	c.JSON(http.StatusOK, gin.H{
    		"method": c.Request.Method,
    		"path":   c.Request.URL.Path,
    	})
    }

    func Edit(c *gin.Context) {
    	c.JSON(http.StatusOK, gin.H{
    		"method": c.Request.Method,
    		"path":   c.Request.URL.Path,
    	})
    }

    func Delete(c *gin.Context) {
    	c.JSON(http.StatusOK, gin.H{
    		"method": c.Request.Method,
    		"path":   c.Request.URL.Path,
    	})
    }
    // user.go
    package user

    import (
    	"net/http"

    	"github.com/gin-gonic/gin"
    )

    func Add(c *gin.Context) {
    	c.JSON(http.StatusOK, gin.H{
    		"method": c.Request.Method,
    		"path":   c.Request.URL.Path,
    	})
    }

    func Get(c *gin.Context) {
    	c.JSON(http.StatusOK, gin.H{
    		"method": c.Request.Method,
    		"path":   c.Request.URL.Path,
    	})
    }
    // user_v2.go
    package user

    import (
    	"net/http"

    	"github.com/gin-gonic/gin"
    )

    func AddV2(c *gin.Context) {
    	c.JSON(http.StatusOK, gin.H{
    		"method": c.Request.Method,
    		"path":   c.Request.URL.Path,
    	})
    }

    func GetV2(c *gin.Context) {
    	c.JSON(http.StatusOK, gin.H{
    		"method": c.Request.Method,
    		"path":   c.Request.URL.Path,
    	})
    }
    // upload.go
    package upload

    import (
    	"net/http"

    	"github.com/gin-gonic/gin"
    )

    func Upload(c *gin.Context) {
    	c.JSON(http.StatusOK, gin.H{
    		"method": c.Request.Method,
    		"path":   c.Request.URL.Path,
    	})
    }

定义路由

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
// course.go
package routers

import (
	"gin/course"

	"github.com/gin-gonic/gin"
)

func initCourse(group *gin.RouterGroup) {
	v1 := group.Group("v1")
	{
		// /api/v1/course/id
		v1.GET("/course/:id", course.Get)
		v1.POST("/course", course.Add)
		v1.PUT("/course", course.Edit)
		v1.DELETE("/course", course.Delete)
	}
}
// user.go
package routers

import (
	"gin/user"

	"github.com/gin-gonic/gin"
)

func initUser(group *gin.RouterGroup) {
	v1 := group.Group("v1")
	{
		v1.GET("/user/:id", user.Get)
		v1.POST("/user", user.Add)
	}
	v2 := group.Group("v2")
	{
		v2.GET("/user/:id", user.GetV2)
		v2.POST("/user", user.AddV2)
	}
}
// upload.go
package routers

import (
	"gin/upload"

	"github.com/gin-gonic/gin"
)

func initUpload(group *gin.RouterGroup) {
	v1 := group.Group("v1")
	v1.POST("/upload", upload.Upload)
}
// routers.go
package routers

import "github.com/gin-gonic/gin"

func InitRouters(r *gin.Engine) {
	api := r.Group("/api")
	initCourse(api)
	initUser(api)
	initUpload(api)
}

启用服务

  • main.go
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    package main

    import (
    	"gin/routers"

    	"github.com/gin-gonic/gin"
    )

    func main() {
    	r := gin.Default()
    	routers.InitRouters(r)
    	r.Run()
    }

模型绑定、参数验证及文件上传

模型绑定、参数验证

  • course.go
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    package course

    import (
    	"net/http"

    	"github.com/gin-gonic/gin"
    )

    // 定义模型
    type course struct {
    	// 手动指明表单里面写的字段名，否则就是Name, binding是做一些校验的地方，这里是必填+字母
    	Name     string `form:"name" binding:"required,alphaunicode"`
    	Teacher  string `json:"teacher" binding:"required,alphaunicode"` // 手动指明json里面写的字段名，否则就是Teacher
    	Duration int    `binding:"number"`
    }

    func Add(c *gin.Context) {
    	req := &course{}
    	// 只能取到x-www-form-urlencoded的表单值，不能取到form-data和json的值
    	err := c.ShouldBind(req) // 带should的，假如没有从form表单中取到值，就返回一个错误
    	// c.Bind()
    	if err != nil {
    		c.JSON(http.StatusInternalServerError, gin.H{
    			"error": err.Error(),
    		})
    		return
    	}
    	c.JSON(http.StatusOK, req)
    }

    func Get(c *gin.Context) {
    	id := c.Param("id") // 路径上的参数即 :id的获取方式
    	c.JSON(http.StatusOK, gin.H{
    		"id": id,
    	})
    }

    func Edit(c *gin.Context) { // edit方法，即put方法和add方法参数获取方法一致
    	req := &course{}
    	err := c.Bind(req) // bind方法没有should，假如我们传入一个duration是字符串，那么会直接返回400错误，并不会走到下面的500错误返回的代码里面
    	if err != nil {
    		c.JSON(http.StatusInternalServerError, gin.H{
    			"error": err.Error(),
    		})
    		return
    	}
    	c.JSON(http.StatusOK, req)
    }

    func Delete(c *gin.Context) { // delete方法获取参数需要用到query string
    	id := c.Query("id")
    	c.JSON(http.StatusOK, gin.H{
    		"id": id,
    	})
    }

  • user.go
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    package user

    import (
    	"net/http"

    	"github.com/gin-gonic/gin"
    )

    type user struct {
    	Name  string `json:"name" binding:"required,alphaunicode"`
    	Age   int    `json:"age" binding:"omitempty,number"` // 忽略为空的情况的格式校验
    	Phone string `json:"phone" binding:"omitempty,e164"`
    	Email string `json:"email" binding:"omitempty,email"`
    }

    // http://localhost:8080/api/v1/user
    // {"name":"lin","age":18,"Phone":"+8613683200000","Email":"123@xx.cn"}
    func Add(c *gin.Context) {
    	req := &user{}
    	err := c.ShouldBindJSON(req)
    	if err != nil {
    		c.JSON(http.StatusInternalServerError, gin.H{
    			"error": err.Error(),
    		})
    		return
    	}
    	c.JSON(http.StatusOK, req)
    }

    // http://localhost:8080/api/v1/user?id=10
    func Get(c *gin.Context) {
    	id := c.Query("id")
    	c.JSON(http.StatusOK, gin.H{
    		"id": id,
    	})
    }

文件上传

  • upload.go
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    package upload

    import (
    	"net/http"

    	"github.com/gin-gonic/gin"
    )

    func Upload(c *gin.Context) {
    	// 此处file是字段名
    	file, _ := c.FormFile("file")
    	dst := "upload_files/" + file.Filename
    	c.SaveUploadedFile(file, dst)
    	c.JSON(http.StatusOK, gin.H{
    		"file": file.Filename,
    	})
    }

    func UploadMulitiple(c *gin.Context) {
    	form, _ := c.MultipartForm()
    	// 此处files是字段名
    	files := form.File["files"]
    	filesName := make([]string, len(files))
    	for i := 0; i < len(files); i++ {
    		file := files[i]
    		dst := "upload_files/" + file.Filename
    		c.SaveUploadedFile(file, dst)
    		filesName[i] = file.Filename
    	}
    	c.JSON(http.StatusOK, gin.H{
    		"files": filesName,
    	})
    }

  • 修改路由添加多文件上传
  • upload.go
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    package routers

    import (
    	"gin/upload"

    	"github.com/gin-gonic/gin"
    )

    func initUpload(group *gin.RouterGroup) {
    	v1 := group.Group("v1")
    	v1.POST("/upload", upload.Upload)
    	v1.POST("/uploadmult", upload.UploadMulitiple)
    }

  • 修改单次api请求的最大空间限制
  • main.go
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    package main

    import (
    	"gin/routers"

    	"github.com/gin-gonic/gin"
    )

    func main() {
    	r := gin.Default()
    	r.MaxMultipartMemory = 8 << 20 // 设置单次请求的最大空间大小
    	routers.InitRouters(r)
    	r.Run()
    }

  • 文件上传只能从form-data上传
    alt text

中间件编程及jwt身份认证

  • 添加跨域处理包
    1
    go get github.com/gin-contrib/cors
  • 添加身份认证处理包
    1
    go get github.com/golang-jwt/jwt/v4

跨域处理中间件

  • cors.go
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    package middleware

    import (
    	"github.com/gin-contrib/cors"
    	"github.com/gin-gonic/gin"
    )

    func Cors() gin.HandlerFunc {
    	// 添加跨域逻辑
    	return cors.New(cors.Config{
    		AllowAllOrigins: true,
    		AllowHeaders: []string{
    			"Origin", "Content-Length", "Content-Type",
    		},
    		AllowMethods: []string{
    			"GET", "POST", "DELETE", "PUT", "HEAD", "OPTIONS",
    		},
    	})
    }

身份认证中间件

jwt插件

  • jwt.go
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    package jwtplugin

    import "github.com/golang-jwt/jwt/v4"

    var key = "abcdefg1234567" // 先这么写着，实际开发要写到配置文件中，会灵活很多

    type Data struct {
    	Name   string `json:"name"`
    	Age    int    `json:"age"`
    	Gender int    `json:"gender"`
    	jwt.RegisteredClaims
    }

    // 签名
    func Sign(data jwt.Claims) (string, error) {
    	token := jwt.NewWithClaims(jwt.SigningMethodES256, data)
    	sign, err := token.SignedString([]byte(key))
    	if err != nil {
    		return "", err
    	}
    	return sign, err
    }

    // 验签
    func Verify(sign string, data jwt.Claims) error {
    	_, err := jwt.ParseWithClaims(sign, data, func(token *jwt.Token) (interface{}, error) {
    		return []byte(key), nil
    	})
    	return err
    }

认证中间件

  • auth.go
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    package middleware

    import (
    	jwtplugin "gin/jwt_plugin"
    	"net/http"

    	"github.com/gin-gonic/gin"
    )

    func Auth() gin.HandlerFunc {
    	return func(c *gin.Context) {
    		// 添加身份认证逻辑
    		accessToken := c.Request.Header.Get("access_token")
    		data := &jwtplugin.Data{}
    		err := jwtplugin.Verify(accessToken, data)
    		if err != nil {
    			c.JSON(http.StatusForbidden, gin.H{
    				"error": "身份认证失败",
    			})
    			c.Abort()
    		}
    		c.Set("auth_info", data) // 将认证信息设置到上下文中，随时可以使用c.Get("auth_info")取出
    		c.Next()                 // 执行下一个中间件
    	}
    }

模拟登录接口

  • login.go
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    package login

    import (
    	jwtplugin "gin/jwt_plugin"
    	"net/http"
    	"time"

    	"github.com/gin-gonic/gin"
    	"github.com/golang-jwt/jwt/v4"
    )

    func Login(c *gin.Context) {
    	data := jwtplugin.Data{
    		Name:   "nick",
    		Age:    18,
    		Gender: 1,
    		RegisteredClaims: jwt.RegisteredClaims{
    			ExpiresAt: jwt.NewNumericDate(time.Now().Add(time.Hour)),
    			IssuedAt:  jwt.NewNumericDate(time.Now()),
    			NotBefore: jwt.NewNumericDate(time.Now()),
    		},
    	}
    	sign, err := jwtplugin.Sign(data)
    	if err != nil {
    		c.JSON(http.StatusInternalServerError, gin.H{
    			"error": err.Error(),
    		})
    		return
    	}
    	c.JSON(http.StatusOK, gin.H{
    		"access_token": sign,
    	})
    }
  • login.go
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    package routers

    import (
    	"gin/login"

    	"github.com/gin-gonic/gin"
    )

    func initLogin(group *gin.RouterGroup) {
    	v1 := group.Group("v1")
    	{
    		v1.GET("login", login.Login) // 暂时模拟登录
    	}
    }

在路由中应用中间件

  • routes.go
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    package routers

    import (
    	"gin/middleware"

    	"github.com/gin-gonic/gin"
    )

    func InitRouters(r *gin.Engine) {
    	api := r.Group("/api")
    	api.Use(middleware.Cors(), middleware.Auth()) // 添加中间件
    	initCourse(api)
    	initUser(api)
    	initUpload(api)

        // 下面的接口不需要鉴权就能使用，如登录接口
    	notAuthApi := r.Group("/api")
    	notAuthApi.Use(middleware.Cors()) // 添加中间件
    	initLogin(notAuthApi)
    }

测试身份认证

  • 模拟登录
    alt text
  • 使user v2 api返回鉴权数据
  • user_v2.go
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    package user

    import (
    	"net/http"

    	"github.com/gin-gonic/gin"
    )

    func AddV2(c *gin.Context) {
    	c.JSON(http.StatusOK, gin.H{
    		"method": c.Request.Method,
    		"path":   c.Request.URL.Path,
    	})
    }

    func GetV2(c *gin.Context) {
    	authInfo, _ := c.Get("auth_info")
    	c.JSON(http.StatusOK, authInfo)
    }

    alt text
  • 此时访问其他接口时，不加token会返回403Forbidden

Protobuf消息传输

定义消息

1
2
3
4
5
6
7
8
9
10
11
syntax = "proto3";

package course;

option go_package = "gin/course";

message AddCourseResponse{
    string name = 1;
    string teacher = 2;
    int32 duratioin = 3;
}

生成代码

1
protoc -I . --go_out=. --go_opt=paths=source_relative ./course/course.proto

使用protobuf格式返回数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
package course

import (
	"net/http"

	"github.com/gin-gonic/gin"
)

// 定义模型
type course struct {
	// 手动指明表单里面写的字段名，否则就是Name, binding是做一些校验的地方，这里是必填+字母
	Name     string `form:"name" binding:"required,alphaunicode"`
	Teacher  string `form:"teacher" binding:"required,alphaunicode"` // 手动指明json里面写的字段名，否则就是Teacher
	Duration int    `form:"duration" binding:"number"`
}

func Add(c *gin.Context) {
	req := &course{}
	// 只能取到x-www-form-urlencoded的表单值，不能取到form-data和json的值
	err := c.ShouldBind(req) // 带should的，假如没有从form表单中取到值，就返回一个错误
	// c.Bind()
	if err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{
			"error": err.Error(),
		})
		return
	}
	// 使用protobuf格式返回 , out一定得是指针类型
	out := &AddCourseResponse{
		Name:      req.Name,
		Teacher:   req.Teacher,
		Duratioin: int32(req.Duration),
	}
	c.ProtoBuf(http.StatusOK, out)
	// c.JSON(http.StatusOK, req)
}

测试结果(protobuf反序列化)

  • client/main.go
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    package main

    import (
    	"fmt"
    	"gin/course"
    	"io"
    	"log"
    	"net/http"
    	"net/url"
    	"strings"

    	"google.golang.org/protobuf/proto"
    )

    // 仅仅是为了验证protobuf传递的返回的正确性
    func main() {
    	uri := "http://localhost:8080/api/v1/course"
    	method := "POST"
    	v := url.Values{}
    	v.Add("name", "golang")
    	v.Add("teacher", "lin")
    	v.Add("duration", "200")
    	payload := strings.NewReader(v.Encode())
    	client := &http.Client{}
    	req, err := http.NewRequest(method, uri, payload)
    	if err != nil {
    		log.Println(err)
    		return
    	}
    	req.Header.Add("access_token", "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJuYW1lIjoibmljayIsImFnZSI6MTgsImdlbmRlciI6MSwiZXhwIjoxNzMzNzcwNTI3LCJuYmYiOjE3MzM3NjY5MjcsImlhdCI6MTczMzc2NjkyN30.ZX3VAVUaDKvMqz20H6ZfZ28RrJx7LQhJf4DVyxS02Ss")
    	req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
    	res, err := client.Do(req)
    	if err != nil {
    		log.Println(err)
    		return
    	}
    	defer res.Body.Close()
    	body, err := io.ReadAll(res.Body)
    	if err != nil {
    		log.Println(err)
    		return
    	}
    	out := &course.AddCourseResponse{}
    	err = proto.Unmarshal(body, out)
    	fmt.Println(out, err)
    }
2024-12-09 该篇文章被 Cleofwine 归为分类: Go云原生

上一篇：【go工程组件】高性能消息传输协议Protobuf 下一篇：【go工程组件】高性能RPC框架gRPC
© 2023-2026 Cleofwine / Email / GitHub / 浙ICP备2024136127号
🌙赠我弯弯一枚月，也赠予我晚星⭐ 本站由Hexo驱动｜使用Hexo-theme-A4主题