Cara saya menulis Go API dalam pengalaman saya dengan Fuego

Pengalaman Saya Membina API Go dengan Fuego

Sebagai pembangun Go dengan pengalaman beberapa tahun, saya telah meneroka pelbagai rangka kerja web. Perjalanan saya termasuk perpustakaan standard, Gin, dan Fiber. Walaupun masing-masing mempunyai kelebihan, saya sering mendapati diri saya memerlukan lebih banyak struktur atau menghabiskan masa yang berlebihan untuk menyepadukan berbilang perpustakaan untuk pengesahan, penyiaran dan dokumentasi. Di situlah Fuego menukar permainan.

Pada mulanya, Fuego kelihatan seperti rangka kerja lain. Walau bagaimanapun, penggunaan ciri Go moden, terutamanya generik, untuk menjana spesifikasi OpenAPI secara automatik terus daripada kod, menarik minat saya. Saya memutuskan untuk mengujinya pada projek dalaman yang kecil, dan inilah akaun jujur ​​saya.

---

Tanggapan Pertama

Kesederhanaan Fuego segera terserlah. Menyediakan pelayan asas mengambil masa hanya beberapa minit:

<code class="language-go">package main

import "github.com/go-fuego/fuego"

func main() {
    s := fuego.NewServer()
    fuego.Get(s, "/", func(c fuego.ContextNoBody) (string, error) {
        return "Hello, World!", nil
    })
    s.Run()
}</code>

Keakraban itu sangat menarik—serupa dengan Gin, tetapi dengan sokongan OpenAPI terbina dalam.

---

Contoh Dunia Nyata

Contoh "Hello World" tidak menggambarkan kerumitan dunia sebenar. Aplikasi saya memerlukan pengendalian data JSON, pengesahan dan respons yang ditaip. Rangka kerja lain memerlukan penyahkodan JSON tersuai, pengendalian ralat dan penyepaduan middleware. Fuego memperkemas ini dengan banyak menggunakan pengendali laluan ditaip.

Berikut ialah pengendali laluan yang dipermudahkan:

<code class="language-go">type UserInput struct {
    Name string `json:"name" validate:"required"`
}

type UserOutput struct {
    Message string `json:"message"`
}

func main() {
    s := fuego.NewServer()
    fuego.Post(s, "/user", handleUser)
    s.Run()
}

func handleUser(c fuego.ContextWithBody[UserInput]) (UserOutput, error) {
    in, err := c.Body()
    if err != nil {
        return UserOutput{}, err
    }
    return UserOutput{Message: "Hello, " + in.Name}, nil
}</code>

Peningkatan utama:

1. Pengendali Ditaip: fuego.ContextWithBody[UserInput] secara automatik menyahsiri JSON ke dalam struct UserInput.
2. Pengesahan: validate:"required" memastikan medan Name ada; Fuego mengendalikan ralat dengan anggun.
3. Respons: Mengembalikan struct UserOutput secara automatik mensirikannya kepada JSON.

Ini menghapuskan kod plat dandang yang ketara—tiada json.Unmarshal, perpustakaan pengesahan luaran atau pengendalian ralat tersuai.

---

Mengapa Fuego Menyerlah

1. Native Go Feel: Tidak seperti rangka kerja yang banyak membalut net/http, Fuego berasa sangat asli. Ia menggunakan net/http secara langsung, membenarkan penyepaduan lancar bagi perisian tengah dan pengendali standard. Saya menggunakan semula perisian tengah pengesahan sedia ada tanpa masalah.

2. Penjanaan OpenAPI Automatik: Saya sebelum ini menguruskan fail YAML yang berasingan atau bergantung pada ulasan untuk spesifikasi OpenAPI, proses yang membosankan dan mudah ralat. Fuego menjana spesifikasi secara automatik daripada jenis pengendali laluan, memastikan dokumentasi sentiasa kekal terkini.

3. Pengesahan dan Pengendalian Ralat: Pengesahan bersepadu (menggunakan go-playground/validator) adalah intuitif dan pengendalian ralat dipermudahkan. Struktur UserInput tidak sah mengakibatkan mesej ralat berstruktur yang mematuhi piawaian RFC.

---

Transformasi Data

Untuk memastikan semua medan Name masuk adalah huruf kecil, saya memanfaatkan kaedah InTransform Fuego:

<code class="language-go">package main

import "github.com/go-fuego/fuego"

func main() {
    s := fuego.NewServer()
    fuego.Get(s, "/", func(c fuego.ContextNoBody) (string, error) {
        return "Hello, World!", nil
    })
    s.Run()
}</code>

Ini menukar data secara automatik sebelum sampai ke pengendali laluan.

---

Cabaran Dihadapi

1. Ekosistem yang Lebih Kecil: Pangkalan pengguna Fuego yang lebih kecil berbanding Gin atau Echo menyebabkan sumber komuniti yang lebih sedikit tersedia. Walau bagaimanapun, contoh dan dokumentasi repositori terbukti mencukupi.

2. Perisian Tengah Terbina Dalam Terhad: Walaupun Fuego menyediakan beberapa perisian tengah, ia tidak seluas beberapa rangka kerja lama. Keserasian net/http dibenarkan menggunakan perpustakaan luaran atau perisian tengah tersuai.

---

Kesimpulan

Fuego menawarkan keseimbangan yang menarik antara kemudahan dan fleksibiliti. Ia mempercepatkan pembangunan API dengan pengesahan terbina dalam, bersiri dan penjanaan dokumentasi, sambil kekal berpegang kepada prinsip Go. Menggunakan struct yang ditaip dan membiarkan Fuego menguruskan yang lain telah meningkatkan aliran kerja saya dengan ketara.

Faedah utama:

• Peningkatan Produktiviti: Kod yang lebih bersih dan plat dandang yang dikurangkan.
• Dokumentasi Automatik: Sentiasa kemas kini spesifikasi OpenAPI.
• Peralihan Lancar: Penyepaduan mudah dengan pengendali net/http sedia ada.

Jika anda mencari rangka kerja Go yang moden dan fleksibel, terutamanya jika anda bosan dengan penyelenggaraan OpenAPI manual, saya amat mengesyorkan Fuego. Ia memudahkan proses pembangunan saya sambil kekal berpegang kepada falsafah minimalis Go. Repositori GitHub menyediakan maklumat yang komprehensif dan peta jalan yang menjanjikan. Saya teruja dengan masa depannya dan akan terus menggunakannya untuk projek akan datang.

Atas ialah kandungan terperinci Cara saya menulis Go API dalam pengalaman saya dengan Fuego. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!