Shulou(Shulou.com)06/02 Report--

The main content of this article is to explain "what is golang embed". Interested friends may wish to take a look. The method introduced in this paper is simple, fast and practical. Let's let the editor take you to learn what golang embed is.

What is embed?

Embed is a new package added in Go 1.16. Through the / / go:embed directive, it can package static resource files into the compiled program during the compilation phase and provide the ability to access these files.

Why do you need embed

In the past, many friends who switched to Go from other languages would ask or step into a pit: they thought that the binaries packaged by the Go language would contain joint compilation and packaging of configuration files.

As a result, as soon as the binaries are moved around, the application cannot be run because the resources of the static files cannot be read.

If static resources cannot be compiled and packaged with binaries, there are usually two solutions:

The first is to identify such static resources and whether they need to follow the program.

The second is to package it into a binary file.

In the second case, Go is not supported in the past, so we will use a variety of fancy open source libraries, such as go-bindata/go-bindata.

However, since Go1.16, the Go language itself officially supports this feature.

It has the following advantages

The ability to package static resources into a binary package makes the deployment process easier. Traditional deployments either need to package static resources with compiled programs to upload, or use docker and dockerfile to automate the former, which is troublesome.

Ensure the integrity of the program. Damage or loss of static resources during operation usually affects the normal operation of the program.

Static resource access can be very fast without io operations.

Basic usage of embed

We know from the official documentation that there are three ways to embed embed: string, bytes, and FS (File Systems). Both the string and [] byte types can match only one file, and if you want to match multiple files or a directory, use the embed.FS type.

Special note: the package embed must be imported. If the import is not used, use _ import.

Embed as a string

For example, there is a hello.txt file under the current file, and its content is hello,world!. With the go:embed directive, the value of the s variable in the following program becomes hello,world! after compilation.

Package mainimport (_ "embed"fmt") / / go:embed hello.txtvar s stringfunc main () {fmt.Println (s)} II. Embed as byte slice

You can also embed the contents of a single file as slice of byte, which is a byte array.

Package mainimport (_ "embed"fmt") / / go:embed hello.txtvar b [] bytefunc main () {fmt.Println (b)} III. Embed as fs.FS

You can even embed it as a file system, which is useful when embedding multiple files.

For example, embed a file:

Package mainimport ("embed"fmt") / / go:embed hello.txtvar f embed.FSfunc main () {data, _: = f.ReadFile ("hello.txt") fmt.Println (string (data))}

Embed another local file, hello2.txt, to support multiple go:embed instructions on the same variable (embedded as string or byte slice cannot have multiple go:embed instructions):

Package mainimport ("embed"fmt") / / go:embed hello.txt//go:embed hello2.txtvar f embed.FSfunc main () {data, _: = f.ReadFile ("hello.txt") fmt.Println (string (data)) data, _ = f.ReadFile ("hello2.txt") fmt.Println (string (data))}

The current repeated go:embed instruction embedding as embed.FS is supported, which is equivalent to a:

Package mainimport ("embed"fmt") / / go:embed hello.txt//go:embed hello.txtvar f embed.FSfunc main () {data, _: = f.ReadFile ("hello.txt") fmt.Println (string (data))}

You can also embed files under a subfolder:

Package mainimport ("embed"fmt") / / go:embed p/hello.txt//go:embed p/hello2.txtvar f embed.FSfunc main () {data, _: = f.ReadFile ("p/hello.txt") fmt.Println (string (data)) data, _ = f.ReadFile ("p/hello2.txt") fmt.Println (string (data))} embed Advanced usage

Go1.16 has also added a new package io/fs to support embed. The combination of the two can be the same as before with ordinary files.

Read-only

Embedded content is read-only. That is, what is embedded in the file at compile time, that is, what is embedded at run time.

FS file system values provide methods for opening and reading, and there is no write method, which means that FS instances are thread-safe and multiple goroutine can be used concurrently.

There are three main external methods for embed.FS structure, as follows:

/ / Open opens the file to be read And return the fs.File structure of the file. Func (f FS) Open (name string) (fs.File, error) / / ReadDir reads and returns the entire named directory func (f FS) ReadDir (name string) ([] fs.DirEntry, error) / / ReadFile reads and returns the contents of the name file. Func (f FS) ReadFile (name string) ([] byte Error) II. Embed multiple files package mainimport ("embed"fmt") / / go:embed hello.txt hello2.txtvar f embed.FSfunc main () {data, _: = f.ReadFile ("hello.txt") fmt.Println (string (data)) data, _ = f.ReadFile ("hello2.txt") fmt.Println (string (data))}

Of course, you can also write multiple lines of go:embed as in the previous example:

Package mainimport ("embed"fmt") / / go:embed hello.txt//go:embed hello2.txtvar f embed.FSfunc main () {data, _: = f.ReadFile ("hello.txt") fmt.Println (string (data)) data, _ = f.ReadFile ("hello2.txt") fmt.Println (string (data))} 3. Support folder

The folder delimiter is a forward slash /, which is used even on windows systems.

Package mainimport ("embed"fmt") / / go:embed pvar f embed.FSfunc main () {data, _: = f.ReadFile ("p/hello.txt") fmt.Println (string (data)) data, _ = f.ReadFile ("p/hello2.txt") fmt.Println (string (data))} Application

In our project, some common configurations of the application are written on a file in .env, so we can use the go:embed directive here.

Main.go file:

/ go:embed ".env"v1d0/.env" var FS embed.FSfunc main () {setting.InitSetting (FS) manager.InitManager () cron.InitCron () routersInit: = routers.InitRouter () readTimeout: = setting.ServerSetting.ReadTimeout writeTimeout: = setting.ServerSetting.WriteTimeout endPoint: = fmt.Sprintf (":% d", setting.ServerSetting.HttpPort) maxHeaderBytes: = 1

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.