内容简介:对于 Go 语言开发者来说,在享受语言便利性的同时,最终编译的单一可执行文件也是我们所热衷的。但是,Go在编译成二进制文件时并没有把我们的静态资源文件编译进去,如果我们开发的是web应用的话就需要想办法把我们的静态文件也编译进去。本文收集了一些Go语言中用来在编译过程中将静态文件打包到编译文件的方法。
对于 Go 语言开发者来说,在享受语言便利性的同时,最终编译的单一可执行文件也是我们所热衷的。
但是,Go在编译成二进制文件时并没有把我们的静态资源文件编译进去,如果我们开发的是web应用的话就需要想办法把我们的静态文件也编译进去。
本文收集了一些Go语言中用来在编译过程中将静态文件打包到编译文件的方法。
go-bindata
在 Go 语言的 Awesome 中你可以看到很多静态打包库,但是,你却看不到 go-bindata, go-bindata 明显更受欢迎,更流行。
go-bindata 很简单,设计理念也不难理解。它的任务就是讲静态文件封装在一个 Go 语言的 Source Code 里面,然后提供一个统一的接口,你通过这个接口传入文件路径,它将给你返回对应路径的文件数据。这也就是说它不在乎你的文件是字符型的文件还是字节型的,你自己处理,它只管包装。
简单来说就是它可以把我们的静态文件生成 .go
文件,这样就可以编译成二进制文件,项目启动的时候再把这个 .go
文件再释放成静态文件
使用
打包整个静态目录,使用的时候释放
# 目录结构 ConfigTest ├── asset │ └── asset.go 静态文件编译之后的go文件 ├── config # 静态文件目录 │ ├── rule.yaml │ └── rule.json ├── cli # 运行目录 │ ├── config 执行main释放出来的静态文件 │ │ ├── rule.yaml │ │ └── rule.json │ └── main # main.go编译之后生成的二进制执行文件 └── main 程序目录 └── main.go # 源码
执行命令将静态文件打包成go文件
go-bindata -o=./asset/asset.go -pkg=asset config/... -o # 指定打包后生成的go文件路径 -pkg # 指定go文件的包名 config/... # 指定需要打包的静态文件路径
main函数中解压静态文件
package main import "ConfigTest/asset" func main() { dirs := []string{"config"} // 设置需要释放的目录 for _, dir := range dirs { // 解压dir目录到当前目录 if err := asset.RestoreAssets("./", dir); err != nil { break } } }
编译 main.go
执行二进制文件
cd cli && go build ../main/main.go ./main # 执行之后会自动解压出config目录以及下面的静态文件
使用
目录结构
ConfigTest ├── asset │ └── asset.go 静态文件编译之后的go文件 ├── cli # 运行目录 │ ├── config │ │ ├── config.json │ │ └── config.yaml │ └── main # main.go编译之后生成的二进制执行文件 ├── config # 配置文件目录 │ ├── config.json │ └── config.yaml └── main # 程序目录 └── main.go # 源码
yaml配置文件内容
enabled: true path: aaaaa id: 10
json文件内容
{ "enabled": true, "path": "xxxx", "id": 111 }
main.go
package main import ( "ConfigTest/asset" "encoding/json" "fmt" "log" "os" "path/filepath" yaml "gopkg.in/yaml.v2" ) 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) } } func restore() { 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() }
执行命令将静态文件打包成go文件
go-bindata -o=./asset/asset.go -pkg=asset config/... -o # 指定打包后生成的go文件路径 -pkg # 指定go文件的包名 config/... # 指定需要打包的静态文件路径
编译 main.go
执行二进制文件
cd cli && go build ../main/main.go ./main json: {true xxxx 111} yaml: {true aaaaa 10} 释放静态文件 # 执行之后会自动解压出config目录以及下面的静态文件
http.FileSystem
http.FileSystem
是定义 HTTP 静态文件服务的接口。 go-bindata
的第三方包 go-bindata-assetfs
实现了这个接口,支持 HTTP 访问静态文件目录的行为。
// import ( // "net/http" // "github.com/elazarl/go-bindata-assetfs" // "github.com/go-xiaohei/pugo/app/asset" // 用 pugo 的asset.go进行测试 // ) 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
,就可以看到嵌入的静态资源目录的内容了
go.rice
go.rice
也支持打包静态文件到 go 文件中,但是行为和 go-bindata
很不相同。从使用角度, go.rice
其实是更便捷的静态文件操作库。打包静态文件反而是顺带的功能。
安装
go get github.com/GeertJohan/go.rice/...
使用
go.rice
把一个目录认为是一个 rice.Box
操作
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 的打包命令是 rice。用起来非常直接:在有使用 go.rice 操作的 go 代码目录,直接执行 rice embed-go:
rice embed-go rice -i "github.com/fuxiaohei/xyz" embed-go // -i 处理指定包里的 go.rice 操作
他就会生成当前包名下的、嵌入了文件的代码 rice-box.go
。但是,它不递归处理 import。他会分析当前目录下的 go 代码中 go.rice
的使用,找到对应需要嵌入的文件夹。但是子目录下的和 import 的里面的 go.rice
使用不会分析,需要你手动 cd
过去或者 -i
指定要处理的包执行命令。这点来说非常的不友好。
http.FileSystem
go.rice
是直接支持 http.FileSystem
接口:
func main() { // MustFindBox 出错直接 panic http.Handle("/", http.FileServer(rice.MustFindBox("theme").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
http.FileSystem
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 使用。例如 pugo 的入口文件就有:
package main import ( "os" "time" "github.com/go-xiaohei/pugo/app/command" "github.com/go-xiaohei/pugo/app/vars" "github.com/urfave/cli" ) //go:generate go-bindata -o=app/asset/asset.go -pkg=asset source/... theme/... doc/source/... doc/theme/... // ......
以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持 码农网
猜你喜欢:- 多页应用增量更新静态资源Webpack打包方案
- Webpack4 学习笔记 - 03:loader 打包静态资源(样式)
- 详解vue静态资源打包中的坑与解决方案
- 小程序静态资源无缝转移到腾讯云COS 使用wepy mpvue 等webpack打包的小程序项目
- 静态库遇到静态库
- 全局变量,静态全局变量,局部变量,静态局部变量
本站部分资源来源于网络,本站转载出于传递更多信息之目的,版权归原作者或者来源机构所有,如转载稿涉及版权问题,请联系我们。