开发者

Go语言web框架Gin响应客户端的方式

开发者 https://www.devze.com 2024-10-29 14:15 出处:网络 作者: 景天科技苑
目录前言一、响应html页面1、我们首先定义一个存放模板文件的templates文件夹2、让程序进行页面渲染和加载3、通过请求来响应页面4、启动测试5、静态文件处理二、响应字符串数据三、响应类型为jsON1. 返回普通数据类型
目录
  • 前言
  • 一、响应html页面
    • 1、我们首先定义一个存放模板文件的templates文件夹
    • 2、让程序进行页面渲染和加载
    • 3、通过请求来响应页面
    • 4、启动测试
    • 5、静态文件处理
  • 二、响应字符串数据
    • 三、响应类型为jsON
      • 1. 返回普通数据类型
      • 2. 返回结构体
    • 四、响应类型为XML和YAML
      • 1. 响应类型为XML
      • 2. 响应类型为YAML

    前言

    Gin是一个用Go语言编写的web框架。它是一个类似于martini但拥有更好性能的API框架, 由于使用了httprouter,速度提高了近40倍。

    如果你是性能和高效的追求者, 你会爱上Gin。Gin框架支持多种响应类型,包括字符串、JSON、XML和YAML等。

    一、响应html页面

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

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

    然后在其内部按照业务分别定义一个posts文件夹和一个users文件夹。 两个文件夹中分别有posts/posts.html文件和users/users.html文件。

    Go语言web框架Gin响应客户端的方式

    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 :=http://www.devze.com ginServer.Run(":8088")
        if err != nil {
            return
        }
    }
    

    4、启动测试

    Go语言web框架Gin响应客户端的方式

    Go语言web框架Gin响应客户端的方式

    5、静态文件处理

    当我们渲染的HTML文件中引用了静态文件时,我们只需要按照以下方式在渲染页面前调用gin.Static方法即可。

    ginServer.Static(url string, path string)

    url:URL前缀,客户端通过这个前缀来访问静态文件。

    path:静态文件所在的目录路径。Gin 会将这个目录下的文件映射到指定的URL前缀下。

    文件结构

    Go语言web框架Gin响应客户端的方式

    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("t编程emplates/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")
    
        //php 启动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" php>
    </head>
    <body>
    
    <h1>posts 感谢大家来到景天科技苑 Go语言全栈课</h1>
    
    
    获取传入的数据:
    {{.msg}}
    
    </body>
    </html>
    

    浏览器请求,可见css样式生效

    Go语言web框架Gin响应客户端的方式

    二、响应字符串数据

    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")
    }
    

    Go语言web框架Gin响应客户端的方式

    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字段名称就是结构体原本字段名

    Go语言web框架Gin响应客户端的方式

    (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

    Go语言web框架Gin响应客户端的方式

    在这个示例中,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响应中。

    Go语言web框架Gin响应客户端的方式

    (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")
    }
    

    Go语言web框架Gin响应客户端的方式

    (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")
    }
    

    Go语言web框架Gin响应客户端的方式

    四、响应类型为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数据。由于篇幅限制,这里省略了导入包的语句。

    Go语言web框架Gin响应客户端的方式

    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语言web框架Gin响应客户端的方式的详细内容,更多关于Go Gin响应客户端的资料请关注编程客栈(www.devze.com)其它相关文章!

    0

    精彩评论

    暂无评论...
    验证码 换一张
    取 消

    关注公众号