go web 开发 学习笔记之gin框架学习

最新推荐文章于 2024-06-16 15:37:05 发布
最新推荐文章于 2024-06-16 15:37:05 发布
阅读量774 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lintiyan/article/details/105023954
版权

gin入门

index.html

<html>
	<head>
		<title>
			index.html
		</title>
	</head>
	<body>
		{{.title}}
	</body>
</html>

main.go

package main

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

func main(){
	//创建默认路由引擎
	r := gin.Default()
	//设置路由和渲染数据
	r.Get("/index", func (c *gin.Context){
		c.JSON(http.StatusOK,gin.H{
			"title":"lijiahui",
		})
	})
	//启动服务
	r.Run(":8080")
}

启动服务后访问 localhost:8080/index结果如下
在这里插入图片描述

1. gin模板使用

（1）demo

index.html

<html>
	<head>
		<title>
			index.html
		</title>
	</head>
	<body>
		{{.title}}
	</body>
</html>

main.go

package main

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

func main(){
	//定义默认路由引擎
	r := gin.Default()
	//模板解析
	r.LoadHTMLFiles("index.html")
	//定义路由 渲染模板
	r.GET("/index",func(c *gin.Context){
		c.HTML(http.StatusOK,"index.html",gin.H{
			"title":"lijiahui",
		})
	})
	//启动服务
	r.Run(":8080")
}

访问结果为
在这里插入图片描述

（2）gin框架默认将传入模板的数据转义，如果我们想要它不转义，同样需要自定义方法

<html>
	<head>
		<title>
			不转义
		</title>
	</head>
	<body>
		{{safe .title}}
	</body>
</html>

main.go

package main

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

func main(){

	r := gin.Default()
	//自定义模板方法
	r.SetFuncMap(template.FuncMap{
		"safe" : func(str string)template.HTML{
			return template.HTML(str)
		},
	})
	//解析模板
	r.LoadHTMLFiles("index.html")
	//定义路由 
	r.GET("/index",func(c *gin.Context){
		//渲染模板
		c.HTML(http.StatusOK,"index.html",gin.H{
			"title":"<a href='http://www.baidu.com'>百度</a>"
		}),
	})
	//启动服务
	r.Run(":8080")
}

访问结果是：
在这里插入图片描述

(3) 静态文件处理

静态文件是一般指一些样式文件(.css,js)或者图片等。gin处理静态文件如下:

index.html

<html>
	<head>
		<title>
			静态文件
		</title>
		<link rel="stylesheet" href="/static/css/index.css"/>
	</head>
	<body>
	
	</body>
</html>

index.css

body{
	background-color:burlywood;
}

main.go

package main

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

func main(){
	r := gin.Default()

	//定义静态文件访问路由。前一个参数代指静态文件的访问路径，
	//后一个参数指该路径对应项目中的文件目录,这里是相对于main.go文件的相对路径
	r.Static("/static","./static")
	r.LoadHTMLFiles("index.html")
	r.GET("/index",func(c *gin.Context){
		c.HTML(http.StatusOK,"index.html",nil)
	})
	r.Run(":8080")
}

项目结构如下：
在这里插入图片描述
访问的结果如下：
在这里插入图片描述
背景色被换成了深黄色。

（4）返回json和返回结构体

package main

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

func main(){
	r := gin.Default()
	r.GET("index",func(c *gin.Context){
		c.JSON(http.StatusOK,gin.H{
			"name":"lijiahui",
			"age":20,
			"address":"China",
		})
	})
	r.Run(":8080")
}

访问结果为
在这里插入图片描述
如果需要返回结构体，则可以如下处理

func main(){

	r := gin.Default()
	type MSG struct{
		name string
		Age int64
		Address string
	}
	data = MSG{
		name:"lijiahui",
		Age :20,
		Address : "China",
	}
	r.GET("/index2",func(c *gin.Context){
		c.JSON(http.StatusOK,data)
	})
	r.Run(":8080")
}

访问结果是
在这里插入图片描述
可以看到向前端响应的json中，name字段的值不见了，这是因为gin框架中对数据的序列化默认还是采用原生的序列化方法，对于结构体中小写的字段会被隐藏，此时要让前端能接收到小写字段的数据，可以使用tag
如：

