【Golang】gin框架入门

最新推荐文章于 2024-05-11 15:36:33 发布
最新推荐文章于 2024-05-11 15:36:33 发布
阅读量754 收藏 1
点赞数 3
分类专栏： golang 文章标签： golang gin 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Suk_god/article/details/133580969
版权

文章目录

gin框架入门

认识gin

go流行的web框架

  • Gin

    号称最快的go语言web框架，目前是go官方的推荐框架（https://go.dev/doc/tutorial/）

  • iris

    性能比gin高一些，支持MVC，但这款框架评价不太好，使用上问题较多，近些年很少去选择使用

  • Beego

    国人开发，最早的go web框架之一，工具集比较完善，性能较差，据传言作者是php转行，所以框架带有浓厚的php特色，早期国内使用的多，目前少有人选择

  • fiber

    2020年发布的框架，发展迅速，建立在fasthttp之上，性能目前最高，受Express启发，比较简洁，上手较快，和gin类似

当然还有其他一些框架，但从star数上，以及流行程度上看，gin一骑绝尘，gin的好处在于其简洁，扩展性，稳定性以及性能都比较出色。

go的框架其实是可以理解为库，并不是用了某一个框架就不能用别的框架，可以选择性的使用各个库中的优秀组件，进行组合

gin介绍

特性：

  • 快速

    基于 Radix 树的路由，小内存占用。没有反射。可预测的 API 性能

  • 支持中间件

    传入的 HTTP 请求可以由一系列中间件和最终操作来处理。 例如：Logger，Authorization，GZIP，最终操作 DB

  • Crash处理

    Gin 可以 catch 一个发生在 HTTP 请求中的 panic 并 recover 它。这样，你的服务器将始终可用。例如，你可以向 Sentry 报告这个 panic！

  • JSON验证

    Gin 可以解析并验证请求的 JSON，例如检查所需值的存在

  • 路由组

    更好地组织路由。是否需要授权，不同的 API 版本…… 此外，这些组可以无限制地嵌套而不会降低性能

  • 错误管理

    Gin 提供了一种方便的方法来收集 HTTP 请求期间发生的所有错误。最终，中间件可以将它们写入日志文件，数据库并通过网络发送

  • 内置渲染

    Gin 为 JSON，XML 和 HTML 渲染提供了易于使用的 API

  • 可扩展性

    新建一个中间件非常简单

快速入门

go版本需求：go1.13及以上

环境：windows 11

  • gin框架下载

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

    在这里插入图片描述

  • demo展示

    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() // 监听并在 0.0.0.0:8080 上启动服务
}

    在这里插入图片描述

    此时，通过postman发送请求测试是否联通

    在这里插入图片描述

路由

路由是URI到函数的映射。

一个URI含: http://localhost:8080/user/find?id=11

  • 协议，比如http，https等
  • ip端口或者域名，比如127.0.0.1:8080或者www.test.com
  • path，比如 /path
  • query，比如 ?query

同时访问的时候，还需要指明HTTP METHOD，比如

  • GET

    GET方法请求一个指定资源的表示形式. 使用GET的请求应该只被用于获取数据.

  • POST

    POST方法用于将实体提交到指定的资源，通常会导致在服务器上的状态变化

  • HEAD

    HEAD方法请求一个与GET请求的响应相同的响应，但没有响应体.

  • PUT

    PUT方法用请求有效载荷替换目标资源的所有当前表示

  • DELETE

    DELETE方法删除指定的资源

  • CONNECT

    CONNECT方法建立一个到由目标资源标识的服务器的隧道。

  • OPTIONS

    OPTIONS方法用于描述目标资源的通信选项。

  • TRACE

    TRACE方法沿着到目标资源的路径执行一个消息环回测试。

  • PATCH

    PATCH方法用于对资源应用部分修改。

使用的时候，应该尽量遵循其语义

RESTful API规范

RESTful API 的规范建议我们使用特定的HTTP方法来对服务器上的资源进行操作。

