Routing w Iris dla języka Go

Framework Iris ma dwa tryby powiązania tras, jeden to funkcjonalny, a drugi to MVC. Tryb funkcjonalny wiąże funkcję obsługi ze wskazaną ścieżką URL, podczas gdy tryb MVC wiąże kontroler ze ścieżką URL. Framework automatycznie generuje odpowiadające im ścieżki URL na podstawie reguł nazewnictwa metod kontrolera i automatycznie wiąże odpowiadające funkcje kontrolera.

Funkcjonalne Powiązanie Tras

Najprostszy model trasowania w frameworku Iris, gdzie można powiązać funkcję z dowolnym adresem URL.

func main() {
    // Utwórz aplikację Iris z domyślnym oprogramowaniem pośredniczącym:
    // Domyślnie używa poziomu dziennika "debug".
    // Obsługuje lokalizację znajdującą się w katalogu "./locales".
    // Szablony HTML znajdują się w katalogach "./views" lub "./templates".
    // Dzienniki dostępu są zapisywane w "./access.log",
    // a wykrywanie awarii (bez awarii) i identyfikator żądania są już dołączone.
    app := iris.Default()

    // Proste powiązanie funkcji trasowania na podstawie metody żądania HTTP i ścieżki, podobnie jak mechanizm trasowania w Gin, echo i innych frameworkach.
    app.Get("/someGet", getting)
    app.Post("/somePost", posting)
    app.Put("/somePut", putting)
    app.Delete("/someDelete", deleting)
    app.Patch("/somePatch", patching)
    app.Head("/someHead", head)
    app.Options("/someOptions", options)
    
    // Słuchaj na porcie
    app.Listen(":8080")
}

Parametry w ścieżce

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

    // Ten obsługiwacz będzie pasował do /user/john, ale nie do /user/ lub /user
    app.Get("/user/{name}", func(ctx iris.Context) {
        name := ctx.Params().Get("name")
        ctx.Writef("Witaj %s", name)
    })
    
    // Jednak ten obsługiwacz będzie pasował do /user/john/ i /user/john/send
    // Jeśli żaden inny routing nie pasuje do /user/john, zostanie przekierowany do /user/john/
    app.Get("/user/{name}/{action:path}", func(ctx iris.Context) {
        name := ctx.Params().Get("name")
        action := ctx.Params().Get("action")
        message := name + " jest " + action
        ctx.WriteString(message)
    })
    
    // Dla każdego pasującego żądania Context zachowa definicję trasy
    app.Post("/user/{name:string}/{action:path}", func(ctx iris.Context) {
        ctx.GetCurrentRoute().Tmpl().Src == "/user/{name:string}/{action:path}" // true
    })
    
    app.Listen(":8080")
}

Dostępne wbudowane typy parametrów:

Grupowanie tras

Czasami jest potrzebne zarządzanie wersjami interfejsu API, lub ustawienie wspólnego prefiksu dla tras dużej aplikacji. Tutaj przyda się umiejętność grupowania tras.

funkcja główna() {
    aplikacja := iris.Default()

    // Proste grupowanie: v1
    v1 := aplikacja.Party("/v1")
    {
        v1.Post("/login", loginEndpoint)
        v1.Post("/submit", submitEndpoint)
        v1.Post("/read", readEndpoint)
    }
    
    // Proste grupowanie: v2
    v2 := aplikacja.Party("/v2")
    {
        v2.Post("/login", loginEndpoint)
        v2.Post("/submit", submitEndpoint)
        v2.Post("/read", readEndpoint)
    }
    
    aplikacja.Listen(":8080")
}

Trasy MVC

Framework Go Iris obsługuje architekturę MVC, mapując trasy do określonych funkcji kontrolera poprzez określone reguły.

pakiet główny

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

// Utwórz aplikację iris
funkcja newApp() *iris.Application {
	aplikacja := iris.New()
	// Ustaw dwa middleware
	// recover jest używany do przechwytywania błędów panic, aby uniknąć nieprawidłowego zakończenia programu
	// logger jest używany do rejestrowania żądań
	aplikacja.Use(recover.New())
	aplikacja.Use(logger.New())

	// Zarejestruj kontroler dla trasy "/" tutaj.
	mvc.New(aplikacja).Handle(new(ExampleController))
	
	// Może być również zarejestrowany dla określonej ścieżki przy użyciu grupowania tras
	// Przykład: Zarejestruj kontroler dla ścieżki /books
	// mvc.New(aplikacja.Party("/books")).Handle(new(ExampleController))
}

funkcja główna() {
	// Utwórz aplikację
	aplikacja := newApp()

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

// Zdefiniuj ExampleController do obsługi żądań dla "/", "/ping" i "/hello".
typ ExampleController struct{}

// Obsłuż żądanie GET
// URL żądania: http://localhost:8080
func (c *ExampleController) Get() mvc.Result {
	return mvc.Response{
		ContentType: "text/html",
		Text:        "<h1>Witaj</h1>",
	}
}

// GetPing obsługuje
// Metoda:   GET
// URL żądania: http://localhost:8080/ping
func (c *ExampleController) GetPing() string {
	return "pong"
}

// GetHello obsługuje
// Metoda:   GET
// URL żądania: http://localhost:8080/hello
func (c *ExampleController) GetHello() interface{} {
	return map[string]string{"message": "Witaj Iris!"}
}

// GetHelloWorld obsługuje
// Metoda:   GET
// URL żądania: http://localhost:8080/hello/world
func (c *ExampleController) GetHelloWorld() interface{} {
	return map[string]string{"message": "Witaj Iris! DefaultPath"}
}

Związek między trasowaniem MVC a regułą nazewnictwa funkcji kontrolera.

Adres trasy: Grupowanie trasy + Nazwa metody HTTP + Nazwa funkcji (małymi literami)

Na przykład:

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

Ponieważ nie ma ustawionego grupowania tras, ta funkcja może obsługiwać żądania GET dla trasy http://localhost:8080/ping.