首页 > 脚本中心 > Golang > Golang Gin框架实现多种数据格式返回结果详解

Golang Gin框架实现多种数据格式返回结果详解

福牛 5月 16, 2023 19 0

背景

在前面的课程中，我们已经学习和掌握了多类型的网络请求和处理，还掌握了提交数据与结构体绑定的操作。我们都知道，一个完整的请求包含请求、处理请求和结果返回三个步骤，在服务器端对请求处理完成以后，会将结果返回给客户端。

在gin框架中，支持返回多种请求数据格式。

[ ]byte

在之前的课程案例中，我们统一使用的请求返回数据格式为[ ]byte。通过context，Writer，Write方法写入[ ]byte数据。编码案例如下所示：

  1. package main
  2. import “github.com/gin-gonic/gin”
  3. func main() {
  4.      engine := gin.Default()
  5.      engine.GET(“/byte”, func(c *gin.Context) {
  6.          fullPath := c.FullPath()
  7.          c.Writer.Write([]byte(fullPath))
  8.      })
  9.      engine.Run()
  10. }

string

  1. engine.GET(“/string”, func(c *gin.Context) {
  2.          fullPath := c.FullPath()
  3.          c.Writer.WriteString(fullPath)
  4.      })

这里writer是context结构体里面的一个属性，类型为ResponseWriter这样一个类型。

  1. type Context struct {
  2.      writermem responseWriter
  3.      Request *http.Request
  4.      Writer ResponseWriter
  5. }

ResponseWriter是一个接口类型，在这个接口里面包括了http.ResponseWriter，这个也就是go标准库http包下的，这里还有一系列的方法。上面使用的c.Writer方法是属于http.ResponseWriter下的一个方法。

  1. type ResponseWriter interface {
  2.      http.ResponseWriter
  3.      http.Hijacker
  4.      http.Flusher
  5.      http.CloseNotifier
  6.      Status() int
  7.      Size() int
  8.      WriteString(string) (int, error)
  9.      Written() bool
  10.      WriteHeaderNow()
  11.      Pusher() http.Pusher
  12. }

JSON

除了使用context.Writer对象返回byte和string类型的数据意外。在项目开发中，JSON格式规范使用的更为普遍。gin为了方便开发者更方便的使用该框架进行项目开发，直接支持将返回数据组装成JSON格式进行返回。

gin框架中的context包含的JSON方法可以将结构体类型的数据转换成JSON格式的结构化数据，然后返回给客户端。

下面是两种方式来演示，一种是通过map类型数据转化为json，其次还可以通过结构体类型转化为json格式。

map类型编程调用如下所示：

  1. engine.GET(“/map”, func(c *gin.Context) {
  2.          fullPath := c.FullPath()
  3.          c.JSON(http.StatusOK, map[string]interface{}{
  4.              “code”: 1,
  5.              “msg”: “ok”,
  6.              “data”: fullPath,
  7.          })
  8.      })

-1

这样就完成了最简单的map类型的数据格式转化为json，然后返回给前端。

struct类型编程调用如下所示：

真正项目开发的时候，往往会有很多的结构体，要将结构体对应值类型的数据直接返回给前端。

通常会将code，message和data这三个数据定义作为response这样一个通用的结构体。

  1. package main
  2. import (
  3.      “github.com/gin-gonic/gin”
  4.      “net/http”
  5. )
  6. func delStructHandler(c *gin.Context) {
  7.      fullPath := “请求路径” + c.FullPath()
  8.      resp := Response{
  9.          Code: 1,
  10.          Message: “ok”,
  11.          Data: fullPath,
  12.      }
  13.      c.JSON(http.StatusOK, &resp)
  14.      //第二个参数是interface类型，这里需要取值类型的地址
  15. }
  16. type Response struct {
  17.      Code int
  18.      Message string
  19.      Data interface{} //由于类型不确定，那么使用万能类型，interface类型
  20. }
  21. func main() {
  22.      engine := gin.Default()
  23.      engine.GET(“/struct”, delStructHandler)
  24.      engine.Run()
  25. }

-2

Html

在gin框架当中，支持直接加载html页面，或者html模板，这样就可以在前端里面渲染出来。

这里要先创建html的目录，目录下面放的都是html文件，gin要去先加载这些文件才能使用。