func main(){

	r := gin.Default()
	type MSG struct{
		Name string `json:"name"`
		Age int64 `json:age`
		Address string `json:address`
	}
	data = MSG{
		name:"lijiahui",
		Age :20,
		Address : "China",
	}
	r.GET("/index2",func(c *gin.Context){
		c.JSON(http.StatusOK,data)
	})
	r.Run(":8080")
}

访问结果为：
在这里插入图片描述

2. gin获取请求参数

（1）gin获取querystring上的参数，即get请求的参数

package main

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

func main(){
	r := gin.Default()

	r.GET("/index",func(c *gin.Context){
		//方式一
		name := c.Query("name")
		//方式二
		name := c.DefaultQuery("name","BBB")
		//方式三
		name,ok := c.GetQuery("name")
		c.JSON(http.StatusOK,name)
	})
	
	r.Run(":8080")
}

方式一：
在这里插入图片描述
方式二：
在这里插入图片描述
方式三：
在这里插入图片描述

（2）gin获取post请求的参数，即表单提交参数

login.html

<html>
	<head>
		<title>
			登录
		</title>
	</head>
	<body>
		<form action="/login" method="post">
			用户名：<input name="username" placeholder="用户名" />
			密码：<input name="password" placeholder="密码" />
			<input type="submit" value="提交" />
		</form>
	</body>
</html>

package main

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

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

	r.POST("/login",func(c *gin.Context){
		//方式一
		//username := c.PostForm("username")
		//password := c.PostForm("password")
		//方式二
		username := c.DefaultPostForm("username","小刘")
		password := c.DefaultPostForm("xx","xxxxx")
		c.JSON(http.StatusOK,gin.H{
			"username":username,
			"password":password,
		})
	})
	r.Run(":8080")
}

方式一的访问结果
在这里插入图片描述
方式二的访问结果：
在这里插入图片描述
方式三：
在这里插入图片描述

（3）获取path路径的参数

当请求采用 http://localhost:8080/user/zhangsan/18这种方式来传递参数，该怎么获取路径上的参数呢

package main

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

func main(){
	r:= gin.Default()
	
	r.GET("/login/:username/:age",func(c *gin.Context){
		username :=  c.Param("username")
		age := c.Param("age")
		c.JSON(http.StatusOK,gin.H{
			"username":username,
			"age":age,
		})
	})
	r.Run(":8080")
}

访问结果是
在这里插入图片描述

（4）参数绑定

package main

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

type User struct{
	Username string `form:"username" json:"username"`
	Password string `form:"password" json:"password"`
}

func main(){
	r := gin.Default()
	//方式一 ：query string方式参数绑定
	r.GET("/login2",func(c *gin.Context){
		var u User
		r.ShouldBind(&u)
		c.JSON(http.StatusOK,gin.H{
			"username" :username,
			"password" :password,
		})
	})
	//方式二 ： form表单提交方式
	r.LoadHTMLFiles("login.html")
	r.GET("/login",func(c *gin.Context){
		c.HTML(http.StatusOK,"login.html",nil)
	})
	r.POST("/login",func(c *gin.Context){
		var u User
		c.ShouldBind(&u)
		c.JSON(http.StatusOK,gin.H{
			"username":username,
			"password":password,
		})
	})
	//方式三 ： json提交方式
	r.POST("/login",func(c *gin.Context){
		var u User
		c.ShouldBind(&u)
		c.JSON(http.StatusOK,gin.H{
			"username":username,
			"password":password,
		})
	})
	r.Run(":8080")
}

login.html

<html>
	<head>
		<title>
			表单提交方式
		</title>
	</head>
	<body>
		<form action="/login" method="post">
		<div>
			<input name="username" type="text" value="用户名" />
		</div>
		<div>
			<input name="password" type="password" value="密码" />
		</div>
		<div>
			<input type="submit" value="提交"/>
		</div>
		</form>
	</body>
</html>

方式一的结果为
在这里插入图片描述
方式二的结果为
在这里插入图片描述
方式三的访问结果为：
在这里插入图片描述

