Qu'est-ce que l'intégration ? Comment Go l'utilise-t-il pour charger des fichiers statiques ?

Cet article est écrit par la colonne tutoriel go language pour vous présenter comment utiliser l'intégration pour charger des fichiers statiques dans Golang1.16. J'espère qu'il sera utile aux amis dans le besoin !

                                                                                                            Qu'est-ce que 什么 Embed ? Embed est un package nouvellement ajouté dans GO 1.16. Grâce à la directive //go:embed, il peut regrouper des fichiers de ressources statiques dans des programmes compilés pendant la phase de compilation et offrir la possibilité d'accéder à ces fichiers.

Pourquoi avez-vous besoin d'intégrer

Dans le passé, de nombreux amis qui sont passés à la langue Go à partir d'autres langues​​demandaient ou tombaient sur un piège : ils pensaient que le fichier binaire emballé par Go Le langage contiendrait le fichier de configuration Compilation et packaging conjoints. //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))}

三、支持文件夹

---

文件夹分隔符采用正斜杠/

Par conséquent, une fois le fichier binaire déplacé, l'application ne peut pas être exécutée car les ressources du fichier statique ne peuvent pas être lues. 🎜🎜Si les ressources statiques ne peuvent pas être compilées et regroupées dans des fichiers binaires, il existe généralement deux solutions : 🎜

• La première consiste à identifier ces ressources statiques et si vous devez suivre le programme.
• La seconde consiste à le regrouper dans un fichier binaire.

🎜Dans le deuxième cas, Go ne le supportait pas auparavant, donc tout le monde utilisera diverses bibliothèques open source sophistiquées, telles que : go-bindata/go-bindata pour réaliser . 🎜🎜Mais à partir de Go 1.16, le langage Go lui-même prend officiellement en charge cette fonctionnalité. 🎜🎜Il présente les avantages suivants🎜

• 🎜Il peut regrouper des ressources statiques dans des packages binaires, ce qui simplifie le processus de déploiement🎜. Le déploiement traditionnel nécessite soit de regrouper et de télécharger des ressources statiques avec des programmes compilés, soit d'utiliser docker et dockerfile pour automatiser le premier, ce qui est fastidieux.
• 🎜Assurer l'intégrité du programme🎜. Les dommages ou la perte de ressources statiques pendant le fonctionnement affectent généralement le fonctionnement normal du programme.
• 🎜L'accès aux ressources statiques ne nécessite pas d'opérations io et sera très rapide🎜.

🎜🎜Utilisation de base de l'intégration

🎜Grâce à la documentation officielle, nous connaissons les trois manières d'intégrer : chaîne, octets et FS (systèmes de fichiers). Parmi eux, les types string et []byte ne peuvent correspondre qu'à un seul fichier. Si vous souhaitez faire correspondre plusieurs fichiers ou un répertoire, vous devez utiliser embed.FS. Tapez. 🎜

🎜Remarque spéciale : le package d'intégration doit être importé Si l'importation n'est pas utilisée, utilisez simplement _ pour importer🎜

🎜🎜1 Intégrer sous forme de chaîne

---

🎜Par exemple, il y a un fichier hello.txt sous le fichier actuel, et le contenu du fichier est hello, world !. Grâce à la directive go:embed, la valeur de la variable s dans le programme suivant devient hello, world! après compilation. 🎜

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. Incorporation sous forme de tranche d'octets

---

🎜Vous pouvez également intégrer le contenu d'un seul fichier sous forme de tranche d'octets, qui est un tableau d'octets. 🎜

//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. Intégrer en tant que fs.FS

---

🎜Vous pouvez même intégrer en tant que système de fichiers, ce qui est très utile lors de l'intégration de plusieurs fichiers. 🎜🎜Par exemple, intégrez un fichier : 🎜

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)}

🎜Intégrez un autre fichier local hello2.txt, prenez en charge plusieurs instructions go:embed sur la même variable (intégrées sous forme de chaîne ou de tranche d'octets ne peuvent pas avoir plusieurs Instruction go:embed):🎜rrreee🎜L'instruction go:embed répétée actuelle est prise en charge sous le nom d'embed.FS, ce qui équivaut à un:🎜rrreee🎜Il peut également être intégré à des fichiers sous sous-dossiers : 🎜rrreee

🎜🎜utilisation avancée de l'intégration

🎜Go1.16 ajoute également un nouveau package io/fs pour prendre en charge <code>embed . La combinaison des deux peut fonctionner comme des fichiers ordinaires auparavant. 🎜

🎜🎜1. Lecture seule

🎜Le contenu intégré est en lecture seule. Autrement dit, quel est le contenu du fichier intégré au moment de la compilation, puis quel est le contenu au moment de l'exécution. 🎜🎜La valeur du système de fichiers FS fournit des méthodes d'ouverture et de lecture, et il n'y a pas de méthode d'écriture. Cela signifie que les instances FS sont thread-safe et que plusieurs goroutines peuvent être utilisées simultanément. La structure 🎜🎜embed.FS comporte principalement 3 méthodes externes, comme suit : 🎜rrreee

🎜🎜2 Incorporer plusieurs fichiers

---

rrreee🎜Bien sûr, vous pouvez également écrire plusieurs lignes comme dans l'exemple précédent. go:embed:🎜rrreee

🎜🎜3. Dossiers de support

---

🎜Le séparateur de dossiers utilise des barres obliques /, même sur les systèmes Windows. utilisez également ce modèle. 🎜

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)}

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!