-3

  1. package main
  2. import (
  3.      “github.com/gin-gonic/gin”
  4.      “net/http”
  5. )
  6. func htmlHandler(c *gin.Context) {
  7.      c.HTML(http.StatusOK, “index.html”, nil)
  8.      //第二个参数是interface类型，这里需要取值类型的地址
  9. }
  10. func main() {
  11.      engine := gin.Default()
  12.      //指明要加载的html文件所在的目录,这样就将html目录下面所有的文件可以让gin访问
  13.      engine.LoadHTMLGlob(“C:\\Users\\W10\GolandProjects\\day1\\gin\\bilibli\\html\\*”)
  14.      engine.GET(“/html”, htmlHandler)
  15.      engine.Run()
  16. }

-4

在这个html页面能不能将后台的服务器的一些数据返回给html页面呢？

这就需要使用模板语言，要将一个变量传递到index.html页面中展示，这就需要在html页面当中使用模板语言来定义变量。双花括号+变量

  1. <!DOCTYPE html>
  2. <html lang=“en”>
  3. <head>
  4.      <meta charset=“UTF-8”>
  5.      <title>Title</title>
  6. </head>
  7. <body>
  8. <h1>gin学习</h1>
  9. {{.fullPath}}
  10. </body>
  11. </html>

在这个页面当中定义了

  1. <!DOCTYPE html>
  2. <html lang=“en”>
  3. <head>
  4.      <meta charset=“UTF-8”>
  5.      <title>{{.title}</title>
  6. </head>
  7. <body>
  8. <h1>gin学习</h1>
  9. {{.fullPath}}
  10. </body>
  11. </html>
  1. package main
  2. import (
  3.      “github.com/gin-gonic/gin”
  4.      “net/http”
  5. )
  6. func htmlHandler(c *gin.Context) {
  7.      fullPath := c.FullPath()
  8.      c.HTML(http.StatusOK, “index.html”, gin.H{
  9.          “fullPath”: fullPath,
  10.          “title”: “gin学习”,
  11.      })
  12.      //这样就将服务器端的变量传递到html页面当中了
  13. }
  14. func main() {
  15.      engine := gin.Default()
  16.      //指明要加载的html文件所在的目录,这样就将html目录下面所有的文件可以让gin访问
  17.      engine.LoadHTMLGlob(“C:\\Users\\W10\\GolandProjects\\day1\\gin\\bilibli\\html\\*”)
  18.      engine.GET(“/html”, htmlHandler)
  19.      engine.Run()
  20. }

-5

上面就是在html当中使用模板语言进行数据的传递和数据展示。

加载静态图片

在开发的过程当中往往会将同一类资源创建在同一个目录下面。

gin框架要在加载静态资源的时候必须先设置好静态资源的目录。

  1. package main
  2. import (
  3.      “github.com/gin-gonic/gin”
  4.      “net/http”
  5. )
  6. func htmlHandler(c *gin.Context) {
  7.      fullPath := c.FullPath()
  8.      c.HTML(http.StatusOK, “index.html”, gin.H{
  9.          “fullPath”: fullPath,
  10.          “title”: “gin学习”,
  11.      })
  12.      //这样就将服务器端的变量传递到html页面当中了
  13. }
  14. func main() {
  15.      engine := gin.Default()
  16.      //指明要加载的html文件所在的目录,这样就将html目录下面所有的文件可以让gin访问
  17.      engine.LoadHTMLGlob(“C:\\Users\\W10\\GolandProjects\\day1\\gin\\bilibli\\html\\*”)
  18.      //第一个参数代表客户端请求的http路径，第二个参数表示本地工程的路径
  19.      engine.Static(“/img”, “../image”)
  20.      engine.GET(“/html”, htmlHandler)
  21.      engine.Run()
  22. }
  1. <!DOCTYPE html>
  2. <html lang=“en”>
  3. <head>
  4.      <meta charset=“UTF-8”>
  5.      <title>{{.title}}</title>
  6. </head>
  7. <body>
  8. <h1>gin学习</h1>
  9. {{.fullPath}}
  10. <div align=“center”>
  11. <img src=“C:\Users\W10\GolandProjects\day1\gin\bilibli\image\test.jpg”>
  12. </div>
  13. </body>
  14. </html>

到此这篇关于golang Gin框架实现多种数据格式返回结果详解的文章就介绍到这了,更多相关Golang Gin多数据格式返回内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！

标签

相关推荐

发表评论