go-bindata 与 gin 的结合对html进行渲染

gaoluhua

已于 2022-04-25 14:24:47 修改

阅读量1.6k

点赞数

分类专栏： go 文章标签： golang

于 2022-04-25 14:18:10 首次发布

本文链接：https://blog.csdn.net/gaoluhua/article/details/124403171

版权

go 专栏收录该内容

17 篇文章 1 订阅

订阅专栏

Gin 是一个用 Go (Golang) 编写的 Web 框架。它具有类似 martini 的 API，性能要好得多，多亏了 httprouter，速度提高了 40 倍。
go-bindata 将任何文件封装在一个 Go 语言的 Source Code 里面，文件数据在转换为原始字节时可以选择使用 gzip 压缩，同时提供了统一的接口，帮助获取原始的文件数据.
本文就是用go-bindata对html文件进行打包，实际上是生成asset.go文件，然后通过gin对asset.go进行渲染，特别是本文探讨了如何在渲染过程中传递参数。

gin对html渲染

参见https://gin-gonic.com/zh-cn/docs/examples/html-rendering/
HTML 渲染
使用 LoadHTMLGlob() 或者 LoadHTMLFiles()

func main() {
	router := gin.Default()
	router.LoadHTMLGlob("templates/*")
	//router.LoadHTMLFiles("templates/template1.html", "templates/template2.html")
	router.GET("/index", func(c *gin.Context) {
		c.HTML(http.StatusOK, "index.tmpl", gin.H{
			"title": "Main website",
		})
	})
	router.Run(":8080")
}

templates/index.tmpl

<html>
	<h1>
		{{ .title }}
	</h1>
</html>

使用不同目录下名称相同的模板

func main() {
	router := gin.Default()
	router.LoadHTMLGlob("templates/**/*")
	router.GET("/posts/index", func(c *gin.Context) {
		c.HTML(http.StatusOK, "posts/index.tmpl", gin.H{
			"title": "Posts",
		})
	})
	router.GET("/users/index", func(c *gin.Context) {
		c.HTML(http.StatusOK, "users/index.tmpl", gin.H{
			"title": "Users",
		})
	})
	router.Run(":8080")
}

templates/posts/index.tmpl

{{ define "posts/index.tmpl" }}
<html><h1>
	{{ .title }}
</h1>
<p>Using posts/index.tmpl</p>
</html>
{{ end }}

templates/users/index.tmpl

{{ define "users/index.tmpl" }}
<html><h1>
	{{ .title }}
</h1>
<p>Using users/index.tmpl</p>
</html>
{{ end }}

自定义模板渲染器
你可以使用自定义的 html 模板渲染

import "html/template"

func main() {
	router := gin.Default()
	html := template.Must(template.ParseFiles("file1", "file2"))
	router.SetHTMLTemplate(html)
	router.Run(":8080")
}

自定义分隔符
你可以使用自定义分隔

	r := gin.Default()
	r.Delims("{[{", "}]}")
	r.LoadHTMLGlob("/path/to/templates")

自定义模板功能
查看详细示例代码。

main.go

