Gin 框架学习笔记（03）— 输出响应与渲染

最新推荐文章于 2024-09-03 09:11:43 发布
最新推荐文章于 2024-09-03 09:11:43 发布
阅读量2.9k 收藏 3
点赞数 1
分类专栏： # Gin 文章标签： golang Gin
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wohu1104/article/details/121928225
版权

在 Gin 框架中，对 HTTP 请求可以很方便有多种不同形式的响应。比如响应为 JSON 、 XML 或者是 HTML 等。
​

Context 的以下方法在 Gin 框架中把内容序列化为不同类型写入到响应主体中。

// HTML 呈现指定文件名的 HTTP 模板。
// 更新 HTTP 状态代码并将 Content-Type设置为 “text/html”。
// 参见 http://golang.org/doc/articles/wiki/
func (c *Context) HTML(code int, name string, obj interface{})

// IndentedJSON 将给定结构序列化为漂亮的 JSON（缩进+结束行）到响应体中。
// 同时将 Content-Type设置为 “application/json”。
// 警告：建议仅将此用于开发目的，因为打印漂亮的 JSON 会占用更多 CPU 和带宽。
// 请改用 Context.JSON() 。
func (c *Context) IndentedJSON(code int, obj interface{})

// SecureJSON 将给定结构序列化为安全 JSON 到响应主体中。
// 如果给定的结构是数组值，则默认将 “while（1）” 添加到响应主体。
// 将 Content-Type设置为 “application/json” 。
func (c *Context) SecureJSON(code int, obj interface{})

// JSONP 将给定结构序列化为 JSON 到响应体中。
// 它可跨域向服务器请求数据。
// 将 Content-Type 设置为 “application/javascript” 。
func (c *Context) JSONP(code int, obj interface{})

// JSON 将给定结构序列化为 JSON 到响应主中。
// 将 Content-Type 设置为 “application/json” 。
func (c *Context) JSON(code int, obj interface{})

// AsciiJSON 将给定结构作为 JSON 序列化到响应体中，并将 Unicode 序列化为 ASCII 字符串。
// 将 Content-Type 设置为 “application/json” 。
func (c *Context) AsciiJSON(code int, obj interface{})

// PureJSON 将给定结构序列化为 JSON 到响应体中。
// 与 JSON 不同，PureJSON 不会用他们的 Unicode 实体替换特殊的 HTML 字符。
func (c *Context) PureJSON(code int, obj interface{})

// XML 将给定结构序列化为 XML 到响应体中。
// 将 Content-Type 设置为 “application/xml” 。
func (c *Context) XML(code int, obj interface{})

// YAML 将给定结构序列化为 YAML 到响应体中。
func (c *Context) YAML(code int, obj interface{})

// ProtoBuf 将给定结构序列化为 ProtoBuf 到响应体中。
func (c *Context) ProtoBuf(code int, obj interface{})

// String 将给定字符串写入到响应体中。
func (c *Context) String(code int, format string, values ...interface{})

// Redirect 将 HTTP 重定向返回到特定位置。
func (c *Context) Redirect(code int, location string)

// Data 将一些数据写入正文流并更新 HTTP 状态代码。
func (c *Context) Data(code int, contentType string, data []byte)

// DataFromReader 将指定的读取器写入正文流并更新 HTTP 代码。
func (c *Context) DataFromReader(code int, contentLength int64, contentType string, reader io.Reader, extraHeaders map[string]string)

// File 以有效的方式将指定的文件写入正文流。
func (c *Context) File(filepath string)

// FileAttachment 以有效的方式将指定的文件写入正文流中在客户端，
// 通常会使用给定的文件名下载该文件。
func (c *Context) FileAttachment(filepath, filename string)

// SSEvent 将 Server-Sent 事件写入正文流。
func (c *Context) SSEvent(name string, message interface{})

// Stream 发送流响应并返回布尔值，表示“客户端在流中间断开连接”。
func (c *Context) Stream(step func(w io.Writer) bool) bool

1. XML/JSON/YAML/ProtoBuf 响应