比如：

  1. GET，表示读取服务器上的资源
  2. POST，表示在服务器上创建资源
  3. PUT,表示更新或者替换服务器上的资源
  4. DELETE，表示删除服务器上的资源
  5. PATCH，表示更新/修改资源的一部分

请求方法

比如

	r.GET("/get", func(ctx *gin.Context) {
		ctx.JSON(200, "get")
	})
	r.POST("/post", func(ctx *gin.Context) {
		ctx.JSON(200, "post")
	})
	r.DELETE("/delete", func(ctx *gin.Context) {
		ctx.JSON(200, "delete")
	})
	r.PUT("/put", func(ctx *gin.Context) {
		ctx.JSON(200, "put")
	})

如果想要支持所有：

r.Any("/any", func(ctx *gin.Context) {
		ctx.JSON(200, "any")
	})

如果想要支持其中的几种：

   r.GET("/hello", func(ctx *gin.Context) {
		//数组 map list 结构体
		ctx.JSON(200, gin.H{
			"name": "hello world",
		})
	})
	r.POST("/hello", func(ctx *gin.Context) {
		//数组 map list 结构体
		ctx.JSON(200, gin.H{
			"name": "hello world",
		})
	})

URI

URI书写的时候，我们不需要关心scheme和authority这两部分，我们主要通过path和query两部分的书写来进行资源的定位

  • 静态url，比如/hello，/user/find

    r.POST("/user/find", func(ctx *gin.Context) {
})

  • 路径参数，比如/user/find/:id

    r.POST("/user/find/:id", func(ctx *gin.Context) {
		param := ctx.Param("id")
		ctx.JSON(200, param)
	})

  • 模糊匹配，比如/user/*path

    r.POST("/user/*path", func(ctx *gin.Context) {
		param := ctx.Param("path")
		ctx.JSON(200, param)
})

处理函数

定义：

type HandlerFunc func(*Context)

通过上下文的参数，获取http的请求参数，响应http请求等。

分组路由

在进行开发的时候，我们往往要进行模块的划分，比如用户模块，以user开发，商品模块，以goods开头。

或者进行多版本开发，不同版本之间路径是一致的，这种时候，就可以用到分组路由了。

比如:

  ug := r.Group("/user")
	{
		ug.GET("find", func(ctx *gin.Context) {
			ctx.JSON(200, "user find")
		})
		ug.POST("save", func(ctx *gin.Context) {
			ctx.JSON(200, "user save")
		})
	}
	gg := r.Group("/goods")
	{
		gg.GET("find", func(ctx *gin.Context) {
			ctx.JSON(200, "goods find")
		})
		gg.POST("save", func(ctx *gin.Context) {
			ctx.JSON(200, "goods save")
		})
	}

请求参数

GET请求参数

使用Get请求传参时，类似于这样 http://localhost:8080/user/save?id=11&name=zhangsan。

如何获取呢？

  • 1.1 普通参数

    request url: http://localhost:8080/user/save?id=11&name=zhangsan

    r.GET("/user/save", func(ctx *gin.Context) {
		id := ctx.Query("id")
		name := ctx.Query("name")
		ctx.JSON(200, gin.H{
			"id":   id,
			"name": name,
		})
	})

    如果参数不存在，就会给一个默认值

    r.GET("/user/save", func(ctx *gin.Context) {
		id := ctx.Query("id")
		name := ctx.Query("name")
		address := ctx.DefaultQuery("address", "北京")
		ctx.JSON(200, gin.H{
			"id":      id,
			"name":    name,
			"address": address,
		})
	})

    因此，为了正常处理业务，我们需要判断参数是否存在

    r.GET("/user/save", func(ctx *gin.Context) {
		id, ok := ctx.GetQuery("id")
		address, aok := ctx.GetQuery("address")
		ctx.JSON(200, gin.H{
			"id":      id,
			"idok":    ok,
			"address": address,
			"aok":     aok,
		})
	})

    id是数值类型，上述获取的都是string类型，根据类型获取方式：

    type User struct {
	Id   int64  `form:"id"`
	Name string `form:"name"`
}
r.GET("/user/save", func(ctx *gin.Context) {
		var user User
		err := ctx.BindQuery(&user)
		if err != nil {
			log.Println(err)
		}
		ctx.JSON(200, user)
})

    也可以通过这个方式：

    r.GET("/user/save", func(ctx *gin.Context) {
		var user User
		err := ctx.ShouldBindQuery(&user)
		if err != nil {
			log.Println(err)
		}
		ctx.JSON(200, user)
	})

  • 参数是数组

    请求url：http://localhost:8080/user/save?address=Beijing&address=shanghai

    r.GET("/user/save", func(ctx *gin.Context) {
		address := ctx.QueryArray("address")
		ctx.JSON(200, address)
	})

    r.GET("/user/save", func(ctx *gin.Context) {
		address, ok := ctx.GetQueryArray("address")
		fmt.Println(ok)
		ctx.JSON(200, address)
	})

    r.GET("/user/save", func(ctx *gin.Context) {
		var user User
		err := ctx.ShouldBindQuery(&user)
		fmt.Println(err)
		ctx.JSON(200, user)
	})

  • map参数

    请求url：http://localhost:8080/user/save?addressMap[home]=Beijing&addressMap[company]=shanghai

    r.GET("/user/save", func(ctx *gin.Context) {
		addressMap := ctx.QueryMap("addressMap")
		ctx.JSON(200, addressMap)
	})

    r.GET("/user/save", func(ctx *gin.Context) {
		addressMap, _ := ctx.GetQueryMap("addressMap")
		ctx.JSON(200, addressMap)
	})

    map参数 bind并没有支持

POST请求参数

post请求一般是表单参数和json参数

  • 表单参数

    r.POST("/user/save", func(ctx *gin.Context) {
		id := ctx.PostForm("id")
		name := ctx.PostForm("name")
		address := ctx.PostFormArray("address")
		addressMap := ctx.PostFormMap("addressMap")
		ctx.JSON(200, gin.H{
			"id":         id,
			"name":       name,
			"address":    address,
			"addressMap": addressMap,
		})
	})

    r.POST("/user/save", func(ctx *gin.Context) {
		var user User
		err := ctx.ShouldBind(&user)
		addressMap, _ := ctx.GetPostFormMap("addressMap")
		user.AddressMap = addressMap
		fmt.Println(err)
		ctx.JSON(200, user)
	})

  • JSON参数

    {
    "id":1111,
    "name":"zhangsan",
    "address": [
        "beijing",
        "shanghai"
    ],
    "addressMap":{
        "home":"beijing"
    }
}

    r.POST("/user/save", func(ctx *gin.Context) {
		var user User
		err := ctx.ShouldBindJSON(&user)
		fmt.Println(err)
		ctx.JSON(200, user)
	})

路径参数

请求url：http://localhost:8080/user/save/111

r.POST("/user/save/:id", func(ctx *gin.Context) {
		ctx.JSON(200, ctx.Param("id"))
	})

文件参数

r.POST("/user/save", func(ctx *gin.Context) {
		form, err := ctx.MultipartForm()
		if err != nil {
			log.Println(err)
		}
		files := form.File
		for _, fileArray := range files {
			for _, v := range fileArray {
				ctx.SaveUploadedFile(v, "./"+v.Filename)
			}

		}
		ctx.JSON(200, form.Value)
	})

响应

字符串方式

r.GET("/user/save", func(ctx *gin.Context) {
		ctx.String(http.StatusOK, "this is a %s", "ms string response")
	})

JSON方式

r.GET("/user/save", func(ctx *gin.Context) {
		ctx.JSON(http.StatusOK, gin.H{
			"success": true,
		})
	})

XML方式

type XmlUser struct {
	Id   int64  `xml:"id"`
	Name string `xml:"name"`
}
r.GET("/user/save", func(ctx *gin.Context) {
		u := XmlUser{
			Id:   11,
			Name: "zhangsan",
		}
		ctx.XML(http.StatusOK, u)
	})

文件格式

r.GET("/user/save", func(ctx *gin.Context) {
		//ctx.File("./1.png")
		ctx.FileAttachment("./1.png", "2.png")
	})

设置HTTP响应头

r.GET("/user/save", func(ctx *gin.Context) {
		ctx.Header("test", "headertest")
	})

重定向

r.GET("/user/save", func(ctx *gin.Context) {
		ctx.Redirect(http.StatusMovedPermanently, "http://www.baidu.com")
	})

YAML方式

r.GET("/user/save", func(ctx *gin.Context) {
		ctx.YAML(200, gin.H{"name": "ms", "age": 19})
})

模板渲染

模板是golang语言的一个标准库，使用场景很多，gin框架同样支持模板

基本使用

定义一个存放模板文件的templates文件夹

<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>gin_templates</title>
</head>
<body>
{{.title}}
</body>
</html>

后端代码：

package main

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

func main() {
	r := gin.Default()
	// 模板解析
	r.LoadHTMLFiles("templates/index.tmpl")

	r.GET("/index", func(c *gin.Context) {
		// HTML请求
		// 模板的渲染
		c.HTML(http.StatusOK, "index.tmpl", gin.H{
			"title": "hello 模板",
		})
	})

	r.Run(":9090") // 启动server
}

多个模板渲染

如果有多个模板，可以统一进行渲染

// 模板解析,解析templates目录下的所有模板文件
	r.LoadHTMLGlob("templates/**")

如果目录为templates/post/index.tmpl和templates/user/index.tmpl这种，可以

	// **/* 代表所有子目录下的所有文件
	router.LoadHTMLGlob("templates/**/*")

