Pemetaan Rute Go Iris

Kerangka kerja iris memiliki dua mode untuk pengikatan rute, yaitu fungsional dan MVC. Mode fungsional mengikat fungsi penanganan ke jalur URL yang ditentukan, sementara mode MVC mengikat pengontrol ke jalur URL. Kerangka kerja secara otomatis menghasilkan jalur URL yang sesuai berdasarkan aturan penamaan metode pengontrol, dan secara otomatis mengikat fungsi pengontrol yang sesuai.

Pengikatan Rute Fungsional

Model routing paling sederhana dalam kerangka kerja iris, di mana Anda dapat mengikat fungsi ke URL apa pun.

func main() {
    // Buat aplikasi iris dengan middleware default:
    // Secara default, itu menggunakan tingkat log "debug".
    // Mendukung lokalitas yang terletak di bawah direktori "./locales".
    // Templat HTML terletak di bawah direktori "./views" atau "./templates".
    // Log akses disimpan di "./access.log",
    // dan pemulihan (tanpa crash) serta middleware ID permintaan sudah dilampirkan.
    app := iris.Default()

	// Hanya mengikat fungsi rute berdasarkan metode permintaan HTTP dan jalur, mirip dengan mekanisme routing di Gin, echo, dan kerangka kerja lainnya.
    app.Get("/someGet", getting)
    app.Post("/somePost", posting)
    app.Put("/somePut", putting)
    app.Delete("/someDelete", deleting)
    app.Patch("/somePatch", patching)
    app.Header("/someHead", head)
    app.Options("/someOptions", options)
    
	// Mendengarkan port
    app.Listen(":8080")
}

Parameter di Path

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

    // Handler ini akan cocok dengan /user/john tetapi tidak dengan /user/ atau /user
    app.Get("/user/{name}", func(ctx iris.Context) {
        name := ctx.Params().Get("name")
        ctx.Writef("Halo %s", name)
    })
    
    // Namun, handler ini akan cocok dengan /user/john/ dan /user/john/send
    // Jika tidak ada rute lain yang cocok dengan /user/john, maka akan diarahkan ke /user/john/
    app.Get("/user/{name}/{action:path}", func(ctx iris.Context) {
        name := ctx.Params().Get("name")
        action := ctx.Params().Get("action")
        message := name + " " + action
        ctx.WriteString(message)
    })
    
    // Untuk setiap permintaan yang cocok, Konteks akan menyimpan definisi rute
    app.Post("/user/{name:string}/{action:path}", func(ctx iris.Context) {
        ctx.GetCurrentRoute().Tmpl().Src == "/user/{name:string}/{action:path}" // true
    })
    
    app.Listen(":8080")
}

Tersedia jenis parameter bawaan:

Routing Grup

Terkadang, manajemen versi API diperlukan, atau awalan yang seragam diatur untuk routing modul besar. Di sinilah kemampuan routing grup muncul.

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

    // Grup sederhana: v1
    v1 := app.Party("/v1")
    {
        v1.Post("/login", loginEndpoint)
        v1.Post("/submit", submitEndpoint)
        v1.Post("/read", readEndpoint)
    }
    
    // Grup sederhana: v2
    v2 := app.Party("/v2")
    {
        v2.Post("/login", loginEndpoint)
        v2.Post("/submit", submitEndpoint)
        v2.Post("/read", readEndpoint)
    }
    
    app.Listen(":8080")
}

Routing MVC

Framework Go Iris mendukung arsitektur MVC, memetakan rute ke fungsi pengontrol tertentu melalui aturan tertentu.

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"
)

// Buat aplikasi iris
func newApp() *iris.Application {
	app := iris.New()
	// Atur dua middleware
	// recover digunakan untuk mengintersep kesalahan panic untuk menghindari terminasi program yang abnormal
	// logger digunakan untuk mencatat permintaan
	app.Use(recover.New())
	app.Use(logger.New())

	// Daftarkan pengontrol ke rute "/root" di sini.
	mvc.New(app).Handle(new(ExampleController))
	
	// Ini juga dapat didaftarkan ke jalur tertentu dengan bantuan pengelompokan rute
	// Contoh: Daftarkan pengontrol di bawah jalur /books
	// mvc.New(app.Party("/books")).Handle(new(ExampleController))
}

func main() {
	// Buat aplikasinya
	app := newApp()

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

// Tentukan ExampleController untuk menangani permintaan untuk "/", "/ping" dan "/hello".
type ExampleController struct{}

// Handle permintaan GET
// URL Permintaan: http://localhost:8080
func (c *ExampleController) Get() mvc.Result {
	return mvc.Response{
		ContentType: "text/html",
		Text:        "<h1>Welcome</h1>",
	}
}

// GetPing melayani
// Metode:   GET
// URL Permintaan: http://localhost:8080/ping
func (c *ExampleController) GetPing() string {
	return "pong"
}

// GetHello melayani
// Metode:   GET
// URL Permintaan: http://localhost:8080/hello
func (c *ExampleController) GetHello() interface{} {
	return map[string]string{"message": "Hello Iris!"}
}

// GetHelloWorld melayani
// Metode:   GET
// URL Permintaan: http://localhost:8080/hello/world
func (c *ExampleController) GetHelloWorld() interface{} {
	return map[string]string{"message": "Hello Iris! DefaultPath"}
}

Hubungan antara routing MVC dan aturan penamaan fungsi pengontrol.

Alamat Rute: Grup Rute + nama metode HTTP + nama fungsi (huruf kecil)

Sebagai contoh:

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

Karena tidak ada pengelompokan rute yang diatur, fungsi ini dapat menangani permintaan GET untuk rute http://localhost:8080/ping.