Bagaimana untuk melaksanakan penghalaan golang

Golang ialah bahasa pengaturcaraan yang sangat popular yang cekap, ringkas dan berskala. Dari segi pengaturcaraan rangkaian, Golang juga berprestasi sangat baik Perpustakaan standardnya menyediakan banyak API yang berkaitan dengan operasi rangkaian, dan sangat mudah untuk menulis perkhidmatan berprestasi tinggi menggunakan Golang.

Penghalaan ialah asas pengaturcaraan rangkaian dan komponen penting dalam rangka kerja Web. Artikel ini akan meneroka cara menggunakan Golang untuk melaksanakan fungsi penghalaan asas.

Demi kesederhanaan, kami memilih rangka kerja Gin untuk demonstrasi Gin ialah rangka kerja Web yang cekap dan ringan yang pantas, mudah digunakan dan berkuasa. Anda boleh menggunakan arahan untuk memasang pustaka Gin:

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

Setelah mengetahui asas rangka kerja, kami boleh mula melaksanakan penghalaan. Dalam Gin, penghalaan dibahagikan kepada dua jenis: penghalaan asas HTTP dan penghalaan paket.

Penghalaan asas HTTP boleh melaksanakan fungsi berikut:

• Mengendalikan penghalaan kaedah HTTP seperti GET, POST, PUT, PATCH, DELETE dll.
• Parameter yang digunakan dalam penghalaan
• Parameter pertanyaan yang digunakan dalam penghalaan
• Parameter fragmen yang digunakan dalam penghalaan

Sekarang, mari kita tunjukkan cara mencipta laluan asas:

package main

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

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

Dalam contoh di atas, kami mencipta laluan yang boleh mengakses laluan /ping melalui kaedah HTTP GET. Apabila permintaan diterima, ia mengembalikan respons berformat JSON dengan kod status HTTP 200.

Seterusnya mari kita lihat cara melaksanakan penghalaan dengan parameter:

package main

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

func main() {
    r := gin.Default()

    // 路由中使用参数
    r.GET("/user/:name", func(c *gin.Context) {
        name := c.Param("name")
        c.String(200, fmt.Sprintf("Hello, %s", name))
    })

    r.Run() // listen and serve on 0.0.0.0:8080
}

Dalam contoh di atas, kami menggunakan :name dalam laluan sebagai parameter apabila kami menggunakan HTTP Kaedah GET Apabila mengakses /pengguna/xxx, penghala akan menggesa kami "Hello, xxx".

Parameter pertanyaan ialah format rentetan pertanyaan standard yang digunakan dalam permintaan HTTP. Contoh berikut menunjukkan cara menggunakan parameter Pertanyaan dalam laluan:

package main

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

func main() {
    r := gin.Default()

    // 路由中使用Query参数
    r.GET("/welcome", func(c *gin.Context) {
        firstname := c.Query("firstname")
        lastname := c.Query("lastname")
        c.String(200, fmt.Sprintf("Welcome, %s %s", firstname, lastname))
    })

    r.Run() // listen and serve on 0.0.0.0:8080
}

Dalam contoh di atas, kami menggunakan kaedah HTTP GET untuk mengakses laluan /selamat datang dan lulus parameter Pertanyaan nama pertama dan nama keluarga. Laluan mengembalikan rentetan yang mengandungi nilai parameter ini. Contohnya: Apabila kami menggunakan URL berikut untuk mengakses laluan, kami akan mendapat nilai pulangan "Selamat Datang, John Doe":

http://localhost:8080/welcome?firstname=John&lastname=Doe

Dalam beberapa kes, parameter Fragmen mungkin diperlukan dalam laluan untuk melaksanakan operasi tertentu. Contoh berikut menunjukkan cara menggunakan parameter Fragmen dalam penghalaan:

package main

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

func main() {
    r := gin.Default()

    // 路由中使用Fragment参数
    r.GET("/blog/:id/:title/*fragment", func(c *gin.Context) {
        id := c.Param("id")
        title := c.Param("title")
        fragment := c.Param("fragment")
        c.String(200, fmt.Sprintf("This is Blog %s: %s %s", id, title, fragment))
    })

    r.Run() // listen and serve on 0.0.0.0:8080
}

Dalam contoh di atas, kami mencipta laluan Apabila kami melawati /blog/1234/best-blog-ever#comments, Laluan itu boleh berjaya mengembalikan rentetan yang mengandungi nilai id, tajuk dan serpihan.

Selain penghalaan asas, Gin juga menyokong penghalaan kumpulan.

Dalam penghalaan kumpulan, kami mengumpulkan laluan mengikut fungsi atau kebenaran. Sub-laluan yang berbeza boleh menghala ke fungsi yang berbeza, dan mereka juga boleh berkongsi middleware, memanggil fungsi yang sama dan berkongsi parameter penghalaan.

Berikut ialah contoh mudah penghalaan kumpulan:

package main

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

func main() {
    r := gin.Default()

    // 创建一个分组路由
    guest := r.Group("/guest")
    {
        guest.GET("/login", func(c *gin.Context) {
            c.String(200, "Welcome to Login Page!")
        })
        guest.GET("/register", func(c *gin.Context) {
            c.String(200, "Welcome to Register Page!")
        })
    }

    admin := r.Group("/admin")
    {
        admin.GET("/dashboard", func(c *gin.Context) {
            c.String(200, "Welcome to Dashboard!")
        })
        admin.GET("/users", func(c *gin.Context) {
            c.String(200, "Welcome to Users page!")
        })
    }

    r.Run() // listen and serve on 0.0.0.0:8080
}

Dalam contoh di atas, kami menggunakan penghalaan kumpulan untuk membahagikan laluan kepada dua kumpulan: tetamu dan pentadbir. Setiap set laluan mempunyai fungsi penghalaan sendiri. Dengan cara ini kami boleh menyampaikan halaman yang berbeza kepada setiap jenis pengguna.

Melaksanakan penghalaan di Golang adalah sangat mudah, dan menggunakan rangka kerja Gin adalah lebih mudah. Dengan menggunakan fungsi dan API yang disebutkan di atas, kami boleh mencipta aplikasi web dengan berbilang laluan. Saya doakan anda berjaya!

Atas ialah kandungan terperinci Bagaimana untuk melaksanakan penghalaan golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!