Cara menggunakan golang untuk membina aplikasi web yang mudah dan cekap

Sebagai pembangun golang, kami bukan sahaja perlu menguasai sintaks asas bahasa golang, tetapi juga perlu memahami pembinaan rangka kerja golang, kerana ini sangat penting untuk kami membangunkan aplikasi yang berkualiti tinggi. Dalam artikel ini, saya akan berkongsi cara menggunakan golang untuk membina aplikasi web yang mudah dan cekap.

Pertama, kita perlu memilih rangka kerja web golang. Terdapat banyak rangka kerja web yang sangat baik untuk dipilih dalam pasaran golang. Seperti gin, beego, echo, dll. Apabila memilih rangka kerja, anda perlu membuat keputusan berdasarkan keperluan khusus projek anda. Dalam artikel ini, saya memilih rangka kerja gin untuk pembinaan.

Langkah 1: Pasang rangka kerja GIN

Sebelum menggunakan golang, anda perlu memasang rangka kerja yang sepadan. Gunakan alat pengurusan pakej rasmi golang golang untuk memasang rangka kerja gin:

go get -u github.com/gin-gonic/gin

Langkah 2: Buat pelayan web mudah

Selepas memasang rangka kerja gin, kita perlu mencipta web asas pelayan. Cipta fail main.go dan tambahkan kod berikut dalam fail:

package main

import (
    "github.com/gin-gonic/gin"
)

func main() {
    r := gin.Default()
    r.GET("/", func(c *gin.Context) {
        c.JSON(200, gin.H{
            "message": "hello gin",
        })
    })
    r.Run() // listen and serve on 0.0.0.0:8080
}

Kod ini melaksanakan perkhidmatan web yang sangat mudah. Antaranya, kami menggunakan fungsi Default() gin untuk mencipta contoh gin lalai. Fungsi r.GET() digunakan untuk mendaftarkan laluan permintaan GET, iaitu, apabila seseorang menghantar permintaan GET ke laluan akar, kami akan mengembalikan mesej "hello gin". Akhir sekali, kami menggunakan fungsi r.Run() untuk memulakan perkhidmatan.

Langkah 3: Tentukan struktur

Dalam pembangunan sebenar, kita perlu mengelaskan parameter permintaan dan data tindak balas. Oleh itu, kita perlu mentakrifkan struktur untuk mewakili kandungan permintaan dan respons. Tambahkan kod berikut pada fail main.go:

type Request struct {
    Name string `json:"name" binding:"required"`
}

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

func main() {
    r := gin.Default()
    r.POST("/", func(c *gin.Context) {
        var req Request
        if err := c.ShouldBindJSON(&req); err != nil {
            c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
            return
        }
        res := Response{Message: "hello " + req.Name}
        c.JSON(http.StatusOK, res)
    })
    r.Run() // listen and serve on 0.0.0.0:8080
}

Antaranya, kami mentakrifkan dua struktur Permintaan dan Respons. Struktur Permintaan mengandungi medan Nama, yang digunakan untuk mewakili nama pengguna dalam permintaan. Struktur Respons mengandungi medan Mesej untuk mewakili mesej respons. Dalam fungsi r.POST(), kami mula-mula menggunakan fungsi c.ShouldBindJSON() untuk mengikat data permintaan kepada struktur Permintaan. Jika berlaku kesilapan, kami akan mengembalikan ralat 400 Permintaan Buruk. Jika pengikatan berjaya, kami mengembalikan mesej respons dengan medan nama.

Langkah 4: Gunakan middleware

Dalam pembangunan sebenar, kita perlu menggunakan beberapa middleware untuk memproses permintaan. Sebagai contoh, kita perlu mengendalikan pengepala permintaan, kita perlu mengesahkan setiap permintaan, dsb. Rangka kerja gin mempunyai banyak middleware terbina dalam dan boleh menggunakan middleware pihak ketiga. Dalam contoh ini, kami menggunakan perisian tengah Logger() terbina dalam gin. Cipta fail main.go dan tambah kod berikut dalam fail:

func main() {
    r := gin.New()
    r.Use(gin.Logger())
    r.POST("/", func(c *gin.Context) {
        var req Request
        if err := c.ShouldBindJSON(&req); err != nil {
            c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
            return
        }
        res := Response{Message: "hello " + req.Name}
        c.JSON(http.StatusOK, res)
    })
    r.Run() // listen and serve on 0.0.0.0:8080
}

Dalam contoh ini, kami mencipta contoh gin baharu dan menggunakan perisian tengah Logger() gin. Perisian tengah ini akan merekodkan log terperinci setiap permintaan. Ini sangat berguna untuk penyahpepijatan dalam pembangunan kami.

Langkah 5: Pelayan fail statik

Jika kami perlu menyediakan akses kepada fail statik, seperti gambar, helaian gaya, skrip, dll., kami boleh menggunakan perisian tengah pemprosesan fail statik yang disediakan oleh rangka kerja gin. Tambahkan kod berikut pada fail main.go:

func main() {
    r := gin.New()
    r.Use(gin.Logger())
    r.LoadHTMLGlob("templates/*")
    r.Static("/static", "./public")
    r.GET("/", func(c *gin.Context) {
        c.HTML(http.StatusOK, "index.tmpl", gin.H{})
    })
    r.Run() // listen and serve on 0.0.0.0:8080
}

Dalam kod di atas, kami menggunakan fungsi r.LoadHTMLGlob() untuk memuatkan templat HTML ke dalam atur cara. Kami menggunakan fungsi r.Static() untuk memetakan semua fail statik (seperti imej, helaian gaya dan skrip) dalam direktori awam ke laluan /statik. Dalam fungsi r.GET(), kami menggunakan fungsi c.HTML() untuk mengembalikan templat HTML kepada pengguna.

Kesimpulan

Melalui pengenalan artikel ini, kita boleh belajar cara menggunakan rangka kerja gin untuk membina aplikasi web yang ringkas dan cekap. Kita dapat lihat bahawa membangunkan aplikasi web menggunakan golang adalah sangat mudah dan cekap. Sudah tentu, kita juga boleh menggunakan lebih banyak middleware gin untuk membangunkan mengikut keperluan projek. Semoga artikel ini dapat membantu pembaca yang sedang mempelajari pembangunan golang.

Atas ialah kandungan terperinci Cara menggunakan golang untuk membina aplikasi web yang mudah dan cekap. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!