自定义模板函数

   // gin框架给模板添加自定义函数
	r.SetFuncMap(template.FuncMap{
		"safe": func(str string) template.HTML {
			return template.HTML(str)
		},
	})

	// 模板解析,解析templates目录下的所有模板文件
	r.LoadHTMLGlob("templates/**")

	r.GET("/index", func(c *gin.Context) {
		// HTML请求
		// 模板的渲染
		c.HTML(http.StatusOK, "index.tmpl", gin.H{
			"title": "<a href='http://baidu.com'>跳转到其他地方</a>",
		})
	})

<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>gin_templates</title>
</head>
<body>
{{.title | safe}}
</body>
</html>Z

静态文件处理

如果在模板中引入静态文件，比如样式文件

index.css

body{
    background-color: aqua;
}

<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>gin_templates</title>
    <link rel="stylesheet" href="/css/index.css">
</head>
<body>
{{.title}}
</body>
</html>

// 加载静态文件
r.Static("/css", "./static/css")

会话

会话控制涉及到cookie和session的使用

  • cookie

    1. HTTP是无状态协议，服务器不能记录浏览器的访问状态，也就是说服务器不能区分两次请求是否由同一个客户端发出
    2. Cookie就是解决HTTP协议无状态的方案之一
    3. Cookie实际上就是服务器保存在浏览器上的一段信息。浏览器有了Cookie之后，每次向服务器发送请求时都会同时将该信息发送给服务器，服务器收到请求后，就可以根据该信息处理请求
    4. Cookie由服务器创建，并发送给浏览器，最终由浏览器保存

    设置cookie

    func (c *Context) SetCookie(name, value string, maxAge int, path, domain string, secure, httpOnly bool)

    参数说明：

    参数名类型说明
    namestringcookie名字
    valuestringcookie值
    maxAgeint有效时间，单位是秒，MaxAge=0 忽略MaxAge属性，MaxAge<0 相当于删除cookie, 通常可以设置-1代表删除，MaxAge>0 多少秒后cookie失效
    pathstringcookie路径
    domainstringcookie作用域
    secureboolSecure=true，那么这个cookie只能用https协议发送给服务器
    httpOnlybool设置HttpOnly=true的cookie不能被js获取到
    r.GET("/cookie", func(c *gin.Context) {
		// 设置cookie
		c.SetCookie("site_cookie", "cookievalue", 3600, "/", "localhost", false, true)
	})

    获取cookie

    r.GET("/read", func(c *gin.Context) {
		// 根据cookie名字读取cookie值
		data, err := c.Cookie("site_cookie")
		if err != nil {
			// 直接返回cookie值
			c.String(200,data)
			return
		}
		c.String(200,"not found!")
	})

    删除cookie

    通过将cookie的MaxAge设置为-1, 达到删除cookie的目的。

    r.GET("/del", func(c *gin.Context) {
		// 设置cookie  MaxAge设置为-1，表示删除cookie
		c.SetCookie("site_cookie", "cookievalue", -1, "/", "localhost", false, true)
		c.String(200,"删除cookie")
	})

  • session

    在Gin框架中，我们可以依赖gin-contrib/sessionsopen in new window中间件处理session

    安装session包

    go get github.com/gin-contrib/sessions

    package main

