【Golang】Go语言web框架Gin响应客户端有哪些方式

在这里插入图片描述

✨✨ 欢迎大家来到景天科技苑✨✨

???????? 养成好习惯，先赞后看哦~????????

???? 作者简介：景天科技苑
????《头衔》：大厂架构师，华为云开发者社区专家博主，阿里云开发者社区专家博主，****全栈领域优质创作者，掘金优秀博主，51CTO博客专家等。
????《博客》：Python全栈，Golang开发，PyQt5和Tkinter桌面开发，小程序开发，人工智能，js逆向，App逆向，网络系统安全，数据分析，Django，fastapi，flask等框架，云原生K8S，linux，shell脚本等实操经验，网站搭建，数据库等分享。

所属的专栏：Go语言开发零基础到高阶实战
景天的主页：景天科技苑

在这里插入图片描述

文章目录

Gin框架响应客户端方式
- 一、响应html页面
- - 1、我们首先定义一个存放模板文件的`templates`文件夹
  - 2、让程序进行页面渲染和加载
  - 3、通过请求来响应页面
  - 4、启动测试
  - 5、静态文件处理
- 二、响应字符串数据
- 三、响应类型为JSON
- - 1. 返回普通数据类型
  - 2. 返回结构体
  - - (1) 不带JSON标签的结构体
    - (2) 带JSON标签的结构体
    - (3) 忽略某些字段
    - (4) 返回map
    - (5) 返回结构体切片
- 四、响应类型为XML和YAML
- - 1. 响应类型为XML
  - 2. 响应类型为YAML

Gin框架响应客户端方式

Gin是一个用Go语言编写的web框架。它是一个类似于martini但拥有更好性能的API框架, 由于使用了httprouter，速度提高了近40倍。
如果你是性能和高效的追求者, 你会爱上Gin。Gin框架支持多种响应类型，包括字符串、JSON、XML和YAML等。

一、响应html页面

响应页面，就跟我们直接用http编程时的模板渲染差不多

1、我们首先定义一个存放模板文件的`templates`文件夹

然后在其内部按照业务分别定义一个posts文件夹和一个users文件夹。两个文件夹中分别有posts/posts.html文件和users/users.html文件。
在这里插入图片描述

users/users.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>我的Go页面</title>
</head>
<body>

<h1>users 感谢大家来到景天科技苑 Go语言全栈课</h1>


获取传入的数据：
{{.msg}}

</body>
</html>

posts/posts.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>我的Go页面</title>
</head>
<body>

<h1>posts 感谢大家来到景天科技苑 Go语言全栈课</h1>


获取传入的数据：
{{.msg}}

</body>
</html>

2、让程序进行页面渲染和加载

Gin框架中使用 LoadHTMLGlob()或者 LoadHTMLFiles()方法进行HTML模板渲染
LoadHTMLGlob(pattern string)：
这个方法接受一个模式（pattern），通常是一个通配符（如"*.html"），用于匹配目录中的所有HTML模板文件。
它会加载指定目录下所有匹配该模式的文件作为模板。
这种方式适合于项目中模板文件较多，且都存放在同一个目录下的情况。

LoadHTMLFiles(files …string)：
这个方法接受一个文件名列表，你可以显式地指定要加载的HTML模板文件。
它允许你加载项目中分散在不同目录的模板文件，或者只加载特定的几个模板文件。
这种方式提供了更细粒度的控制，你可以精确选择哪些模板文件被加载。

//指定html模版路径，这个方法接受一个模式（pattern），通常是一个通配符（如"*.html"），用于匹配目录中的所有HTML模板文件。
// func (engine *Engine) LoadHTMLGlob(pattern string)
ginServer.LoadHTMLGlob("templates/*/*")

//使用ginServer.LoadHTMLFiles() 这个方法接受一个文件名列表，你可以显式地指定要加载的HTML模板文件。
// func (engine *Engine) LoadHTMLFiles(files ...string)
//这种方式需要把文件名都列出来
//ginServer.LoadHTMLFiles("templates/posts/posts.html", "templates/users/posts.html")

// localhost:8088/hello
// 处理请求的函数 *gin.Context
ginServer.GET("/posts/index", func(c *gin.Context) {
    //响应html页面使用c.HTML()
    c.HTML(http.StatusOK, "posts.html", gin.H{"msg": "这是后台posts路径返回的数据"})
})

//再写个路径
ginServer.GET("/users/index", func(c *gin.Context) {
    //响应html页面使用c.HTML()
    c.HTML(http.StatusOK, "users.html", gin.H{"msg": "这是后台users路径返回的数据"})
})