（5）文件上传

  1. 单个文件上传

upload.html

<html>
	<head>
		<title>
			单个文件上传
		</title>
	</head>
	<body>
		<form action="/upload" method="post" enctype="multipart/form-data">
			上传文件<input type="file" name="file" value="选择文件"/>
			<input type="submit" value="提交"/> 
		</form>
	</body>
</html>

main.go

package main

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

func main(){
	router := gin.Default()
	router.LoadHTMLFiles("upload.html")
	router.GET("/upload",func(c *gin.Context){
		c.HTML(http.StatusOK,"upload.html",nil)
	})
	router.POST("/upload",func(c *gin.Context){
		file,err := c.FormFile("file")
		if err != nil{
			c.JSON(http.StatusBadRequest,gin.H{
				"msg":"读取文件失败！",
			})
		}else{
			dst := fmt.Sprintf("./%s",file.Filename)
			c.SaveUploadFile(file,dst)
			c.JSON(http.StatusOK,gin.H{
				"msg":"读取文件成功！"
			})
		}
	})
	
	router.Run(":8080")
}

选择文件上传 结果为：
在这里插入图片描述
在这里插入图片描述
2. 多个文件上传

<html>
	<head>
		<title>
			多个文件上传
		</title>
	</head>
	<body>
		<form action="/upload" method="post" enctype="multipart/form-data">
			<input  type="file" name="files" multipart/>
			<input  type="submit" value="提交"/>
		</form>
	</body>
</html>

main.go

package main

import (
	"github.com/gin=gonic/gin"
)

func main(){
	router:= gin.Default()
	router.LoadHTMLFiles("upload.html")
	router.GET("/upload",func(c *gin.Context){
		c.HTML(http.StatusOK,"upload.html",nil)
	})
	router.POST("/upload",func(c *gin.Context){
		form,_ := c.MultipartForm()
		files := form.File["files"]
		for _,file := range files{
			dst := fmt.Sprintf("./%s",file.Filename)
			c.SaveUploadFile(file,dst)
		}
		c.JSON(http.StatusOK,gin.H{
			"msg":"上传文件成功！"
		})
	})
	router.Run(":8080")
}

上传文件结果：
在这里插入图片描述
在这里插入图片描述

（6）gin请求重定向

（7）路由和路由组

对不同的请求，gin框架有不同的方法来处理， 如 GET ,POST,PUT,DELETE
路由组的概念就是在路由的路径的前半部分有很大相似的时候，单独将相同的部分设置为一个路由组，提高代码的可读性和整洁性 如下：

package main
import (
	"github.com/gin-gonic/gin"
)

func main(){
	router:=gin.Default()
	router.GET("/index/get1",func(c *gin.Context){
		c.JSON(http.StatusOK,gin.H{
			"msg":"/index/get1OK",
		})
	})
	router.GET("/index/get2",func(c *gin.Context){
		c.JSON(http.StatusOK,gin.H{
			"msg":"/index/get2OK",
		})
	})
	//上面的代码路由的前缀 相似，都有 "/index/"，此时就可以设置一个路由组，增加可读性和整洁性
	indexGroup := router.Group("/index")
	indexGroup.GET("/get3",func(c *gin.Context){
		c.JSON(http.StatusOK,gin.H{
			"msg":"/group/index/get3OK",
		})
	})
	indexGroup.GET("/get4",func(c *gin.Context){
		c.JSON(http.StatusOK,gin.H{
			"msg":"/group/index/get4OK",
		})
	})
	router.Run(":8080")
}

（8）中间件

gin框架允许开发者在处理请求的过程中加入自己的钩子函数，所谓钩子函数就是，在正常的处理逻辑中间加入一个函数能做其他的跟业务无关的处理（也可以相关把），像个钩子一样挂在正常的逻辑线上。通常钩子函数用于 处理 日志、计时、登录认证、权限控制等。这样的钩子函数就是中间件

  1. 定义一个钩子函数（中间件）
    main.go