import (
	"fmt"
	"github.com/gin-contrib/sessions"
	"github.com/gin-contrib/sessions/cookie"
	"github.com/gin-gonic/gin"
)

func main() {
	r := gin.Default()
	// 创建基于cookie的存储引擎，secret 参数是用于加密的密钥
	store := cookie.NewStore([]byte("secret"))
	// 设置session中间件，参数mysession，指的是session的名字，也是cookie的名字
	// store是前面创建的存储引擎，我们可以替换成其他存储引擎
	r.Use(sessions.Sessions("mysession", store))

	r.GET("/hello", func(c *gin.Context) {
		// 初始化session对象
		session := sessions.Default(c)
		// 通过session.Get读取session值
		// session是键值对格式数据，因此需要通过key查询数据
		if session.Get("hello") != "world" {
			fmt.Println("没读到")
			// 设置session数据
			session.Set("hello", "world")
			session.Save()
		}
		c.JSON(200, gin.H{"hello": session.Get("hello")})
	})
	r.Run(":8080")
}

    多session

    package main

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

func main() {
	r := gin.Default()
	store := cookie.NewStore([]byte("secret"))
	sessionNames := []string{"a", "b"}
	r.Use(sessions.SessionsMany(sessionNames, store))

	r.GET("/hello", func(c *gin.Context) {
		sessionA := sessions.DefaultMany(c, "a")
		sessionB := sessions.DefaultMany(c, "b")

		if sessionA.Get("hello") != "world!" {
			sessionA.Set("hello", "world!")
			sessionA.Save()
		}

		if sessionB.Get("hello") != "world?" {
			sessionB.Set("hello", "world?")
			sessionB.Save()
		}

		c.JSON(200, gin.H{
			"a": sessionA.Get("hello"),
			"b": sessionB.Get("hello"),
		})
	})
	r.Run(":8080")
}