3、通过请求来响应页面

使用c.HTML()方法，并需要加载HTML模板文件。

package main

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

func main() {

    //以生产模式运行
    //gin.SetMode(gin.ReleaseMode)

    // 创建gin服务，创建一个默认的路由引擎ginServer。然后可以根据ginServer.GET，ginServer.ROST，ginServer.DELETE等内置函数处理客户端发来的http请求。
    ginServer := gin.Default()

    //指定html模版路径，这个方法接受一个模式（pattern），通常是一个通配符（如"*.html"），用于匹配目录中的所有HTML模板文件。
    // func (engine *Engine) LoadHTMLGlob(pattern string)
    ginServer.LoadHTMLGlob("templates/*")

    //使用ginServer.LoadHTMLFiles() 这个方法接受一个文件名列表，你可以显式地指定要加载的HTML模板文件。
    // func (engine *Engine) LoadHTMLFiles(files ...string)
    //这种方式需要把文件名都列出来
    //ginServer.LoadHTMLFiles("templates/posts/index.html", "templates/users/index.html")

    // localhost:8088/hello
    // 处理请求的函数 *gin.Context
    ginServer.GET("/posts/index", func(c *gin.Context) {
        //响应html页面使用c.HTML()
        c.HTML(http.StatusOK, "index.tmpl", gin.H{"msg": "这是后台posts路径返回的数据"})
    })

    //再写个路径
    ginServer.GET("/users/index", func(c *gin.Context) {
        //响应html页面使用c.HTML()
        c.HTML(http.StatusOK, "index.tmpl", gin.H{"msg": "这是后台users路径返回的数据"})
    })

    // 启动HTTP服务,可以修改端口。默认是8080端口
    err := ginServer.Run(":8088")
    if err != nil {
        return
    }
}

4、启动测试

在这里插入图片描述

5、静态文件处理

当我们渲染的HTML文件中引用了静态文件时，我们只需要按照以下方式在渲染页面前调用gin.Static方法即可。
ginServer.Static(url string, path string)
url：URL前缀，客户端通过这个前缀来访问静态文件。
path：静态文件所在的目录路径。Gin 会将这个目录下的文件映射到指定的URL前缀下。

文件结构
在这里插入图片描述

package main

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

func main() {

    //以生产模式运行
    //gin.SetMode(gin.ReleaseMode)

    // 创建gin服务，创建一个默认的路由引擎ginServer。然后可以根据ginServer.GET，ginServer.ROST，ginServer.DELETE等内置函数处理客户端发来的http请求。
    ginServer := gin.Default()

    //指定html模版路径，这个方法接受一个模式（pattern），通常是一个通配符（如"*.html"），用于匹配目录中的所有HTML模板文件。
    // func (engine *Engine) LoadHTMLGlob(pattern string)
    //ginServer.LoadHTMLGlob("templates/*/*")

    //使用ginServer.LoadHTMLFiles() 这个方法接受一个文件名列表，你可以显式地指定要加载的HTML模板文件。
    // func (engine *Engine) LoadHTMLFiles(files ...string)
    //这种方式需要把文件名都列出来
    ginServer.LoadHTMLFiles("templates/posts/posts.html", "templates/users/users.html")

    // 处理请求的函数 *gin.Context
    ginServer.GET("/posts/index", func(c *gin.Context) {
        //响应html页面使用c.HTML()
        c.HTML(http.StatusOK, "posts.html", gin.H{"msg": "这是后台posts路径返回的数据"})
    })

    //再写个路径
    ginServer.GET("/users/index", func(c *gin.Context) {
        //响应html页面使用c.HTML()
        c.HTML(http.StatusOK, "users.html", gin.H{"msg": "这是后台users路径返回的数据"})
    })

    // 静态资源
    //引入css样式文件 这样需要访问静态资源的时候只需要在域名后面加上/static   就能访问当前staticData目录下的静态资源
    // 例如，如果客户端请求 /static/css/main.css，Gin会尝试从 ./staticData/css/main.css 文件中提供内容。
    ginServer.Static("/static", "staticData")

    // 启动HTTP服务,可以修改端口。默认是8080端口
    err := ginServer.Run(":8088")
    if err != nil {
        return
    }
}

前端html因日css静态文件

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>我的Go页面</title>
    <link rel="stylesheet" href="/static/css/main.css">
</head>
<body>

<h1>posts 感谢大家来到景天科技苑 Go语言全栈课</h1>


获取传入的数据：
{{.msg}}

</body>
</html>