这些响应的方法可以把数据序列化为对应数据编码方式。

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

    router.GET("/someJSON", func(c *gin.Context) {
        c.JSON(http.StatusOK, gin.H{"userinfo": "Mo", "status": http.StatusOK})
    })

    router.GET("/moreJSON", func(c *gin.Context) {
        // 也可使用一个结构体
        var msg struct {
            Name     string `json:"user"`
            UserInfo string
            Number   int
        }
        msg.Name = "Lena"
        msg.UserInfo = "Mo"
        msg.Number = 123
        // 注意 msg.Name 在 JSON 中变成了 "user"
        c.JSON(http.StatusOK, msg)
    })

    router.GET("/someXML", func(c *gin.Context) {
        c.XML(http.StatusOK, gin.H{"userinfo": "Mo", "status": http.StatusOK})
    })

    router.GET("/someYAML", func(c *gin.Context) {
        c.YAML(http.StatusOK, gin.H{"userinfo": "Mo", "status": http.StatusOK})
    })

    router.GET("/someProtoBuf", func(c *gin.Context) {
        name := "Lena"
        // protobuf 的具体定义写在 pb/user文件中。
        data := &pb.UserInfo{
            UserType: 101,
            UserName: name,
            UserInfo: "Mo",
        }
        // 将输出被 protobuf 序列化了的数据
        c.ProtoBuf(http.StatusOK, data)
    })

    // 监听并启动服务
    router.Run(":8080")
}

程序运行在 Debug 模式时，在命令行运行下面命令：

curl -v http://localhost:8080/someProtoBuf

命令行返回：

> GET /someProtoBuf HTTP/1.1
> Host: localhost:8080
> User-Agent: curl/7.47.0
> Accept: */*
>
< HTTP/1.1 200 OK
< Content-Type: application/x-protobuf
< Date: Sun, 14 Jul 2019 10:13:42 GMT
< Content-Length: 12
<

继续运行命令：

curl -v http://localhost:8080/someYAML

命令行返回：

> GET /someYAML HTTP/1.1
> Host: localhost:8080
> User-Agent: curl/7.47.0
> Accept: */*
>
< HTTP/1.1 200 OK
< Content-Type: application/x-yaml; charset=utf-8
< Date: Sun, 14 Jul 2019 10:13:45 GMT
< Content-Length: 25
<
status: 200
userinfo: Mo

继续保持程序运行，通过浏览器访问 http://localhost:8080/moreJSON ，页面显示：

{"user":"Lena","UserInfo":"Mo","Number":123}

通过浏览器访问 http://localhost:8080/someJSON ，页面显示：

{"status":200,"userinfo":"Mo"}

通过浏览器访问 http://localhost:8080/someXML ，页面显示：

<map>
<userinfo>Mo</userinfo>
<status>200</status>
</map>

从以上命令行运行命令情况以及浏览器访问显示，以及控制台输出可以看到 Gin 框架可以根据需要，把内容序列化为不同 Content-Type 类型写入到响应体。
​

下面以 c.JSON() 方法为例，来说说这类方法实现渲染的过程，下面是 c.JSON() 方法的定义：

func (c *Context) JSON(code int, obj interface{}) {
    c.Render(code, render.JSON{Data: obj})
}

在 c.Render() 方法中，第二个参数是结构体对象 render.JSON{Data: obj} ，这个结构体定义在 render/json.go 文件中，并且这个结构体还有两个方法：

// Render (JSON) writes data with custom ContentType.
func (r JSON) Render(w http.ResponseWriter) (err error) {
    if err = WriteJSON(w, r.Data); err != nil {
        panic(err)
    }
    return
}

// WriteContentType (JSON) writes JSON ContentType.
func (r JSON) WriteContentType(w http.ResponseWriter) {
    writeContentType(w, jsonContentType)
}

这两个方法实现了在 render/render.go 中定义的接口：

type Render interface {
    // Render writes data with custom ContentType.
    Render(http.ResponseWriter) error
    // WriteContentType writes custom ContentType.
    WriteContentType(w http.ResponseWriter)
}

所以，程序可以通过 c.Render() 这个渲染的通用方法来适配不同的渲染器，因为其第二个参数对应着 render 目录下的众多渲染器，比如 JSONP 、 HTML 等等。这些渲染器都实现了接口 Render ，所以都可以通过 c.Render() 方法来把渲染后的结果响应给客户端。
​

2. JSONP 响应

JSONP 可以向不同域的服务器跨域请求数据。如果查询参数存在回调，则将回调添加到响应体中。在 Gin 框架中，支持 JSONP 响应，下面分两部分来说明 Gin 框架中 JSONP 的使用。
​