中间件

在Gin框架中，中间件（Middleware）指的是可以拦截http请求-响应生命周期的特殊函数，在请求-响应生命周期中可以注册多个中间件，每个中间件执行不同的功能，一个中间执行完再轮到下一个中间件执行

中间件的常见应用场景如下：

  • 请求限速
  • api接口签名处理
  • 权限校验
  • 统一错误处理

Gin支持设置全局中间件和针对路由分组设置中间件，设置全局中间件意思就是会拦截所有请求，针对分组路由设置中间件，意思就是仅对这个分组下的路由起作用

中间件使用

 r := gin.New()
	// 通过use设置全局中间件
	// 设置日志中间件，主要用于打印请求日志
	r.Use(gin.Logger())
	// 设置Recovery中间件，主要用于拦截paic错误，不至于导致进程崩掉
	r.Use(gin.Recovery())
	r.GET("/test", func(ctx *gin.Context) {
		panic(errors.New("test error"))
	})
	r.Run(":8080")

自定义中间件

使用Use可以使用gin自带的中间件或者其他第三方中间件，也可以自己开发中间件

package main
// 导入gin包
import (
"github.com/gin-gonic/gin"
	"log"
	"time"
)

// 自定义个日志中间件
func Logger() gin.HandlerFunc {
	return func(c *gin.Context) {
		t := time.Now()

		// 可以通过上下文对象，设置一些依附在上下文对象里面的键/值数据
		c.Set("example", "12345")

		// 在这里处理请求到达控制器函数之前的逻辑
     
		// 调用下一个中间件，或者控制器处理函数，具体得看注册了多少个中间件。
		c.Next()

		// 在这里可以处理请求返回给用户之前的逻辑
		latency := time.Since(t)
		log.Print(latency)

		// 例如，查询请求状态吗
		status := c.Writer.Status()
		log.Println(status)
	}
}