浏览器请求，可见css样式生效
在这里插入图片描述

二、响应字符串数据

Gin框架可以很方便地返回字符串类型的响应。以下是一个返回字符串响应的示例：

package main  
  
import (  
    "net/http"  
    "github.com/gin-gonic/gin"  
)  
  
func StringResponse(c *gin.Context) {  
    c.String(http.StatusOK, "This is string response")  
}  
  
func main() {  
    r := gin.Default()  
    r.GET("/string", StringResponse)  
    r.Run(":8080")  
}

在这个示例中，定义了一个StringResponse函数，用于处理/string路径的GET请求。当客户端请求这个路径时，服务器会返回字符串"This is string response"。

三、响应类型为JSON

Gin框架支持将结构体或map类型的数据转换为JSON格式的响应。

1. 返回普通数据类型

package main

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

func main() {
    // 创建gin服务,创建一个默认的路由引擎ginServer。然后可以根据ginServer.GET，ginServer.ROST，ginServer.DELETE等内置函数处理客户端发来的http请求。
    ginServer := gin.Default()
    // localhost:8088/hello
    // 处理请求的函数 *gin.Context
    ginServer.GET("/hello", func(c *gin.Context) {
        // c.JSON：响应给客户端JSON格式的数据 func (c *Context) JSON(code int, obj any)
        // gin.H : 参数 key value
        // gin.H 是一个便捷的快捷方式，你也可以直接使用 map[string]interface{} 来代替它
        c.JSON(200, gin.H{"message": "Hello world!"})
    })
    // 启动HTTP服务,可以修改端口。默认是8080端口
    ginServer.Run(":8088")
}

在这里插入图片描述

2. 返回结构体

(1) 不带JSON标签的结构体

package main

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

func JsonResponse(c *gin.Context) {
        // 定义的结构体不带json标签

    type UserInfo struct {
        UserName string
        Age      int
    }
    user := UserInfo{UserName: "jingtian", Age: 20}
        // 这里直接将不带标签的结构体返回

    c.JSON(http.StatusOK, user)
}

func main() {
    r := gin.Default()
    r.GET("/json", JsonResponse)
    r.Run(":8080")
}

在这个示例中，定义了一个UserInfo结构体，并将其实例化为user变量。然后，使用c.JSON(http.StatusOK, user)语句将user变量转换为JSON格式的响应返回给客户端。
响应的json字段名称就是结构体原本字段名
在这里插入图片描述

(2) 带JSON标签的结构体

有时，我们希望结构体字段在JSON响应中使用不同的名称。这时，可以使用结构体标签（struct tag）来实现。
定义结构体的时候，带上json标签，标签可以与结构体字段不一样，这样当我们返回结构体的时候，返回的json字段是标签字段

package main

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

func JsonResponse(c *gin.Context) {
    // 定义结构体的时候，带上json标签，标签可以与结构体字段不一样，这样当我们返回结构体的时候，返回的json字段是标签字段
    type UserInfo struct {
        UserName string `json:"user_name"`
        Age      int    `json:"age"`
    }
    user := UserInfo{UserName: "景天带标签", Age: 20}
    c.JSON(http.StatusOK, user)
}

func main() {
    r := gin.Default()
    r.GET("/json", JsonResponse)
    r.Run(":8080")
}

结构体的字段时username 而我们返回的json字符串中是我们定义的标签user_name
在这里插入图片描述

在这个示例中，UserInfo结构体的字段使用了json标签，指定了在JSON响应中使用的名称。因此，返回的JSON响应为{“user_name”:“json”,“age”:20}。

(3) 忽略某些字段

有时，我们可能不希望将结构体的所有字段都包含在JSON响应中。这时，可以使用-标签来忽略某些字段。
忽略该字段使用- 标签这样，响应的json中就不包含该字段

package main

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

func JsonResponse(c *gin.Context) {
    type UserInfo struct {
        UserName string `json:"user_name"`
        Age      int    `json:"age"`
        Password string `json:"-"` // 忽略该字段  使用- 标签  这样，响应的json中就不包含该字段
    }
    user := UserInfo{UserName: "景天忽略字段", Age: 20, Password: "secret"}
    c.JSON(http.StatusOK, user)
}

func main() {
    r := gin.Default()
    r.GET("/json", JsonResponse)
    r.Run(":8080")
}

在这个示例中，Password字段使用了-标签，因此它不会被包含在JSON响应中。
在这里插入图片描述

(4) 返回map

除了结构体之外，还可以使用map类型的数据来生成JSON响应。

package main

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

