我要评论前言
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" rel="external nofollow" >
</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文件
以上就是go语言web框架gin响应客户端的方式的详细内容，更多关于go gin响应客户端的资料请关注代码网其它相关文章！
发表评论