go1.16新特性 内置内嵌资源文件的支持

go1.16已经入冻结阶段，这一次较重大的更新是对内嵌资源文件的支持。

内嵌资源文件

典型场景：当你需要在云应用程序中实现一个自动发送邮件的功能时，需要一个html文件作为邮件的模板，一般情况下可以将这个html文件放在指定目录，在go代码中指定路径来读取它。
有一种更加简便的办法，就是将这个html文件用一些手段生成成go文件中的一个变量，这样这个文件就作为代码的一部分，可以在代码中直接使用了。
目前比较常用的是go-bindata工具。

使用go-bindata

安装
go get -u github.com/jteeuwen/go-bindata/...

# test.tpl是模板文件
➜  ls
go.mod   go.sum   test.tpl main.go

使用go-bindata生成go文件 tpl.go
➜  go-bindata -o tpl.go test.tpl
➜  ls
go.mod   go.sum   main.go  test.tpl tpl.go

生成的go文件的内容

package main

import (
        "bytes"
        "compress/gzip"
        "fmt"
        "io"
        "strings"
)

func bindata_read(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)
        gz.Close()

        if err != nil {
                return nil, fmt.Errorf("Read %q: %v", name, err)
        }

        return buf.Bytes(), nil
}

var _test_tpl = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xb2\x49\xca\x4f\xa9\xb4\xe3\xb2\x89\x01\xd3\x80\x00\x00\x00\xff\xff\x68\x04\xe9\x1d\x0e\x00\x00\x00")

func test_tpl() ([]byte, error) {
        return bindata_read(
                _test_tpl,
                "test.tpl",
        )
}

// Asset loads and returns the asset for the given name.
// It returns an error if the asset could not be found or
// could not be loaded.
func Asset(name string) ([]byte, error) {
        cannonicalName := strings.Replace(name, "\\", "/", -1)
        if f, ok := _bindata[cannonicalName]; ok {
                return f()
        }
        return nil, fmt.Errorf("Asset %s not found", name)
}

// AssetNames returns the names of the assets.
func AssetNames() []string {
        names := make([]string, 0, len(_bindata))
        for name := range _bindata {
                names = append(names, name)
        }
        return names
}

// _bindata is a table, holding each asset generator, mapped to its name.
var _bindata = map[string]func() ([]byte, error){
        "test.tpl": test_tpl,
}
// AssetDir returns the file names below a certain
// directory embedded in the file by go-bindata.
// For example if you run go-bindata on data/... and data contains the
// following hierarchy:
//     data/
//       foo.txt
//       img/
//         a.png
//         b.png
// then AssetDir("data") would return []string{"foo.txt", "img"}
// AssetDir("data/img") would return []string{"a.png", "b.png"}
// AssetDir("foo.txt") and AssetDir("notexist") would return an error
// AssetDir("") will return []string{"data"}.
func AssetDir(name string) ([]string, error) {
        node := _bintree
        if len(name) != 0 {
                cannonicalName := strings.Replace(name, "\\", "/", -1)
                pathList := strings.Split(cannonicalName, "/")
                for _, p := range pathList {
                        node = node.Children[p]
                        if node == nil {
                                return nil, fmt.Errorf("Asset %s not found", name)
                        }
                }
        }
        if node.Func != nil {
                return nil, fmt.Errorf("Asset %s not found", name)
        }
        rv := make([]string, 0, len(node.Children))
        for name := range node.Children {
                rv = append(rv, name)
        }
        return rv, nil
}

type _bintree_t struct {
        Func func() ([]byte, error)
        Children map[string]*_bintree_t
}
var _bintree = &_bintree_t{nil, map[string]*_bintree_t{
        "test.tpl": &_bintree_t{test_tpl, map[string]*_bintree_t{
        }},
}}

生成以上的go文件就可以通过AssetDir方法直接返回文件的内容了。

➜  ll
total 40
-rw-r--r--  1 wll  staff   120B 11 22 23:31 go.mod
-rw-r--r--  1 wll  staff   205B 11 22 23:31 go.sum
-rw-r--r--  1 wll  staff    13B 11 22 23:30 main.go
-rw-r--r--  1 wll  staff    14B 11 22 23:58 test.tpl
-rw-r--r--  1 wll  staff   2.6K 11 22 23:59 tpl.go # 文件比tpl大的多

这样做的缺点也很明显，生成的文件大，需要依赖第三方生成器。

go1.16的内嵌资源

package main

import (
    "fmt"
    _ "embed"
)

//go:embed test.tpl
var tpl []byte

func main() {
    fmt.Println(tpl)
}

以上是go1.16内嵌资源的方法。
通过引入embed包，定义一个[]byte类型的变量，通过//go:embed test.tpl这段段代码标记这个变量读取的静态文件，使用go build，即可生成对应的go文件。
比起上面那个go-bindate，可以说是十分简单优雅了。