Heim >Backend-Entwicklung >Golang >Was ist Einbetten? Wie lädt Go damit statische Dateien?
Was ist Einbetten? Wie lädt Go damit statische Dateien?
- 藏色散人nach vorne
- 2021-11-12 14:31:443878Durchsuche
Dieser Artikel wurde von der Go-SpracheTutorial-Kolumne geschrieben, um Ihnen vorzustellen, wie Sie mit Embed statische Dateien in Golang1.16 laden. Ich hoffe, dass er Freunden in Not hilfreich sein wird!
Warum müssen Sie einbetten?
In der Vergangenheit fragten viele Freunde, die von anderen Sprachen zur Go-Sprache wechselten, oder traten in eine Falle: Sie dachten, dass die Binärdatei von Go gepackt wurde Die Sprache würde die Konfigurationsdatei enthalten. Gemeinsame Kompilierung und Verpackung. //go:embed指令，可以在编译阶段将静态资源文件打包进编译好的程序中，并提供访问这些文件的能力。
为什么需要embed
在以前，很多从其他语言转过来Go语言的小伙伴会问到，或者踩到一个坑：就是以为Go语言所打包的二进制文件中会包含配置文件的联同编译和打包。
结果往往一把二进制文件挪来挪去，就无法把应用程序运行起来了，因为无法读取到静态文件的资源。
无法将静态资源编译打包二进制文件的话，通常会有两种解决方法：
- 第一种是识别这类静态资源，是否需要跟着程序走。
- 第二种就是将其打包进二进制文件中。
第二种情况的话，Go以前是不支持的，大家就会借助各种花式的开源库，例如：go-bindata/go-bindata来实现。
但是在Go1.16起，Go语言自身正式支持了该项特性。
它有以下优点
-
能够将静态资源打包到二进制包中，部署过程更简单。传统部署要么需要将静态资源与已编译程序打包在一起上传，或者使用
docker和dockerfile自动化前者，这是很麻烦的。 - 确保程序的完整性。在运行过程中损坏或丢失静态资源通常会影响程序的正常运行。
- 静态资源访问没有io操作，速度会非常快。
embed基础用法
通过 官方文档 我们知道embed嵌入的三种方式：string、bytes 和 FS（File Systems）。其中string和[]byte类型都只能匹配一个文件，如果要匹配多个文件或者一个目录，就要使用embed.FS类型。
特别注意：embed这个包一定要导入，如果导入不使用的话，使用 _ 导入即可
一、嵌入为字符串
比如当前文件下有个hello.txt的文件，文件内容为hello,world!。通过go:embed指令，在编译后下面程序中的s变量的值就变为了hello,world!。
package mainimport (
_ "embed"
"fmt")//go:embed hello.txtvar s stringfunc main() {
fmt.Println(s)}
二、嵌入为byte slice
你还可以把单个文件的内容嵌入为slice of byte，也就是一个字节数组。
package mainimport (
_ "embed"
"fmt")//go:embed hello.txtvar b []bytefunc main() {
fmt.Println(b)}
三、嵌入为fs.FS
甚至你可以嵌入为一个文件系统，这在嵌入多个文件的时候非常有用。
比如嵌入一个文件：
package mainimport (
"embed"
"fmt")//go:embed hello.txtvar f embed.FSfunc main() {
data, _ := f.ReadFile("hello.txt")
fmt.Println(string(data))}
嵌入本地的另外一个文件hello2.txt, 支持同一个变量上多个go:embed指令(嵌入为string或者byte slice是不能有多个go:embed指令的):
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))}
当前重复的go:embed指令嵌入为embed.FS是支持的，相当于一个:
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))}
还可以嵌入子文件夹下的文件：
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进阶用法
Go1.16 为了对 embed 的支持也添加了一个新包 io/fs。两者结合起来可以像之前操作普通文件一样。
一、只读
嵌入的内容是只读的。也就是在编译期嵌入文件的内容是什么，那么在运行时的内容也就是什么。
FS文件系统值提供了打开和读取的方法，并没有write的方法，也就是说FS实例是线程安全的，多个goroutine可以并发使用。
embed.FS结构主要有3个对外方法，如下：
// Open 打开要读取的文件，并返回文件的fs.File结构.func (f FS) Open(name string) (fs.File, error)// ReadDir 读取并返回整个命名目录func (f FS) ReadDir(name string) ([]fs.DirEntry, error)// ReadFile 读取并返回name文件的内容.func (f FS) ReadFile(name string) ([]byte, error)
二、嵌入多个文件
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))}
当然你也可以像前面的例子一样写成多行go:embed:
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))}
三、支持文件夹
文件夹分隔符采用正斜杠/
- Die erste besteht darin, solche statischen Ressourcen zu identifizieren und festzustellen, ob Sie dem Programm folgen müssen.
- Die zweite besteht darin, es in eine Binärdatei zu packen.
go-bindata/go-bindata, um dies zu erreichen . 🎜🎜Aber ab Go 1.16 unterstützt die Go-Sprache selbst diese Funktion offiziell. 🎜🎜Es hat die folgenden Vorteile:🎜- 🎜Es kann statische Ressourcen in Binärpakete packen, was den Bereitstellungsprozess einfacher macht🎜. Die herkömmliche Bereitstellung erfordert entweder das Packen und Hochladen statischer Ressourcen zusammen mit kompilierten Programmen oder die Verwendung von
dockerunddockerfile, um Ersteres zu automatisieren, was umständlich ist. - 🎜Stellen Sie die Programmintegrität sicher🎜. Eine Beschädigung oder ein Verlust statischer Ressourcen während des Betriebs beeinträchtigt normalerweise den normalen Betrieb des Programms.
- 🎜Der Zugriff auf statische Ressourcen erfordert keine IO-Vorgänge und erfolgt sehr schnell🎜.
🎜🎜Grundlegende Verwendung von Embed
🎜Durch die offizielle Dokumentation kennen wir die drei Arten der Einbettung: String, Bytes und FS (Dateisysteme). Unter diesen können die Typenstring und []byte nur mit einer Datei übereinstimmen. Wenn Sie mehrere Dateien oder ein Verzeichnis abgleichen möchten, müssen Sie embed.FS verwenden Typ. 🎜🎜Besonderer Hinweis: Wenn der Import nicht verwendet wird, verwenden Sie einfach _ zum Importieren🎜
🎜🎜1 Einbetten als Zeichenfolge
🎜Zum Beispiel befindet sich unter der aktuellen Datei eine Datei „hello.txt“ und der Inhalt der Datei lautet
hello, world!. Durch die go:embed-Direktive wird der Wert der s-Variablen im folgenden Programm nach der Kompilierung zu hello, world!. 🎜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))}
🎜🎜2. Einbetten als Byte-Slice
🎜Sie können den Inhalt einer einzelnen Datei auch als Byte-Slice einbetten, also ein Byte-Array. 🎜
//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 << 20
server := &http.Server{
Addr: endPoint,
Handler: routersInit,
ReadTimeout: readTimeout,
WriteTimeout: writeTimeout,
MaxHeaderBytes: maxHeaderBytes,
}
server.ListenAndServe()}
🎜🎜3. Als fs.FS einbetten
🎜Sie können sogar als Dateisystem einbetten, was beim Einbetten mehrerer Dateien sehr nützlich ist. 🎜🎜Zum Beispiel eine Datei einbetten: 🎜
func InitSetting(FS embed.FS) {
// 总配置处理
var err error
data, err := FS.ReadFile(".env")
if err != nil {
log.Fatalf("Fail to parse '.env': %v", err)
}
cfg, err = ini.Load(data)
if err != nil {
log.Fatal(err)
}
mapTo("server", ServerSetting)
ServerSetting.ReadTimeout = ServerSetting.ReadTimeout * time.Second
ServerSetting.WriteTimeout = ServerSetting.WriteTimeout * time.Second // 分版本配置引入
v1d0Setting.InitSetting(FS)}🎜Eine andere lokale Datei hello2.txt einbetten, mehrere go:embed-Anweisungen für dieselbe Variable unterstützen (eingebettet als String oder Byte-Slice kann nicht mehrere haben go:embed-Anweisung):🎜rrreee🎜Die aktuell wiederholte go:embed-Anweisung wird als embed.FS unterstützt, was einer:🎜rrreee🎜Es kann auch Dateien unter eingebettet werden Unterordner: 🎜rrreee🎜🎜embed advanced use
🎜Go1.16 fügt außerdem ein neues Paketio/fs zur Unterstützung von <code>embed hinzu. Das Kombinieren der beiden kann wie zuvor normale Dateien funktionieren. 🎜🎜🎜1. Schreibgeschützt
🎜Eingebettete Inhalte sind schreibgeschützt. Das heißt, was ist der Inhalt der eingebetteten Datei zur Kompilierungszeit und was ist dann der Inhalt zur Laufzeit? 🎜🎜Der FS-Dateisystemwert stellt Methoden zum Öffnen und Lesen bereit und es gibt keine Schreibmethode. Dies bedeutet, dass FS-Instanzen threadsicher sind und mehrere Goroutinen gleichzeitig verwendet werden können. Die Struktur 🎜🎜embed.FS verfügt hauptsächlich über drei externe Methoden: 🎜rrreee🎜🎜2 Mehrere Dateien einbetten
rrreee🎜Natürlich können Sie auch mehrere Zeilen wie im vorherigen Beispiel schreiben
go:embed:🎜rrreee🎜🎜3. Unterstützen Sie Ordner
🎜Das Ordnertrennzeichen verwendet Schrägstriche
/, auch bei Windows-Systemen Benutze auch dieses Modell. 🎜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))}
应用
在我们的项目中，是将应用的常用的一些配置写在了.env的一个文件上，所以我们在这里就可以使用go:embed指令。
main.go 文件：
//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 << 20
server := &http.Server{
Addr: endPoint,
Handler: routersInit,
ReadTimeout: readTimeout,
WriteTimeout: writeTimeout,
MaxHeaderBytes: maxHeaderBytes,
}
server.ListenAndServe()}
setting.go文件：
func InitSetting(FS embed.FS) {
// 总配置处理
var err error
data, err := FS.ReadFile(".env")
if err != nil {
log.Fatalf("Fail to parse '.env': %v", err)
}
cfg, err = ini.Load(data)
if err != nil {
log.Fatal(err)
}
mapTo("server", ServerSetting)
ServerSetting.ReadTimeout = ServerSetting.ReadTimeout * time.Second
ServerSetting.WriteTimeout = ServerSetting.WriteTimeout * time.Second // 分版本配置引入
v1d0Setting.InitSetting(FS)}Das obige ist der detaillierte Inhalt vonWas ist Einbetten? Wie lädt Go damit statische Dateien?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
Stellungnahme：
Dieser Artikel ist reproduziert unter:learnku.com. Bei Verstößen wenden Sie sich bitte an admin@php.cn löschen
Vorheriger Artikel：Welche Funken werden entstehen, wenn Golang und Lua sich treffen?Nächster Artikel：Welche Funken werden entstehen, wenn Golang und Lua sich treffen?