golang：打包静态文件
对于 Go 语言开发者来说，在享受语言便利性的同时，最终编译的单一可执行文件也是我们所热衷的。
但是，Go在编译成二进制文件时并没有把我们的静态资源文件编译进去，如果我们开发的是web应用的话就需要想办法把我们的静态文件也编译进去。
本文收集了一些Go语言中用来在编译过程中将静态文件打包到编译文件的方法。
go-bindata
在 Go 语言的 Awesome 中你可以看到很多静态打包库，但是，你却看不到 go-bindata， go-bindata 明显更受欢迎，更流行。
go-bindata 很简单，设计理念也不难理解。它的任务就是讲静态文件封装在一个 Go 语言的 Source Code 里面，然后提供一个统一的接口，你通过这个接口传入文件路径，它将给你返回对应路径的文件数据。这也就是说它不在乎你的文件是字符型的文件还是字节型的，你自己处理，它只管包装。
简单来说就是它可以把我们的静态文件生成 .go 文件，这样就可以编译成二进制文件，项目启动的时候再把这个 .go 文件再释放成静态文件
下载
go get -u github.com/jteeuwen/go-bindata/...
安装确认
C:\Users\Administrator\Desktop>go-bindata -version
go-bindata 3.1.0 (Go runtime go1.14).
Copyright (c) 2010-2013, Jim Teeuwen.
注意： GOPATH必须在环境变量下
使用
例子一
ConfigTest
├── asset
│ └── asset.go 静态文件编译之后的go文件
├── cli # 运行目录
├── config # 配置文件目录
│ ├── config.json
│ └── config.yaml
└── main # 程序目录
└── main.go # 源码
config.yaml内容
enabled: true
path: aaaaa
id: 10
config.json内容
{
"enabled": true,
"path": "xxxx",
"id": 111
}
执行命令将静态文件打包成go文件
go-bindata -o=./asset/asset.go -pkg=asset config/...
-o 输出文件到 ./asset/asset.go
包名 -pkg=asset
config/… # 指定需要打包的静态文件路径， …包括所有子目录
// 可以参考：https://www.cnblogs.com/landv/p/11577213.html
其路径变为：
ConfigTest
├── asset
│ └── asset.go 静态文件编译之后的go文件
├── cli # 运行目录
├── config # 配置文件目录
│ ├── config.json
│ └── config.yaml
└── main # 程序目录
└── main.go # 源码
main.go
package main
import (
"configTest/asset"
"encoding/json"
"fmt"
"gopkg.in/yaml.v2"
"log"
"os"
"path/filepath"
)
type conf struct {
Enabled bool
Path string
ID int
}
func (c *conf) ReadYaml() {
data, _ := asset.Asset("config/config.yaml")
err := yaml.Unmarshal(data, &c)
if err != nil {
log.Fatalf("Unmarshal: %v", err)
}
}
func (c *conf) ReadJson() {
data, _ := asset.Asset("config/config.json")
err := json.Unmarshal(data, &c)
if err != nil {
log.Fatalf("Unmarshal: %v", err)
}
}
// 将dir解压到当前目录：根据生成的.go文件，将其解压为当前文件
func restore() {
// 可以参考：https://www.cnblogs.com/landv/p/11577213.html
dirs := []string{"config"} // 设置需要释放的目录
isSuccess := true
for _, dir := range dirs {
// 解压dir目录到当前目录
if err := asset.RestoreAssets("./", dir); err != nil {
isSuccess = false
break
}
}
if !isSuccess {
for _, dir := range dirs {
os.RemoveAll(filepath.Join("./", dir))
}
}
}
func main() {
var c, j conf
j.ReadJson()
fmt.Println("json:", j)
c.ReadYaml()
fmt.Println("yaml:", c)
fmt.Println("释放静态文件")
restore()
}
- 编译 main.go 执行二进制文件
cd cli && go build ../main/main.go
./main
json: {true xxxx 111}
yaml: {true aaaaa 10}
释放静态文件
执行之后会自动解压出config目录以及下面的静态文件
ConfigTest
├── asset
│ └── asset.go 静态文件编译之后的go文件
├── cli # 运行目录
│ ├── config # 调用了restore()会生成这个文件
│ │ ├── config.json
│ │ └── config.yaml
│ └── main # main.go编译之后生成的二进制执行文件
├── config # 配置文件目录
│ ├── config.json
│ └── config.yaml
└── main # 程序目录
└── main.go # 源码
main.go
http.FileSystem是定义HTTP静态文件服务的接口。go-bindata的第三方包，go-bindata-assetfs实现了这个接口，支持http访问静态文件目录的行为。
package main
import (
"configTest/asset"
assetfs "github.com/elazarl/go-bindata-assetfs"
"net/http"
)
func myhttp() {
fs := assetfs.AssetFS{
Asset: asset.Asset,
AssetDir: asset.AssetDir,
AssetInfo: asset.AssetInfo,
}
http.Handle("/", http.FileServer(&fs))
http.ListenAndServe(":12345", nil)
}
func main() {
myhttp()
}
访问 http://localhost:12345，就可以看到嵌入的静态资源目录的内容了
和 Nginx 查看静态文件目录一样的。
例子二
- 目录
ConfigTest
├── asset
│ └── asset.go 静态文件编译之后的go文件
├── cli # 运行目录
├── config # 配置文件目录
│ ├── config.html
└── main # 程序目录
└── main.go # 源码
- config.html内容
<html>
<body>
<h1>My First Headingh1>
<p>My first paragraph.p>
body>
html>
- 打包命令：生成./asset/asset.go
go-bindata -o=./asset/asset.go -pkg=asset config/...
- main内容：
package main
import (
"configTest/asset"
"fmt"
assetfs "github.com/elazarl/go-bindata-assetfs"
"github.com/gin-contrib/multitemplate"
"github.com/gin-gonic/gin"
"html/template"
)
func main() {
fs := assetfs.AssetFS{
Asset: asset.Asset,
AssetDir: asset.AssetDir,
AssetInfo: asset.AssetInfo,
}
router := gin.Default()
router.StaticFS("/static", &fs)
r := multitemplate.New()
bytes, err := asset.Asset("config/config.html") // 根据地址获取对应内容
if err != nil {
fmt.Println(err)
return
}
t, err := template.New("index").Parse(string(bytes)) // 比如用于模板处理
r.Add("index", t)
router.HTMLRender = r
router.GET("/image", func(c *gin.Context) {
c.HTML(200, "index", gin.H{})
})
router.Run(":12345")
}
go.rice【不好用】
go.rice 也支持打包静态文件到 go文件中，但是行为和 go-bindata很不相同。从使用角度，go.rice其实是更便捷的静态文件操作库。打包静态文件反而是顺带的功能。
安装
go get github.com/GeertJohan/go.rice/...
使用一
import (
"fmt"
"html/template"
"github.com/GeertJohan/go.rice"
)
func main() {
// 这里写相对于的执行文件的地址
box, err := rice.FindBox("theme/default")
if err != nil {
println(err.Error())
return
}
// 从目录 Box 读取文件
str, err := box.String("post.html")
if err != nil {
println(err.Error())
return
}
t, err := template.New("tpl").Parse(str)
fmt.Println(t, err)
}
使用二
go.rice 是直接支持 http.FileSystem 接口：
package main
import (
"github.com/GeertJohan/go.rice"
"net/http"
)
func main() {
http.Handle("/", http.FileServer(rice.MustFindBox("../config").HTTPBox()))
http.ListenAndServe(":12345", nil)
}
有点略繁琐的是 rice.FindBox(dir) 只能加载一个目录。因此需要多个目录的场景，会有代码：
func main() {
http.Handle("/img", http.FileServer(rice.MustFindBox("static/img").HTTPBox()))
http.Handle("/css", http.FileServer(rice.MustFindBox("static/css").HTTPBox()))
http.Handle("/js", http.FileServer(rice.MustFindBox("static/js").HTTPBox()))
http.ListenAndServe(":12345", nil)
}
esc
esc 的作者在研究几款嵌入静态资源的 工具 后，发觉都不好用，就自己写出了 esc。它的需求很简单，就是嵌入静态资源 和 支持 http.FileSystem 。esc 工具也这两个主要功能。
安装
go get github.com/mjibson/esc
使用
使用方法和 go-bindata 类似：
// 注意 esc 不支持 source/... 三个点表示所有子目录
go-bindata -o=asset/asset.go -pkg=asset source theme doc/source doc/theme
import (
"net/http"
"asset" // esc 生成 asset/asset.go
)
func main() {
fmt.Println(asset.FSString(false, "/theme/default/post.html")) // 读取单个文件
http.ListenAndServe(":12345", http.FileServer(asset.FS(false))) // 支持 http.FileSystem，但是没有做展示目录的支持
}
esc 有个较大的问题是只能一个一个文件操作，不能文件夹操作，没有类似 go-bindata 的 asset.RestoreDir() 方法。并且没有方法可以列出嵌入的文件的列表，导致也无法一个一个文件操作，除非自己写死。这是我不使用他的最大原因。
go generate
嵌入静态资源的工具推荐配合 go generate 使用
参考：https://www.cnblogs.com/landv/p/11577213.html