func main() {
	r := gin.New()
	// 注册上面自定义的日志中间件
	r.Use(Logger())

	r.GET("/test", func(c *gin.Context) {
		// 查询我们之前在日志中间件，注入的键值数据
		example := c.MustGet("example").(string)
		// it would print: "12345"
		log.Println(example)
	})

	// Listen and serve on 0.0.0.0:8080
	r.Run(":8080")
}

	panic(errors.New("test error"))
})
r.Run(":8080")


### 自定义中间件

使用Use可以使用gin自带的中间件或者其他第三方中间件，也可以自己开发中间件

```go
package main
// 导入gin包
import (
"github.com/gin-gonic/gin"
	"log"
	"time"
)

// 自定义个日志中间件
func Logger() gin.HandlerFunc {
	return func(c *gin.Context) {
		t := time.Now()

		// 可以通过上下文对象，设置一些依附在上下文对象里面的键/值数据
		c.Set("example", "12345")

		// 在这里处理请求到达控制器函数之前的逻辑
     
		// 调用下一个中间件，或者控制器处理函数，具体得看注册了多少个中间件。
		c.Next()

		// 在这里可以处理请求返回给用户之前的逻辑
		latency := time.Since(t)
		log.Print(latency)

		// 例如，查询请求状态吗
		status := c.Writer.Status()
		log.Println(status)
	}
}

func main() {
	r := gin.New()
	// 注册上面自定义的日志中间件
	r.Use(Logger())

	r.GET("/test", func(c *gin.Context) {
		// 查询我们之前在日志中间件，注入的键值数据
		example := c.MustGet("example").(string)
		// it would print: "12345"
		log.Println(example)
	})

	// Listen and serve on 0.0.0.0:8080
	r.Run(":8080")
}
Suk-god
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
golang-gin框架快速入门--推荐
wtt234的专栏
10-25 1426
检查上述三个地方的设置，看看是否正确，重点是工modules这个地方设置，查看是否启用了国内代理。go env :命令后，获取安装gin的国内代理，解决访问国外网站下载包慢的问题。验证是否正确安装了包以及是否包内有文件，确保程序的可用性。5.4第四种方式，获取前端的表单传送的数据，到后端。3.4增强效果展示--css样式--背景设置。代码--user组里面的add，update。3.5增强效果展示-js-设置-背景设置。6.2任何没有的路由的 404页面。3.6index.html修改。
go语言学习（二）——Gin 框架简介
金荣的个人技术博客
05-25 2249
GoWeb开发有很多框架，如Beego、Gin、Revel、Echo、IRis等，学习框架可以快速做开发，对比常见goweb框架，通过其github的活跃度，维护的team，生产环境中的使用率以及师兄的推荐，个人选择了学习Gin这个轻巧框架。 1. Gin框架简介 Gin是一个golang的微框架，基于 httprouter，封装比较优雅，API友好，源码注释比较明确。具有快速灵活，容错率高，高性能等特点。框架更像是一些常用函数或者工具的集合。借助框架开发，不仅可以省去很多常用的封装带来的时间，也有助于团队
2024年最新Golang 框架介绍_golang框架(1)，腾讯T2手把手教你
最新发布
2401_84920056的博客
05-11 616
它具有快速、高效和易用的特点，是构建高性能 RESTful API 的理想选择。Echo 是一个高性能的、极简的 Web 框架，它专注于提供快速的路由和中间件。Echo 的设计目标是简洁、易用和高效，它在性能方面表现出色，并且具有与标准库兼容的 API 接口。如果你注重性能和简洁的设计，并且在路由和中间件方面有更高的要求，Echo 是一个不错的选择。如果你需要一个全功能的框架，并且关注开发效率和可维护性，Beego 是一个不错的选择。如果你需要一个快速、高性能和易于使用的框架，Gin 是一个不错的选择。
golang-gin框架入门
wspppdy的博客
04-14 1786
相当于spring的拦截器，其中的Context的Next方法决定拦截前后。上下文对象同样是gin的基础，在gin中context方法非常的多。类似SpringBoot的SpringApplication；在go和go框架中，上下文是一个非常核心的概念，，当然和原生Context有点不同。到这里启动基本完成，
Golang | Web开发之Gin框架快速入门基础实践
WeiyiGeek 唯一极客IT知识分享
06-11 1123
描述: Gin 是一个用 Go (Golang) 编写的 web 框架, 它提供类似Martini的API，但性能更佳，速度提升高达40倍, 号称是Go语言最快的全功能Web框架,所以如果你是性能和高效的追求者,你会爱上 Gin.官网地址: https://gin-gonic.com/帮助文档: https://gin-gonic.com/zh-cn/docs/
Golang有那些开源框架值得学习？
YKM_2580的博客
08-05 771
1.相比其他框架，Echo 的社区相对较小，可能会影响到对问题的解决效率。2.支持多种数据库（如 MySQL、PostgreSQL 等）3.支持多种数据库（如 MySQL、PostgreSQL 等）2.支持多种数据库（如 MySQL、PostgreSQL 等）2.支持多种数据库（如 MySQL、PostgreSQL 等）1.功能强大，提供了路由、ORM、模板引擎、会话管理等工具。1.在性能方面可能不如其他 ORM 框架（如 Xorm）1.在性能方面可能不如其他 Web 框架（如 Gin）
Golang+Gin框架入门实战教程
10-12
Go 即Golang，是Google公司2009年11月正式对外公开的一门编程语言。本教程是IT营大地老师在2020年4月份最新录制的golang视频教程，视频 课件 源码等配套资料齐全，教程持续更新，敬请关注。 根据Go语言开发者自述，...
golang实战使用gin+xorm搭建go语言web框架详解.pdf
09-19
golang实战使用gin+xorm搭建go语言web框架详解.pdf
Gin+Gorm开发Golang API快速开发脚手架-Golang开发
05-26
Gin+Gorm开发Golang API快速开发脚手架 Singo Singo: Simple Single Golang Web Service go-crud正式改名为Singo! 使用Singo开发Web服务: 用最...Gin-Session: Gin框架提供的Session操作工具 Go-Redis: Golang Redis
基于Gin的Golang API入门套件-Golang开发
05-26
这是一个基于Gin框架的API框架项目。 我们的目标是减少使用API​​时经常会遇到的默认功能的开发时间。 下面介绍了一组有用的工具。 随时贡献！ 概述这是一个基于Gin框架的API框架项目。 我们的目标是减少使用API​...
Gin是用Go（Golang）编写的HTTP Web框架。 它具有类似于Martini的API，性能更高-快40倍。 如果您需要出色的性能，请给自己一些杜松子酒。-Golang开发
05-26
Gin Web框架Gin是用Go（Golang...目录Gin Web框架目录安装快速入门基准Gin v1。 使用jsoniter API稳定的构建示例使用GET，POST，PUT，PATCH，DELETE和OPTIONS路径中的参数Querystring参数多部分/未编码形式另一个示例：
go 语言框架 gin中文文档
09-11
go 语言框架 gin 的中文文档。说明 安装与配置 框架架构 路由 控制器 请求 响应 中间件 数据库
Zinx--Golang轻量级并发服务器框架
03-18
我们为什么要做Zinx，Golang目前在服务器的应用框架很多，但是应用在游戏领域或者其他长链接的领域的轻量级企业框架甚少。 ​ 设计Zinx的目的是我们可以通过Zinx框架来了解基于Golang编写一个TCP服务器的整体轮廓，让更多的Golang爱好者能深入浅出的去学习和认识这个领域。 ​ Zinx框架的项目制作采用编码和学习教程同步进行，将开发的全部递进和迭代思维带入教程中，而不是一下子给大家一个非常完整的框架去学习，让很多人一头雾水，不知道该如何学起。 ​ 教程会一个版本一个版本迭代，每个版本的添加功能都是微小的，让一个服务框架小白，循序渐进的曲线方式了解服务器框架的领域。 ​ 当然，最后希望Zinx会有更多的人加入，给我们提出宝贵的意见，让Zinx成为真正的解决企业的服务器框架！在此感谢您的关注！
Go语言中的Gin框架的初步使用
ZN175623的博客
11-05 1519
2、这时候如果遇到问题资源加载不了，解决方法是使用代理（这块有个 go env 的命令，可以查看当前配置），在cmd中运行。设置后，重新运行 go get -u github.com/gin-gonic/gin 可以很快速的安装。1、框架文档介绍：go get -u github.com/gin-gonic/gin。Gin RestFul 非常简单。
go语言gin框架教程
12-29
Gin 是一个用 Go (Golang) 编写的 HTTP web 框架。 它是一个类似于 martini 但拥有更好性能的 API 框架, 由于 httprouter，速度提高了近 40 倍。如果你需要极好的性能，使用 Gin 吧。
go-gin框架
roning的博客
03-27 8750
Gin是一个golang的微框架，封装比较优雅，API友好，源码注释比较明确，已经发布了1.0版本。具有快速灵活，容错方便等特点
优秀的golang开源框架
Haikuotiankong11111的博客
09-20 765
Gin：高性能的 Web 框架，适用于构建 RESTful API 和 Web 应用。golang/oauth2：OAuth 2.0 的 Go 库，提供了安全认证支持。Resty：简化 HTTP 请求的库，支持链式调用和各种请求方法。Memcached：用于 Memcached 的 Go 客户端库。go-swagger：用于 Swagger 的 Go 生成工具。Casbin：强大的访问控制库，支持 RBAC、ABAC 等。Gorilla：并发编程库，提供了各种有用的并发工具。
Gin 好用的golang服务框架
右见小栈
04-02 2021
Gin闪亮登场 简介 Gin是一个golang的微框架，封装比较优雅，API友好，源码注释比较明确。 Gin特点主要有： 速度快、性能优；支持中间件操作，方便编码处理；非常简单的实现路由等。 安装gin框架库 go get -u github.com/gin-gonic/gin 基架搭建 package main import ( "github.com/gin-gonic/gin" ) func main() { // 创建一个 默认的 路由引擎 r := gin.Default()
golang中gin框架的基础学习和运用
土豆科技的博客
07-25 4933
    1.安装 go get gopkg.in/gin-gonic/gin.v1   2.基本的架构     2.1  直接调用方案 package main import ( "github.com/gin-gonic/gin" "net/http" ) func main() { r := gin.Default() r.GET("/ping", func(c ...
golang gin框架 项目实战
05-30
好的，我可以为您提供一些关于使用 Golang Gin 框架进行项目实战的建议。 首先，您需要安装 Golang 和 Gin 框架。安装过程可以参考官方文档进行操作。然后，您可以按照以下步骤进行项目实战： 1. 创建项目结构 在...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Suk-god

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值