import (
    "fmt"
    "html/template"
    "net/http"
    "time"

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

func formatAsDate(t time.Time) string {
    year, month, day := t.Date()
    return fmt.Sprintf("%d/%02d/%02d", year, month, day)
}

func main() {
    router := gin.Default()
    router.Delims("{[{", "}]}")
    router.SetFuncMap(template.FuncMap{
        "formatAsDate": formatAsDate,
    })
    router.LoadHTMLFiles("./testdata/template/raw.tmpl")

    router.GET("/raw", func(c *gin.Context) {
        c.HTML(http.StatusOK, "raw.tmpl", map[string]interface{}{
            "now": time.Date(2017, 07, 01, 0, 0, 0, 0, time.UTC),
        })
    })

    router.Run(":8080")
}

raw.tmpl

Date: {[{.now | formatAsDate}]}

结果：

Date: 2017/07/01

好的，通过官方的例子，我们看到gin对html页面的渲染，需要在路由上现载入html页面内容。

Go-bindata的简单使用

参考：https://blog.csdn.net/sitebus/article/details/83827948

（1）安装go-bindata

go get -u github.com/jteeuwen/go-bindata/...
go get github.com/elazarl/go-bindata-assetfs/...

（2）使用Go-bindata生成嵌入go代码
下面是将当前目录下的view目录、bignumber.js以及web3.js代码以压缩二进制代码嵌入到go语言中，生成bindata.go源程序。

 #go-bindata -o=app/asset/asset.go -pkg=asset view/... bignumber.js  web3.js
 go-bindata-assetfs -o=asset/asset.go -pkg=asset template/... conf/...

这是就会生产asset.go文件

// Code generated for package asset by go-bindata DO NOT EDIT. (@generated)
// sources:
// view/index.html
// view/rs.html
package asset

import (
	"bytes"
	"compress/gzip"
	"fmt"
	"io"
	"io/ioutil"
	"os"
	"path/filepath"
	"strings"
	"time"
)

func bindataRead(data []byte, name string) ([]byte, error) {
	gz, err := gzip.NewReader(bytes.NewBuffer(data))
	if err != nil {
		return nil, fmt.Errorf("Read %q: %v", name, err)
	}

	var buf bytes.Buffer
	_, err = io.Copy(&buf, gz)
	clErr := gz.Close()
.......................

（3）重新配置

r := gin.Default()

fsCss := assetfs.AssetFS{Asset: asset.Asset, AssetDir: asset.AssetDir, AssetInfo: asset.AssetInfo, Prefix: "template/css", Fallback: "index.html"}

fsJs := assetfs.AssetFS{Asset: asset.Asset, AssetDir: asset.AssetDir, AssetInfo: asset.AssetInfo, Prefix: "template/js", Fallback: "index.html"}

fsFonts := assetfs.AssetFS{Asset: asset.Asset, AssetDir: asset.AssetDir, AssetInfo: asset.AssetInfo, Prefix: "template/fonts", Fallback: "index.html"}

fsImg := assetfs.AssetFS{Asset: asset.Asset, AssetDir: asset.AssetDir, AssetInfo: asset.AssetInfo, Prefix: "template/img", Fallback: "index.html"}

fs := assetfs.AssetFS{Asset: asset.Asset, AssetDir: asset.AssetDir, AssetInfo: asset.AssetInfo, Prefix: "template", Fallback: "index.html"}

r.StaticFS("/css", &fsCss)
r.StaticFS("/fonts", &fsFonts)
r.StaticFS("/img", &fsImg)
r.StaticFS("/js", &fsJs)
r.StaticFS("/favicon.ico", &fs)

r.GET("/", func(c *gin.Context) {
	c.Writer.WriteHeader(200)
	indexHtml, _ := asset.Asset("template/index.html")
	_, _ = c.Writer.Write(indexHtml)
	c.Writer.Header().Add("Accept", "text/html")
	c.Writer.Flush()
})

说明

fs := assetfs.AssetFS{Asset: asset.Asset, AssetDir: asset.AssetDir, AssetInfo: asset.AssetInfo, Prefix: "template", Fallback: "index.html"}

其中

Prefix: "template" 是为了在查询文件时去除 template 前缀，例如原文件路径为 "template/css/app.ee8ee5dd.css" => /css/app.ee8ee5dd.css 方便和前端请求对应

Fallback: "index.html" 意思为如何查询不到则默认返回 index.html 文件，因为配置了前缀，这里返回的应该是 template/index.html

好的，这样go-bindata大致使用就讲完了。
下面我们主要探究gin如何利用go-bindata生成的asset.go文件来渲染html。当然asset.go是根据已有的html等文件，通过go-bindata-assetfs 命令生成的。

如何利用gin来渲染asset.go中的html信息

（1）示例一,这也是刚才谈到的例子，只是在渲染一个页面，没有进行参数传递。

r := gin.Default()
fs := assetfs.AssetFS{Asset: asset.Asset, AssetDir: asset.AssetDir, AssetInfo: asset.AssetInfo, Prefix: "template", Fallback: "index.html"}
r.StaticFS("/css", &fs)
r.StaticFS("/fonts", &fs)
r.StaticFS("/img", &fs)
r.StaticFS("/js", &fs)
r.StaticFS("/favicon.ico", &fs)
r.StaticFS("/index", &fs)
r.GET("/", func(c *gin.Context) {
	c.Writer.WriteHeader(200)
	indexHtml, _ := asset.Asset("template/index.html")
	_, _ = c.Writer.Write(indexHtml)
	c.Writer.Header().Add("Accept", "text/html")
	c.Writer.Flush()
})

（2）示例二

     r := gin.Default()
	fs := assetfs.AssetFS{Asset: asset.Asset, AssetDir: asset.AssetDir, AssetInfo: asset.AssetInfo, Prefix: "view", Fallback: "index.html"}
	r.StaticFS("/", &fs)
	
	r1 := multitemplate.New()
	bytes, err := asset.Asset("view/rs.html")
	if err != nil {
		fmt.Println(err)
		return
	}
	t, err := template.New("rs.html").Parse(string(bytes))
	fmt.Println(t, err)
	r1.Add("rs.html", t)
	r.HTMLRender = r1

	r.POST("/api", ResultHandler)
	r.Run(":8090") // 修改端口号, 默认8080

func ResultHandler(c *gin.Context) {
	details := MakeDetails(date1, date2, purl)
	c.HTML(http.StatusOK, "rs.html", details)  //这样就实现了参数的传递
}

（3）示例三

	r := gin.Default()
	fs := assetfs.AssetFS{Asset: asset.Asset, AssetDir: asset.AssetDir, AssetInfo: asset.AssetInfo, Prefix: "view", Fallback: "index.html"}

	r.StaticFS("/", &fs)

	bytes, err := asset.Asset("view/rs.html")
	if err != nil {
		fmt.Println(err)
		return
	}
	t, err := template.New("rs.html").Parse(string(bytes))
	r.SetHTMLTemplate(t)	

	r.POST("/api", ResultHandler)
	r.Run(":8090") // 修改端口号, 默认8080

func ResultHandler(c *gin.Context) {
	details := MakeDetails(date1, date2, purl)
	c.HTML(http.StatusOK, "rs.html", details)  //这样就实现了参数的传递
}

gaoluhua

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
go-bindata 与 gin 的结合对html进行渲染

Gin 是一个用 Go (Golang) 编写的 Web 框架。go-bindata 将任何文件封装在一个 Go 语言的 Source Code 里面，文件数据在转换为原始字节时可以选择使用 gzip 压缩，同时提供了统一的接口，帮助获取原始的文件数据.本文就是用go-bindata对html文件进行打包，实际上是生成asset.go文件，然后通过gin对asset.go进行渲染，特别是本文探讨了如何在渲染过程中传递参数。
复制链接

扫一扫

专栏目录