服务端输出 JSONP：

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

    router.GET("/jsonp", func(c *gin.Context) {
        data := map[string]interface{}{
            "foo": "bar",
        }

        // callback 是 x
        // 将输出：x({\\"foo\\":\\"bar\\"})
        c.JSONP(http.StatusOK, data)
    })

    // 监听并启动服务
    router.Run(":8080")
}

客户端调用：

<div id="divJsonp"></div>
<script>
$.getJSON("<http://localhost:8080/jsonp?callback=?">, function(data) {
    var html = '<ul>';
    html += '<li>' + data["foo"] + '</li>';
    html += '</ul>';

    $('#divJsonp').html(html);
});
</script>

首先把服务端运行在 Debug 模式，为了模拟跨域，这里把客户端所在目录作为 Web 服务在 8081 端口运行起来。可在浏览器访问：http://localhost:8081/j.html ，页面显示：

  • bar

从控制台输出可以看到服务端正常接收了 jsonp 调用，且浏览器页面能正常展示服务端响应的内容。

3. SecureJSON 响应

SecureJSON() 方法将给定结构序列化为安全 JSON 到响应主体中。如果给定的结构是数组值，则默认将 while (1) 添加到响应主体。该响应方法会将 Content-Type 设置为 application/json 。使用 SecureJSON() 方法来防止 JSON劫持。

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

    // 可以自定义添加安全 JSON 前缀
    // router.SecureJsonPrefix(")]}',\\n")

    router.GET("/someJSON", func(c *gin.Context) {
        names := []string{"lena", "austin", "foo"}

        // SecureJsonPrefix() 设置优先，
        // 否则将会输出:   while(1);["lena","austin","foo"]
        c.SecureJSON(http.StatusOK, names)
    })

    // 监听并启动服务
    router.Run(":8080")
}

运行程序，通过浏览器访问 http://localhost:8080/someJSON ，页面显示：

while(1);["lena","austin","foo"]

如自定义设置安全前缀 router.SecureJsonPrefix(")]}',\\n")，则页面显示：)]}', ["lena","austin","foo"] 。
这些添加前缀的方法对提升数据的读安全有较好的防护作用，在开发中建议要增强数据安全意识，避免不必要安全问题的发生。

4. AsciiJSON 响应

AsciiJSON() 方法将给定结构作为 JSON 序列化到响应体中，并将 Unicode 序列化为 ASCII 字符串。该响应方法会将 Content-Type 设置为 application/json 。

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

    router.GET("/someJSON", func(c *gin.Context) {
        data := gin.H{
            "lang": "GO语言",
            "tag":  "<br>",
        }

        // 输出 : {"lang":"GO\\u8bed\\u8a00","tag":"\\u003cbr\\u003e"}
        c.AsciiJSON(http.StatusOK, data)
    })

    // 监听并启动服务
    router.Run(":8080")
}

运行程序，通过浏览器访问 http://localhost:8080/someJSON ，页面显示：

{"lang":"GO\\u8bed\\u8a00","tag":"\\u003cbr\\u003e"}

5. PureJSON 响应

PureJSON() 方法将给定结构序列化为 JSON 到响应体中。与 JSON 不同，PureJSON() 方法不会用 Unicode 实体替换特殊的 HTML 字符。

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

    // Unicode 实体
    router.GET("/json", func(c *gin.Context) {
        c.JSON(200, gin.H{
            "html": "<b>Hello, world!</b>",
        })
    })

    // 纯字符标识
    router.GET("/purejson", func(c *gin.Context) {
        c.PureJSON(200, gin.H{
            "html": "<b>Hello, world!</b>",
        })
    })

    // 监听并启动服务
    router.Run(":8080")
}

运行程序，通过浏览器访问 http://localhost:8080/json ，页面显示：

{"html":"\\u003cb\\u003eHello, world!\\u003c/b\\u003e"}

访问 http://localhost:8080/purejson ，页面显示：

{"html":"<b>Hello, world!</b>"}

通过对比可以知道， JSON() 方法与 PureJSON() 方法的区别在于，

  • PureJSON() 不会对内容进行任何的编码转义处理
  • JSON() 以及 AsciiJSON() 方法都会对内容进行变码转义处理
  • SecureJSON() 方法甚至会额外添加其他内容。

但不管怎么，这些方法都有其使用场景，为开发人员提供了更多便利的选择。

6. DataFromReader 响应