package main
import (
	"time"
	"fmt"
	"github.com/gin-gonic/gin"
)
//midWare 中间件函数
func midWare()func(c *gin.Context){
	return func(c *gin.Context){
		fmt.Println("midware in...")
		start := time.Now()
		//c.Next()函数表示让下一个钩子函数执行，
		//且下一个钩子函数执行完成之前不会执行c.Next()后面的代码
		c.Next()
		cost:= time.Since(start)
		fmt.Println("cost :",cost)
		fmt.Println("midware out...")
	}
}

func main(){
	......
}
  1. 为单个路由注册一个中间件
package main

import (
	"time"
	"fmt"
	"github.com/gin-gonic/gin"
)

//midWare 中间件函数
func midWare()func(c *gin.Context){
	return func(c *gin.Context){
		fmt.Println("midware in...")
		start := time.Now()
		//c.Next()函数表示让下一个钩子函数执行，
		//且下一个钩子函数执行完成之前不会执行c.Next()后面的代码
		c.Next()
		cost:= time.Since(start)
		fmt.Println("cost :",cost)
		fmt.Println("midware out...")
	}
}

func main(){
	router := gin.Default()
	router.GET("/index",midWare(),func(c *gin.Context){
		c.JSON(http.StatusOK,gin.H{
			"msg":" test midWare",
		})
	})
	router.Run(":8081")
}

访问的执行结果是：
在这里插入图片描述
3. 为全局路由注册中间件

package main

import (
	"time"
	"fmt"
	"github.com/gin-gonic/gin"
)

//midWare 中间件函数
func midWare()func(c *gin.Context){
	return func(c *gin.Context){
		fmt.Println("midware in...")
		start := time.Now()
		//c.Next()函数表示让下一个钩子函数执行，
		//且下一个钩子函数执行完成之前不会执行c.Next()后面的代码
		c.Next()
		cost:= time.Since(start)
		fmt.Println("cost :",cost)
		fmt.Println("midware out...")
	}
}

func main(){
	router := gin.Default()
	//在这里设置全局路由中间件
	router.Use(midWare())
	router.GET("/index",func(c *gin.Context){
		c.JSON(http.StatusOK,gin.H{
			"msg":" test midWare",
		})
	})
	router.Run(":8081")
}
  1. 为路由组注册中间件
package main

import (
	"time"
	"fmt"
	"github.com/gin-gonic/gin"
)

func main(){
	router := gin.Default()
	//方式一
	indexGroup := router.Group("/index",midWare())
	{
		indexGroup.GET("/a",func(c *gin.Context){
			c.JSON(http.StatusOK,gin.H{
				"msg":"test /index/a",
			})
		})
		indexGroup.GET("/b",func(c *gin.Context){
			c.JSON(http.StatusOK,gin.H{
				"msg":"test /index/b",
			})
		})
	}
	
	//方式二
	index2Group := router.Group("/index2")
	//使用User()方法
	index2Group.Use(midWare())
	{
		index2Group.GET("/c",func(c *gin.Context){
			c.JSON(http.StatusOK,gin.H{
				"msg":"test /index2/c",
			})
		})
		index2Group.GET("/d",func(c *gin.Context){
			c.JSON(http.StatusOK,gin.H{
				"msg":"test /index2/d",
			})
		})
	}
	router.Run(":8081")
}

注意事项：

  1. gin框架中默认添加了两个中间件 Logger(), Recovery().

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

可以使用gin.New()创建一个不含上述两个中间件的路由引擎
2. *当在中间件或handler中启动新的goroutine时，不能使用原始的上下文（c gin.Context），必须使用其只读副本（c.Copy()）。

