Cara melaksanakan pengumpulan laluan dalam bahasa Go

Bahasa Go ialah bahasa pengaturcaraan yang mudah dan cekap yang juga digunakan secara meluas dalam bidang pembangunan web. Dalam pembangunan web, penghalaan adalah bahagian penting. Pengumpulan penghalaan ialah fungsi penghalaan yang lebih maju, yang boleh menjadikan kod lebih jelas dan ringkas, serta meningkatkan kebolehbacaan dan kebolehselenggaraan kod.

Artikel ini akan memperkenalkan secara terperinci cara melaksanakan pengelompokan penghalaan dalam bahasa Go dari kedua-dua aspek pelaksanaan prinsip dan kod.

1. Prinsip pengelompokan

Pengumpulan laluan adalah setara dengan pengelompokan beberapa laluan yang mempunyai ciri yang serupa untuk pengurusan. Sebagai contoh, kita boleh mengumpulkan semua laluan API ke dalam kumpulan API dan semua laluan pengurusan latar belakang ke dalam kumpulan Pentadbir.

Apabila melaksanakan kumpulan penghalaan, kita perlu terlebih dahulu mentakrifkan struktur kumpulan penghalaan, seperti yang ditunjukkan di bawah:

taip struktur RouteGroup {

pathPrefix string
router     *mux.Router

}

di mana pathPrefix mewakili awalan kumpulan penghalaan, dan penghala.

Seterusnya, kita boleh menentukan beberapa kaedah dalam struktur RouteGroup, seperti Get(), Post(), Put(), Delete(), dsb. Fungsi kaedah ini adalah untuk menambah fungsi pemprosesan pada laluan yang ditentukan, seperti ditunjukkan di bawah:

func (rg *RouteGroup) Get(rentetan laluan, pengendali http.HandlerFunc) {

rg.router.HandleFunc(rg.pathPrefix+path, handler).Methods("GET")

}

func (rg *RouteGroup) Post(rentetan laluan, pengendali http.HandlerFunc) {

rg.router.HandlerFunc(rg.pathPrefix+path, handler).Methods("POST")

}

.. .

Dalam kumpulan laluan, gunakan Get(), Post(), Put(), Delete() dan kaedah lain untuk menambah fungsi pemprosesan pada laluan yang ditentukan, seperti ditunjukkan di bawah:

apiHandler := func( w http .ResponseWriter, r *http.Request) {

fmt.Fprintln(w, "This is API handler!")

}

AdminHandler := func(w http.ResponseWriter, r *http.Request) {

fmt.Fprintln(w, "This is Admin handler!")

}

// Cipta penghala

r := mux. NewRouter( )

// Cipta kumpulan penghalaan API

apiGroup := &RouteGroup{pathPrefix: "/api", penghala: r}

apiGroup.Get("/articles", apiHandler)
apiGroup.Post("/articles", apiHandler)

// Buat kumpulan penghalaan pengurusan latar belakang

adminGroup := &RouteGroup{pathPrefix: "/admin", penghala: r}

adminGroup.Get("/articles", AdminHandler)
adminGroup.Post"("/article , AdminHandler)

Melalui kod di atas, kami berjaya mencipta dua kumpulan penghalaan, iaitu kumpulan penghalaan API dan kumpulan penghalaan pengurusan latar belakang.

2. Pelaksanaan Kod

Seterusnya, kami akan menggunakan contoh kod lengkap untuk menunjukkan cara melaksanakan pengumpulan laluan dalam bahasa Go.

Pertama, kita perlu memasang router mux, yang boleh dipasang melalui arahan berikut:

go get -u github.com/gorilla/mux

Kod berikut menunjukkan cara membuat penghala dan kumpulan penghalaan melalui mux:

package main

import (

"net/http"

"github.com/gorilla/mux"

)

func main() {

r := mux.NewRouter()

// 创建API路由分组
apiGroup := &RouteGroup{pathPrefix: "/api", router: r.PathPrefix("/api").Subrouter()}
apiGroup.Get("/articles", apiHandler)
apiGroup.Post("/articles", apiHandler)

// 创建后台管理路由分组
adminGroup := &RouteGroup{pathPrefix: "/admin", router: r.PathPrefix("/admin").Subrouter()}
adminGroup.Get("/articles", AdminHandler)
adminGroup.Post("/articles", AdminHandler)

http.ListenAndServe(":8080", r)

}

Dalam kod di atas, kami mencipta dua kumpulan penghalaan (apiGroup dan adminGroup) melalui kaedah PathPrefix() () Kaedah menambahkannya ke penghala r.

Seterusnya, kita perlu melaksanakan kaedah Get(), Post() dan Put() dalam jenis RouteGroup untuk menambah fungsi pemprosesan bagi laluan yang ditentukan. Kod lengkapnya adalah seperti berikut:

pakej utama

import (

"fmt"
"net/http"

"github.com/gorilla/mux"

)

taip struct RouteGroup {

pathPrefix string
router     *mux.Router

}

func (rg *RouteGroup) Get(path.Hrreee)

}

func (rg *RouteGroup) Post(rentetan laluan, pengendali http.HandlerFunc) {

rg.router.HandleFunc(fmt.Sprintf("%s/%s", rg.pathPrefix, path), handler).Methods(http.MethodGet)

}

func (rg *RouteGroup) Put(rentetan laluan, pengendali http.HandlerFuncreee)

func apiHandler(w http.ResponseWriter, r *http.Request) {

rg.router.HandleFunc(fmt.Sprintf("%s/%s", rg.pathPrefix, path), handler).Methods(http.MethodPost)

}

func AdminHandler(w http.ResponseWriter, r *http.Request) {

rg.router.HandleFunc(fmt.Sprintf("%s/%s", rg.pathPrefix, path), handler).Methods(http.MethodPut)

}

func main() {

}

Melalui pelaksanaan kod di atas, kami berjaya mencipta kumpulan laluan dan menentukan fungsi pemprosesan untuk setiap laluan.

Ringkasan:

Artikel ini memperkenalkan cara melaksanakan pengelompokan laluan dalam bahasa Go Kami mula-mula bercakap tentang prinsip pengelompokan laluan, iaitu, melalui struktur dan kaedah tersuai, fungsi pemprosesan yang sama diberikan kepada kumpulan laluan, dan. melalui penghala Realisasikan pengurusan semua kumpulan penghalaan. Seterusnya, kami menunjukkan secara terperinci cara menggunakan mux untuk melaksanakan kumpulan laluan dan memberikan contoh kod lengkap. Saya harap artikel ini dapat membantu pembaca memahami dengan lebih baik pelaksanaan kumpulan penghalaan dalam bahasa Go.

Atas ialah kandungan terperinci Cara melaksanakan pengumpulan laluan dalam bahasa Go. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!