DataFromReader() 方法将指定的读取器写入正文流并更新 HTTP 状态码。也就是从数据流读取数据后处理并更新 HTTP 状态码。

func main() {
    router := gin.Default()
    router.GET("/someDataFromReader", func(c *gin.Context) {
        response, err := http.Get("<https://raw.githubusercontent.com/gin-gonic/logo/master/color.png>")
        if err != nil || response.StatusCode != http.StatusOK {
            c.Status(http.StatusServiceUnavailable)
            return
        }

        reader := response.Body
        contentLength := response.ContentLength
        contentType := response.Header.Get("Content-Type")

        extraHeaders := map[string]string{

            // 做为附件下载保存
            // "Content-Disposition": `attachment; filename="gopher.png"`,

            // 直接在浏览器显示
            "Content-Type": "image/png",
        }

        c.DataFromReader(http.StatusOK, contentLength, contentType, reader, extraHeaders)
    })

    router.GET("/file", func(c *gin.Context) {
        // 输出当前目录 main.go 文件内容
        c.File("main.go")
    })

    router.GET("/attach", func(c *gin.Context) {
        // 下载当前目录 main.go 文件为 test-main.go
        c.FileAttachment("./main.go", "test-main.go")
    })

    router.Run(":8080")
}

运行程序，通过浏览器访问 http://localhost:8080/someDataFromReader ，程序会读取 https://raw.githubusercontent.com/gin-gonic/logo/master/color.png 这张图，然后在页面显示这张图，这个过程并不是 HTML 标签来完成，而是通过程序来读取图片数据然后设置 “Content-Type”: "image/png " 才呈现出来的。
在上面代码中，如果 extraHeaders 设置为第一种则会作为附件下载保存这张图片。可以这样理解这个方法：可以从任何 Reader 读取数据并按 extraHeaders 的配置来响应渲染内容。
而为了更多演示说明有关文件处理，可通过浏览器访问 http://localhost:8080/file ，会直接在浏览器中显示源文件代码，另外通过浏览器访问 http://localhost:8080/attach ，会在浏览器中下载保存源文件 main.go 为 test-main.go 文件。这两个方法 File() 和 FileAttachment() 不会经常使用，但比较有用。

7. Redirect 重定向

重定向也可以认为是响应的一种方式。这里列举了两种方式，一种是常见的 301 重定向，还有一种是其实是 Gin 的 Handler 重新指定，通过 HandleContex() 方法来重新调用其他的 Handler 。

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

    // 直接重定向到外部站点
    router.GET("/re", func(c *gin.Context) {
        c.Redirect(http.StatusMovedPermanently, "http://www.baidu.com/")
    })

    // 间接重定向到内部 Handler
    router.GET("/handle", func(c *gin.Context) {
        c.Request.URL.Path = "/hi"
        router.HandleContext(c)
        c.JSON(200, gin.H{"Handler": "handle"})
    })

    router.GET("/hi", func(c *gin.Context) {
        c.JSON(200, gin.H{"hello": "world"})
    })

    // 监听并启动服务
    router.Run(":8080")
}

程序运行在 Debug 模式时，通过浏览器访问 http://localhost:8080/handle ，页面显示：

{"hello":"world"}
{"Handler":"handle"}

控制台输出：

[GIN-debug] GET /re --> main.main.func1 (3 handlers)
[GIN-debug] GET /handle --> main.main.func2 (3 handlers)
[GIN-debug] GET /hi --> main.main.func3 (3 handlers)
[GIN-debug] Listening and serving HTTP on :8080
[GIN] 2019/07/14 - 22:24:41 | 200 | 996.8µs | ::1 | GET /hi
[GIN] 2019/07/14 - 22:24:41 | 200 | 26.9291ms | ::1 | GET /handle

可以看到实际上执行了两个 Handler 处理程序，响应状态码为： 200 ，并不是真正的重定向，但可以通过 HandleContex() 方法在程序中实现 Handler 的嵌套调用。
​

程序运行继续运行，在命令行运行：

curl -v http://localhost:8080/re

命令行返回