func JsonResponse(c *gin.Context) {
    // 定义map
    data := map[string]interface{}{
        "user_name": "景天map",
        "age":       20,
    }
    //直接将map返回
    c.JSON(http.StatusOK, data)
}

func main() {
    r := gin.Default()
    r.GET("/json", JsonResponse)
    r.Run(":8080")
}

在这里插入图片描述

(5) 返回结构体切片

有时候我们需要返回一个切片，里面是一个个的结构体

package main

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

func main() {
    // 创建gin服务
    ginServer := gin.Default()
    // localhost:8080/hello
    // 处理请求的函数 *gin.Context

    ginServer.GET("/hello", func(c *gin.Context) {
        //定义结构体
        type User struct {
            Username string `json:"username"`
            Password string `json:"password"`
        }

        //定义User类型的切片
        users := make([]User, 2)
        //给切片赋值
        users[0] = User{"景天哥", "123456"}
        users[1] = User{"赵日天", "895456"}

        //响应结构体切片
        c.JSON(200, users)
    })
    // 启动HTTP服务,可以修改端口
    ginServer.Run(":8088")
}

在这里插入图片描述

四、响应类型为XML和YAML

除了JSON之外，Gin框架还支持将数据转换为XML和YAML格式的响应。以下是一些示例：

1. 响应类型为XML

package main

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

func XmlResponse(c *gin.Context) {
    type UserInfo struct {
        XMLName  xml.Name `xml:"user"`
        UserName string   `xml:"user_name"`
        Age      int      `xml:"age"`
    }
    user := UserInfo{UserName: "xml", Age: 30}
    // 使用c.XML返回xml格式
    c.XML(http.StatusOK, user)
}

func main() {
    r := gin.Default()
    r.GET("/xml", XmlResponse)
    r.Run(":8080")
}

注意：在这个示例中，需要使用encoding/xml包来处理XML数据。由于篇幅限制，这里省略了导入包的语句。
在这里插入图片描述

2. 响应类型为YAML

package main

import (
    "github.com/gin-gonic/gin"
    "gopkg.in/yaml.v3"
    "net/http"
)

func YamlResponse(c *gin.Context) {
    type UserInfo struct {
        UserName string `yaml:"user_name"`
        Age      int    `yaml:"age"`
    }
    user := UserInfo{UserName: "yaml", Age: 40}
    //yaml序列化
    // func Marshal(in interface{}) (out []byte, err error)
    data, err := yaml.Marshal(user)
    if err != nil {
        c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
        return
    }
    // 通过c.Data响应为yaml数据
    c.Data(http.StatusOK, "application/x-yaml", data)
}

func main() {
    r := gin.Default()
    r.GET("/yaml", YamlResponse)
    r.Run(":8080")
}

在这个示例中，使用了gopkg.in/yaml.v3包（需要安装这个包）来处理YAML数据。
yaml.Marshal(user)函数将user变量转换为YAML格式的字节数组，然后使用c.Data方法将字节数组作为响应返回给客户端。
同时，设置了响应头Content-Type为application/x-yaml，以指示客户端这是一个YAML格式的响应。
浏览器访问该url就会下载yaml文件
在这里插入图片描述

秒客网

【Golang】Go语言web框架Gin响应客户端有哪些方式

文章目录

Gin框架响应客户端方式

一、响应html页面

1、我们首先定义一个存放模板文件的`templates`文件夹

2、让程序进行页面渲染和加载

3、通过请求来响应页面

4、启动测试

5、静态文件处理

二、响应字符串数据

三、响应类型为JSON

1. 返回普通数据类型

2. 返回结构体

(1) 不带JSON标签的结构体

(2) 带JSON标签的结构体

(3) 忽略某些字段

(4) 返回map

(5) 返回结构体切片

四、响应类型为XML和YAML

1. 响应类型为XML

2. 响应类型为YAML

相关文章

【Golang】Go语言web框架Gin响应客户端有哪些方式

文章目录

Gin框架响应客户端方式

一、响应html页面

1、我们首先定义一个存放模板文件的templates文件夹

2、让程序进行页面渲染和加载

3、通过请求来响应页面

4、启动测试

5、静态文件处理

二、响应字符串数据

三、响应类型为JSON

1. 返回普通数据类型

2. 返回结构体

(1) 不带JSON标签的结构体

(2) 带JSON标签的结构体

(3) 忽略某些字段

(4) 返回map

(5) 返回结构体切片

四、响应类型为XML和YAML

1. 响应类型为XML

2. 响应类型为YAML

相关文章

1、我们首先定义一个存放模板文件的`templates`文件夹