Định tuyến Iris trong Go

Khung (framework) iris có hai chế độ để buộc đường dẫn (route binding), một là chức năng (functional) và một là MVC. Chế độ chức năng liên kết một chức năng xử lý với một đường dẫn URL cụ thể, trong khi chế độ MVC liên kết một điều khiển (controller) với một đường dẫn URL. Khung (framework) tự động tạo ra các đường dẫn URL tương ứng dựa trên quy tắc đặt tên các phương thức điều khiển, và tự động buộc các chức năng điều khiển tương ứng.

Buộc Đường Dẫn Chức Năng

Mô hình định tuyến đơn giản nhất trong khung (framework) iris, nơi bạn có thể buộc một chức năng với bất kỳ URL nào.

func main() {
    // Tạo một ứng dụng iris với middleware mặc định:
    // Theo mặc định, nó sử dụng cấp độ ghi log "debug".
    // Nó hỗ trợ bản địa hóa nằm dưới thư mục "./locales".
    // Các mẫu HTML nằm dưới thư mục "./views" hoặc "./templates".
    // Nhật ký truy cập được lưu trong "./access.log",
    // và middleware khôi phục (không gây sự cố) và ID yêu cầu đã được gắn kết.
    app := iris.Default()

	// Đơn giản buộc các chức năng đường dẫn dựa trên phương thức yêu cầu HTTP và đường dẫn, tương tự cơ chế định tuyến trong Gin, echo và các framework khác.
    app.Get("/someGet", lấy)
    app.Post("/somePost", đăng)
    app.Put("/somePut", đặt)
    app.Delete("/someDelete", xóa)
    app.Patch("/somePatch", sửa)
    app.Header("/someHead", đầu)
    app.Options("/someOptions", tùy_chọn)
    
	// Nghe trên cổng
    app.Listen(":8080")
}

Tham số trong Đường dẫn

func main() {
    app := iris.Default()

    // Đoạn xử lý này sẽ phù hợp với /user/john nhưng không phù hợp với /user/ hoặc /user
    app.Get("/user/{name}", func(ctx iris.Context) {
        name := ctx.Params().Get("name")
        ctx.Writef("Xin chào %s", name)
    })
    
    // Tuy nhiên, đoạn xử lý này sẽ phù hợp với /user/john/ và /user/john/send
    // Nếu không có route nào phù hợp với /user/john, nó sẽ chuyển hướng đến /user/john/
    app.Get("/user/{name}/{action:path}", func(ctx iris.Context) {
        name := ctx.Params().Get("name")
        action := ctx.Params().Get("action")
        message := name + " là " + action
        ctx.WriteString(message)
    })
    
    // Đối với mỗi yêu cầu phù hợp, Context sẽ giữ định nghĩa route
    app.Post("/user/{name:string}/{action:path}", func(ctx iris.Context) {
        ctx.GetCurrentRoute().Tmpl().Src == "/user/{name:string}/{action:path}" // true
    })
    
    app.Listen(":8080")
}

Các loại tham số tích hợp có sẵn:

Nhóm định tuyến

Đôi khi, quản lý phiên bản API là cần thiết, hoặc một tiền tố thống nhất được đặt cho việc định tuyến của một module lớn. Đây là nơi mà khả năng định tuyến nhóm được áp dụng.

func main() {
    app := iris.Default()

    // Nhóm đơn giản: v1
    v1 := app.Party("/v1")
    {
        v1.Post("/login", loginEndpoint)
        v1.Post("/submit", submitEndpoint)
        v1.Post("/read", readEndpoint)
    }
    
    // Nhóm đơn giản: v2
    v2 := app.Party("/v2")
    {
        v2.Post("/login", loginEndpoint)
        v2.Post("/submit", submitEndpoint)
        v2.Post("/read", readEndpoint)
    }
    
    app.Listen(":8080")
}

Định tuyến MVC

Framework Go Iris hỗ trợ kiến trúc MVC, ánh xạ các đường dẫn đến các hàm điều khiển cụ thể thông qua một số quy tắc cụ thể.

package main

import (
	"strings"
	"github.com/kataras/iris/v12"
	"github.com/kataras/iris/v12/middleware/logger"
	"github.com/kataras/iris/v12/middleware/recover"
	"github.com/kataras/iris/v12/mvc"
)

// Tạo một ứng dụng iris mới
func newApp() *iris.Application {
	app := iris.New()
	// Thiết lập hai middleware
	// recover được sử dụng để chặn lỗi panic để tránh việc kết thúc chương trình bất thường
	// logger được sử dụng để ghi nhật ký yêu cầu
	app.Use(recover.New())
	app.Use(logger.New())

	// Đăng ký điều khiển vào đường dẫn gốc "/"
	mvc.New(app).Handle(new(ExampleController))
	
	// Nó cũng có thể được đăng ký vào một đường dẫn cụ thể với sự trợ giúp của nhóm định tuyến
	// Ví dụ: Đăng ký điều khiển dưới đường dẫn "/books"
	// mvc.New(app.Party("/books")).Handle(new(ExampleController))
}

func main() {
	// Tạo ứng dụng
	app := newApp()

	// http://localhost:8080
	// http://localhost:8080/ping
	// http://localhost:8080/hello
	// http://localhost:8080/custom_path
	app.Listen(":8080")
}

// Xác định ExampleController để xử lý yêu cầu cho "/", "/ping", và "/hello".
type ExampleController struct{}

// Xử lý yêu cầu GET
// URL yêu cầu: http://localhost:8080
func (c *ExampleController) Get() mvc.Result {
	return mvc.Response{
		ContentType: "text/html",
		Text:        "<h1>Welcome</h1>",
	}
}

// GetPing phục vụ
// Phương thức:   GET
// URL yêu cầu: http://localhost:8080/ping
func (c *ExampleController) GetPing() string {
	return "pong"
}

// GetHello phục vụ
// Phương thức:   GET
// URL yêu cầu: http://localhost:8080/hello
func (c *ExampleController) GetHello() interface{} {
	return map[string]string{"message": "Xin chào Iris!"}
}

// GetHelloWorld phục vụ
// Phương thức:   GET
// URL yêu cầu: http://localhost:8080/hello/world
func (c *ExampleController) GetHelloWorld() interface{} {
	return map[string]string{"message": "Xin chào Iris! DefaultPath"}
}

Mối quan hệ giữa định tuyến MVC và quy tắc đặt tên của các hàm điều khiển.

Địa chỉ Đường dẫn: Nhóm Định tuyến + Tên phương thức HTTP + Tên hàm (viết thường)

Ví dụ:

func (c *ExampleController) GetPing() string {
	return "pong"
}

Do không có nhóm định tuyến nào được thiết lập, hàm này có thể xử lý yêu cầu GET cho đường dẫn http://localhost:8080/ping.