> GET /re HTTP/1.1
> Host: localhost:8080
> User-Agent: curl/7.47.0
> Accept: */*
>
< HTTP/1.1 301 Moved Permanently
< Content-Type: text/html; charset=utf-8
< Location: <http://www.baidu.com/>
< Date: Sun, 14 Jul 2019 14:21:25 GMT
< Content-Length: 56
<
<a href="<http://www.baidu.com/>">Moved Permanently</a>.

返回的状态码为： 301 ，说明 Redirect() 方法实现了真正的重定向。而通过浏览器访问 http://localhost:8080/re ，将会重定向打开百度首页。
​

原文地址：https://gitbook.cn/gitchat/column/5dab061e7d66831b22aa0b44/topic/5dab09fd7d66831b22aa0b5e

wohu007
关注
专栏目录
Golang-Gin框架示例二十多个源码
04-26
在这个“Golang-Gin框架示例二十多个源码”中，你可以深入理解并学习如何利用Gin来构建各种类型的Web应用程序。 首先，Gin框架的核心概念是路由器。在Gin中，你可以通过简单的API定义路由，将HTTP请求映射到相应的...
使用Gin框架时，YAML格式来响应HTTP请求并且在浏览器中看到的结果是一个下载文件而不是显示YAML数据
皮卡乒的皮卡乓
04-20 350
在HTTP响应中，Content-Type标头告诉客户端接收到的数据的类型。如果浏览器无法正确识别响应的MIME类型，它将默认将响应保存为下载文件。因此，为了使浏览器正确地显示YAML响应，您需要在响应的Content-Type标头中指定正确的MIME类型。将这行代码添加到您的Gin处理程序中，确保它在响应YAML数据之前被调用。这将告诉浏览器正确的MIME类型，并使浏览器正确地显示YAML响应。
【gin学习笔记】04 gin对于文件的上传和返回
军军的博客
04-03 2023
本文学习视频https://www.bilibili.com/video/BV1GA411t7BR?spm_id_from=333.1007.top_right_bar_window_history.content.click 文件上传 package main import "github.com/gin-gonic/gin" func main() { r := gin.Default() r.POST("/testUpload", func(c *gin.Context) { file.
Gin贡献的SSE（Server-Sent Events）模块指南
最新发布
gitblog_00922的博客
09-03 607
Gin贡献的SSE（Server-Sent Events）模块指南 sseServer-Sent Events implementation in Go. Used by the Gin Framework.项目地址:https://gitcode.com/gh_mirrors/sse1/sse 项目介绍 Gin-Contriub-sse 是一个专为 Gin 框架设计的扩展库，旨在实现 Serv...
GIN Bind模式获取参数和表单验证
一叶知秋
08-08 2225
前言 感谢开源项目gin-vue-admin，以及1010工作室的教程，项目文档 我只是在跟着学习，然后记录下笔记而已，可能会有新的代码加入，但是本质还是跟着学习的一个过程。 所谓的绑定就是先建立一个结构体，然后将接收到的参数通过绑定的形式直接映射上去 bind模式以及如何使用 在使用绑定模式时有两种方式，即must bind和should bind。 must bind Methods： Bind, BindJSON, BindXML, BindQuery, BindYAML Behavior 这次方法
gin框架02--json渲染
脚步不能达到的地方，眼光可以达到；眼光不能达到的地方，精神可以飞到
03-16 998
gin框架01--json渲染介绍json 渲染案例注意事项说明 介绍 Gin 框架对json支持的较晚上，开发人员可以按需选择多种 json 格式返回。 使用 AsciiJSON 生成具有转义的非 ASCII 字符的 ASCII-only JSON， 使用 PureJSON 输出纯json且不会转码，使用 IndentedJSON 输出可以缩进的 json信息。更多详细内容可以在 context.go 中寻找答案。 json 渲染案例 案例： package main import ( "github
Gin 框架学习笔记（02）— 参数自动绑定到结构体
wohu1104的专栏
12-17 8015
参数绑定模型可以将请求体自动绑定到结构体中，目前支持绑定的请求类型有 JSON 、XML 、YAML 和标准表单 form数据 foo=bar&boo=baz 等。换句话说，只要定义好结构体，就可以将请求中包含的数据自动接收过来，这是 Gin 框架非常神奇的功能。 ​ 在定义绑定对应的结构体时，需要给结构体字段设置绑定类型的标签，比如绑定 JSON 数据时，设置字段标签为 json:"fieldname" 。使用绑定可以更快捷地把数据传递给程序中的数据对象。 ​ 使用 Gin框架中系列绑定有关方法
gin框架安装以及gin的请求路由
01-20
Gin框架是Golang中一款非常流行的HTTP服务器框架，以其简洁、高效的API设计受到广大开发者喜爱。...随着对Gin的深入学习，你会发现它提供的中间件、上下文管理等功能，能帮助你更高效地构建RESTful API服务。
GO语言gin框架实现管理员认证登陆接口
12-16
这些主题虽然与本篇文章的核心内容（Gin框架的管理员登录验证）不同，但都是Web开发中不可或缺的知识点，有助于扩展对全栈开发的理解。 总之，使用Gin框架实现后台管理员登录验证接口，主要涉及接收HTTP请求、...
golang 网络框架之gin的使用方法
09-18
在Golang中，开发Web应用时，我们常常会使用到框架来简化开发流程。Gin是一个流行的、高性能的Web框架，特别适合...在实际开发中，还可以探索更多的Gin特性，如中间件、错误处理、模板渲染等，以满足更多复杂的需求。
go语言gin框架数据绑定常用api
11-03
不管你是go小白，还是其他开发语言的大佬，gin框架可以让你快速的实现运用的开发与部署，其跨操作系统的特点，可以让你省掉不少麻烦；同时，gin成了很多初创公司敏捷开发的首选；快速开发，快速测试，快速迭代。go...
Go Web——Gin输出渲染
qq_39280718的博客
08-27 680
Gin支持很多种输出渲染，可以是简单的字符串、JSON、XML、HTML、ProtoBuf。
golang gin 框架读取无法用 body 传递的表单参数
Lucky小黄人的博客
08-07 2380
这两天发现一个有意思的情况，好像 gin 框架里 c.PostForm() 函数只能从表单中获取参数，不能从 body 中解析表单参数，也就是说你如果用 c.PostForm() 来解析获取参数，客户端发起请求时，如果参数放在表单里，服务端能正常获取到参数，但是如果客户端把参数放在 body 里，即使 header 里配置了 content-type:multipart/form-data，服务...
深入Gin框架内幕(二)
weichuangxxb的博客
01-13 1711
在上一篇文章深入gin框架内幕(一)中，主要介绍了Gin框架中是如何创建一个HTTP服务以及内部的核心结构和常用的一些结构体方法，并在最后以一个简单的示例来详细讲解Gin框架内部具体是如何运行的，但是在最后我们会发现使用了一个Context引用对象的一些方法来返回具体的HTTP响应数据，在本篇文章中，我们将继续学习和分析Gin框架内幕。 在开始分析之前，我们先简单回顾一下上一个章节中讲到的...
gin获取请求体（json格式）参数
qq_34252060的博客
09-30 5936
gin获取请求体（json格式）参数
Golang 入门-Gin框架深入了解使用
wuliZs_的博客
03-19 2288
框架架构 HTTP 服务器 1.默认服务器 router.Run() 2.HTTP 服务器 除了默认服务器中router.Run()的方式外，还可以用http.ListenAndServe()，比如 func main() { router := gin.Default() http.ListenAndServe(":8080", router) } 或者自定义 ...
go的gin框架使用（五）：post请求
热门推荐
美丽的泡沫
05-21 1万+
前面我们说的都是get请求，今天来说一下post请求，因为没有写页面，我们就用curl模仿下一：常见的有以下几种application/json     （request中发送json数据用post方式发送Content-type用application/json）application/x-www-form-urlencoded     （最常见的表单数据提交，把query string的内容，...
gin返回ProtoBuf
一个菜鸟的博客
05-29 525
proto syntax = "proto3"; option go_package = ".;proto"; message Result { string name = 1; repeated string course = 2; } 使用命令生成go代码 protoc -I . result.proto --go_out=plugins=grpc:. Server package main import ( "ShopBefore/gintstart/ch06/proto" "gi
Golang Gin 实战（十二）| ProtoBuf 使用和源码分析原理实现
flysnow_org的博客
06-20 1657
Golang Gin 实战（十二）| ProtoBufProtoBuf最近几年也算比较流行，它是一种语言无关，平台无关，并且可以扩展，并结构数据序列化的方法。相比JSON/XML这类文本...
Go语言Gin框架：数据绑定与API详解
Gin的多项式渲染功能使得数据处理变得非常方便，支持JSON、XML、HTML、YAML等多种格式的输出，`c.JSON()`和`c.XML()`等API能轻松地将数据格式化为响应内容。这种灵活性使得Gin成为初创公司敏捷开发的理想选择，因为...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

wohu007

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

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

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

打赏作者

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

抵扣说明：

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

余额充值