Go Iris Routing

Das Iris-Framework hat zwei Modi für die Routenbindung: einen funktionalen und einen MVC-Modus. Der funktionale Modus bindet eine Verarbeitungsfunktion an einen bestimmten URL-Pfad, während der MVC-Modus einen Controller an einen URL-Pfad bindet. Das Framework generiert automatisch entsprechende URL-Pfade basierend auf den Namensregeln der Controller-Methoden und bindet automatisch die entsprechenden Controller-Funktionen.

Funktionale Routenbindung

Das einfachste Routenmodell im Iris-Framework, mit dem Sie eine Funktion an eine beliebige URL binden können.

func main() {
    // Erstellen Sie eine Iris-Anwendung mit Standard-Middleware:
    // Standardmäßig verwendet sie das "debug" Log-Level.
    // Sie unterstützt Lokalisierung im Verzeichnis "./locales".
    // HTML-Templates sind im Verzeichnis "./views" oder "./templates" zu finden.
    // Zugriffsprotokolle werden in "./access.log" gespeichert
    // und das Recovery (ohne Absturz) und die Request ID-Middleware sind bereits angehängt.
    app := iris.Default()

    // Binden Sie einfach Routinenfunktionen basierend auf der HTTP-Request-Methode und dem Pfad, ähnlich dem Routing-Mechanismus in Gin, Echo und anderen Frameworks.
    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)

    // Portüberwachung
    app.Listen(":8080")
}

package main

import "github.com/kataras/iris/v12"

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

    // Dieser Handler entspricht /user/john, aber nicht /user/ oder /user
    app.Get("/user/{name}", func(ctx iris.Context) {
        name := ctx.Params().Get("name")
        ctx.Writef("Hallo %s", name)
    })

    // Jedoch entspricht dieser Handler /user/john/ und /user/john/send
    // Wenn keine andere Route /user/john entspricht, leitet sie auf /user/john/ um
    app.Get("/user/{name}/{action:path}", func(ctx iris.Context) {
        name := ctx.Params().Get("name")
        action := ctx.Params().Get("action")
        message := name + " ist " + action
        ctx.WriteString(message)
    })

    // Für jede übereinstimmende Anfrage behält der Kontext die Routendefinition bei
    app.Post("/user/{name:string}/{action:path}", func(ctx iris.Context) {
        ctx.GetCurrentRoute().Tmpl().Src == "/user/{name:string}/{action:path}" // true
    })

    app.Listen(":8080")
}

Gruppen-Routing

Manchmal ist eine API-Versionierung erforderlich oder es wird ein einheitliches Präfix für die Routing-Struktur eines großen Moduls festgelegt. Hier kommt die Fähigkeit des Gruppen-Routings zum Einsatz.

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

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

MVC-Routing

Das Go Iris-Framework unterstützt die MVC-Architektur, indem es Routen auf bestimmte Controller-Funktionen gemäß bestimmter Regeln abbildet.

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

// Erstellt eine Iris-Anwendung
func newApp() *iris.Application {
	app := iris.New()
	// Setze zwei Middleware
	// recover wird verwendet, um Panikfehler abzufangen, um einen abnormalen Programmabbruch zu vermeiden
	// logger wird verwendet, um Anfragen zu protokollieren
	app.Use(recover.New())
	app.Use(logger.New())

	// Registriere den Controller für die "/"-Root-Route hier.
	mvc.New(app).Handle(new(ExampleController))
	
	// Er kann auch mit Hilfe von Routengruppen für einen bestimmten Pfad registriert werden
	// Beispiel: Registriere den Controller unter dem Pfad /books
	// mvc.New(app.Party("/books")).Handle(new(ExampleController))
}

func main() {
	// Erstelle die Anwendung
	app := newApp()

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

// Definiere ExampleController zur Bearbeitung von Anfragen für "/", "/ping" und "/hello".
type ExampleController struct{}

// Behandelt GET-Anfrage
// Anfrage-URL: http://localhost:8080
func (c *ExampleController) Get() mvc.Result {
	return mvc.Response{
		ContentType: "text/html",
		Text:        "<h1>Willkommen</h1>",
	}
}

// GetPing dient
// Methode:   GET
// Anfrage-URL: http://localhost:8080/ping
func (c *ExampleController) GetPing() string {
	return "pong"
}

// GetHello dient
// Methode:   GET
// Anfrage-URL: http://localhost:8080/hello
func (c *ExampleController) GetHello() interface{} {
	return map[string]string{"message": "Hallo Iris!"}
}

// GetHelloWorld dient
// Methode:   GET
// Anfrage-URL: http://localhost:8080/hello/world
func (c *ExampleController) GetHelloWorld() interface{} {
	return map[string]string{"message": "Hallo Iris! DefaultPath"}
}

Beziehung zwischen MVC-Routing und der Benennungsregel der Controller-Funktionen.

Routenadresse: Routengruppe + HTTP-Methodenname + Funktionsname (Kleinbuchstaben)

Zum Beispiel:

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

Da keine Routengruppe festgelegt ist, kann diese Funktion GET-Anfragen für die Route http://localhost:8080/ping bearbeiten.