lintiyan
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Go Web开发框架 Gin
weixin_51487151的博客
05-17 613
Go Web开发框架 Gin 10.1 Gin 现在的开发模式是后端只提供一份数据，然后不管是移动端还是网页端，如果想要展现出不同的效果，可以自己根据这份数据个性化构建展示效果 下载Gin package GOPROXY=https://goproxy.cn go get -u github.com/gin-gonic/gin 引入使用即可 import "github.com/gin-gonic/gin" //使用Gin框架 func main() { r := gin.Default() //
完整Web开发的go-gin
10-15
使用go-gin作为Web开发后台，该项目基于go-gin框架，其中加入了完整的mysql数据库支持（sqlserver只需修改连接配置即可使用），swagger接口文档的支持等
【Go语言】Gin 框架教程
最新发布
Python、Golang、大数据
06-16 1651
开头，通过分组路由就能够简化路由的定义，也可以更好的实现路由的权限控制，例如将需要登录的路由放到同一分组中。这里使用一个表单参数进行举例，如下所示，输入分数转化为及格、不及格的判断，代码如下所示。请求其他的路由，则不受影响，就如我们在中间件方法所写的判断一样，仅仅只是拦截了。分组路由主要是为了处理路由前缀一致的情况，例如有一组路由前缀都是。程序，重启之后，再次访问路由地址，就能够正常解析路由参数了。与上文的路由参数一样，参数都是路由的一部分，不同的是。请求不同的路由地址，均能够得到正常的响应。
Go的web开发Gin框架1（八）——Gin
qq_54353206的博客
02-13 1237
​ Gin是一个golang的微框架，封装比较优雅，API友好，源代码比较明确。具有快速灵活，容错方便等特点。其实对于golang而言，web框架的依赖远比Python，Java之类的要小。自身的net/http足够简单，性能也非常不错。框架更像是一个常用函数或者工具的集合。借助框架开发，不仅可以省去很多常用的封装带来的时间，也有助于团队的编码风格和形成规范。Gin官方文档地址此处学习了go的Gin框架，了解了gin框架的强大，设置可以直接编译成exe文件跨平台运行。
【Gin】Golang Web开发之Gin框架
weixin_45685541的博客
01-30 1104
Golang Web开发之Gin框架概述安装Gin框架Custom HTTP configuration 自定义HTTP配置Gin URLGin文件上传服务Gin中间件自定义日志输出格式 Custom Log Format请求参数的模型绑定 Model binding and validation自定义请求参数验证参数绑定Uri （Bind Uri）参数请求头（Bind Header）Bind HTML checkboxesGin框架的JSON 介绍Gin文件管理HTML模版Custom Template
Go 语言 Web 开发利器：Gin 框架详解
m0_62153576的博客
10-13 283
Gin 框架是一个灵活、高性能的 Web 框架，通过本文的详细介绍，你应该已经掌握了如何使用 Gin 进行 Web 开发。这只是一个入门，你还可以深入学习 Gin 的中间件、插件等高级特性，构建出更为复杂和功能强大的 Web 应用。希望这篇文章能够成为你学习和使用 Gin 框架的有力指南。在 Web 开发领域，Gin 框架成为了一种流行的选择，它提供了快速、轻量级的 HTTP 框架，适用于构建高性能的 Web 应用程序。本文将详细介绍如何使用 Gin 框架进行 Web 开发。
【Go从入门到实战】学习笔记，从零开始学Go、Gin框架，基本语法包括26个Demo，Gin框架包括：Gin自定义路由配置
05-22
总之，【Go从入门到实战】的学习笔记是学习Go语言和Gin框架的宝贵资源，无论是对Go语言感兴趣的新手，还是希望提升Go开发技能的开发者，都能从中受益匪浅。通过系统学习和实践，你将具备构建高效、稳定、可扩展的Go...
Go-Golang笔记
08-14
- **Gin框架**：Gin是一个基于Go的web框架，用于快速开发API和Web服务，简洁高效。 通过深入学习和实践这些知识点，你可以逐步掌握Go语言，并利用其特性构建高效稳定的系统和服务。Go-Golang笔记旨在帮助初学者和...
study-go:go学习笔记
07-22
这个“study-go:go学习笔记”很可能是某位开发者或者教育者整理的一份关于Go语言的学习资源，包含了对Go语言基础知识、语法特性、并发模型以及常见库和框架的深入讲解。 在Go语言的学习中，有几个关键知识点是必不...
从零开始学 Go，Go 入门的学习笔记
03-07
本学习笔记将从零开始，带你一步步走进 Go 语言的世界。 ### 基础语法 Go 语言的基础语法简洁明了，易于学习。首先，我们来看看变量的声明： ```go var age int = 25 ``` 这里，`int` 是数据类型，`age` 是变量名...
后端语言的学习笔记.zip
03-03
"后端语言的学习笔记.zip"这个压缩包很可能包含了关于各种后端编程语言的学习资源，特别是那些用于构建动态网站和Web服务的语言。尽管没有具体的标签提供额外信息，我们可以推测这可能涵盖了诸如Java、Python、Node....
Go Web框架gin的入门教程
09-20
本篇文章主要介绍了Go Web框架gin的入门教程，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
【web框架】go的web框架——gin（详细）
Jzin的博客
11-02 2725
一、gin的helloworld体验 1. 安装 2. 代码 3.使用New和Default初始化路由器的区别 4. 使用get、post、put等http方法 二、url和路由分组 1. 路由分组 2.带参数的url 3. 获取路由分组的参数 三、获取参数 1.获取get参数 2. 获取post参数 3. get、post混合 四、JSON、ProtoBuf 渲染（输出格式） 1.输出json和protobuf 2. PureJSON 五、表单验证 2. 错误翻译改进 等等
快速上手GoWeb开发之Gin框架
weixin_43416686的博客
02-18 877
Go是一门正在快速增长的编程语言，专为构建简单、快速且可靠的软件而设计。golang提供的net/htp库已经很好了，对于htp的协议的实现非常好，基于此再造框架，也不会是难事，因此生态中出现了很多框架。Gin是一个golang的微框架，封装比较优雅，API友好，源码注释比较明确。具有快速灵活，容错方便等特点。Beego: 开源的高性能 Go 语言 Web 框架。
Go gin web框架介绍
学亮编程手记
08-12 584
gin框架介绍 一、gin框架介绍 gin是用go语言开发的一个web框架，简单易用，是一个轻量级框架。 二、为什么选择gin 1.运行响应非常快 2.快速开发 3.文档齐全 4.社区活跃 三、特性 1.快速：基于 Radix 树的路由，小内存占用。没有反射。可预测的 API 性能。 2.支持中间件：传入的 HTTP 请求可以由一系列中间件和最终操作来处理。 例如：Logger，Authorization，GZIP，最终操作 DB。 3.Crash 处理：Gin 可以 catch 一个发生在 HTTP 请求
基于golang语言web框架gin搭建应用-01新建工程
hexiaoyun128的专栏
10-17 1434
简介 因为工作上的需求，由于两个项目都是管理类型的，故在项目开始之处就考虑做一个能够快速开发应用的框架，考虑到时间紧，任务重，同时市面上很多优秀的基于golang的web框架，综合考虑，不重复造轮子，站在巨人的肩膀上，使用了golang的web框架gin来搭建基础框架，在该框架中使用了很多由于的模块，在此感谢作者的付出。 因为是写一个系列文章， 故文章会从零开始来搭建这个框架，大部分代码会从原...
gin框架-2-返回是html格式的网页数据
wtt234的专栏
04-26 1934
程序的组织代码： gin-2这个程序的这个目录下： templateslab.go templates/ index.html 程序代码如下： 注意点： Gin 框架中使用 c.HTML 可以渲染模板，渲染模板前需要使用 LoadHTMLGlob()或者 LoadHTMLFiles()方法加载模板。 package main import ( "github.com/gin-gonic/gin" "net/http" ) //路...
[Golang] gin框架模板渲染html-不显示转码html实体
程序员老狼专注开发aigc或客服系统应用
02-12 513
默认的gin框架模板中，如果模板变量是html文本 展示模板变量的时候是以html实体的形式出现的，不是以html形式渲染的 这个时候，就需要在传递变量的时候简单处理一下 template.HTML类型转换一下 ...
Gin框架学习
xlsj雪松的博客
10-31 1764
Golang web开发常用的框架Gin
go web开发进阶实战(gin框架)
08-15
《Go Web开发进阶实战（Gin框架）》是一本针对Go语言的Web开发者的进阶实战书籍。该书主要以Gin框架作为...无论是初学者还是有一定经验的开发者，都能够从中受益，快速掌握Go语言Web开发中使用Gin框架的技巧和经验。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值