golang：打包静态文件

素颜马尾好姑娘i 2023-07-13 13:46 17阅读 0赞

对于 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

其路径变为：

**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`，就可以看到嵌入的静态资源目录的内容了  
![在这里插入图片描述][20200312164135946.png]  
和 Nginx 查看静态文件目录一样的。

### 例子二 ###

*  目录

ConfigTest
    ├── asset
    │   └── asset.go     静态文件编译之后的go文件
    ├── cli              # 运行目录
    ├── config           # 配置文件目录
    │   ├── config.html
    └── main            # 程序目录
        └── main.go     # 源码

*  config.html内容

<html>
    <body>
    
    <h1>My First Heading</h1>
    
    <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][https_www.cnblogs.com_landv_p_11577213.html]

[20200312164135946.png]: https://img-blog.csdnimg.cn/20200312164135946.png
[https_www.cnblogs.com_landv_p_11577213.html]: https://www.cnblogs.com/landv/p/11577213.html