Apa itu embed? Bagaimanakah Go menggunakannya untuk memuatkan fail statik?

Artikel ini diperkenalkan oleh ruangan tutorial go language untuk memperkenalkan cara menggunakan embed untuk memuatkan fail statik dalam Golang1.16 Saya harap ia dapat membantu rakan yang memerlukan!

                                                                                                                                               

Apakah itu benam?

benam ialah pakej baharu yang ditambahkan dalam Go 1.16. Melalui arahan //go:embed, ia boleh membungkus fail sumber statik ke dalam atur cara yang disusun semasa fasa penyusunan dan menyediakan keupayaan untuk mengakses fail ini.

Mengapa anda perlu membenamkan

Pada masa lalu, ramai rakan yang bertukar kepada bahasa Go daripada bahasa lain akan bertanya, atau melangkah ke dalam lubang : Diandaikan bahawa fail binari yang dibungkus oleh bahasa Go akan termasuk kompilasi bersama dan pembungkusan fail konfigurasi.

Akibatnya, sebaik sahaja fail binari dialihkan, aplikasi tidak boleh dijalankan kerana sumber fail statik tidak boleh dibaca.

Jika sumber statik tidak boleh disusun dan dibungkus ke dalam fail binari, biasanya terdapat dua penyelesaian:

• Pertama ialah mengenal pasti jenis sumber statik ini dan sama ada anda perlu mengikuti program.
• Yang kedua ialah membungkusnya ke dalam fail binari.

Dalam kes kedua, Go tidak menyokongnya sebelum ini, jadi semua orang akan menggunakan pelbagai perpustakaan sumber terbuka yang mewah, seperti: go-bindata/go-bindata untuk mencapainya.

Tetapi bermula dari Go 1.16, bahasa Go itu sendiri secara rasmi menyokong ciri ini.

Ia mempunyai kelebihan berikut

• Ia boleh membungkus sumber statik ke dalam pakej binari, dan proses penggunaan adalah lebih mudah. Penggunaan tradisional sama ada memerlukan pembungkusan dan memuat naik sumber statik bersama-sama atur cara yang disusun, atau mengautomasikan yang pertama menggunakan docker dan dockerfile, yang menyusahkan.
• Pastikan integriti program . Kerosakan atau kehilangan sumber statik semasa operasi biasanya menjejaskan operasi biasa program.
• Akses sumber statik tidak memerlukan operasi io dan akan menjadi sangat pantas.

Penggunaan asas benam

Melalui dokumentasi rasmi Kami mengetahui tiga cara benam: rentetan, bait dan FS (Sistem Fail). Jenis string dan []byte hanya boleh memadankan satu fail Jika anda ingin memadankan berbilang fail atau direktori, anda mesti menggunakan jenis embed.FS.

Nota istimewa: pakej benam mesti diimport Jika import tidak digunakan, gunakan _ untuk mengimportnya

1 rentetan aksara

---

Contohnya, terdapat fail hello.txt di bawah fail semasa dan kandungan fail ialah hello,world!. Melalui arahan go:embed, nilai pembolehubah s dalam atur cara berikut menjadi hello,world! selepas penyusunan.

package mainimport (
    _ "embed"
    "fmt")//go:embed hello.txtvar s stringfunc main() {
    fmt.Println(s)}

2 Membenamkan sebagai kepingan bait

---

Anda juga boleh membenamkan kandungan satu fail sebagai kepingan bait, iaitu tatasusunan bait .

package mainimport (
    _ "embed"
    "fmt")//go:embed hello.txtvar b []bytefunc main() {
    fmt.Println(b)}

3 Benamkan sebagai fs.FS

---

Anda juga boleh membenamkan sebagai sistem fail, yang sangat berguna apabila membenamkan berbilang fail .

Sebagai contoh, benamkan fail:

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

benamkan fail setempat lain hello2.txt, sokong berbilang arahan go:embed pada pembolehubah yang sama (benamkan sebagai rentetan atau kepingan bait tidak boleh Terdapat berbilang go:embed arahan):

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

Benamkan arahan go:embed semasa berulang ke dalam embed.FS disokong, yang bersamaan dengan satu:

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

OK Benamkan fail dalam 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))}

benamkan penggunaan Lanjutan

Go1.16 juga menambah pakej baharu untuk menyokong embedio/fs. Menggabungkan kedua-duanya boleh beroperasi seperti fail biasa sebelum ini.

1 Baca sahaja

Kandungan terbenam ialah baca sahaja. Iaitu, apakah kandungan fail terbenam pada masa penyusunan, kemudian apakah kandungan semasa runtime.

Nilai sistem fail FS menyediakan kaedah untuk membuka dan membaca, dan tiada kaedah tulis Ini bermakna kejadian FS selamat untuk benang dan berbilang goroutin boleh digunakan secara serentak.

struktur benam.FS terutamanya mempunyai tiga kaedah luaran, seperti berikut:

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

2. Membenamkan berbilang fail

---

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

Sudah tentu anda juga boleh menulis berbilang baris seperti contoh sebelumnya 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))}

3. Sokongan pemisahan folder

---

Simbol menggunakan ke hadapan slash /, malah sistem Windows juga menggunakan corak ini.

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

Atas ialah kandungan terperinci Apa itu embed? Bagaimanakah Go menggunakannya untuk memuatkan fail statik?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!