Routage Go Iris

Le framework iris propose deux modes de liaison de route, l'un fonctionnel et l'autre MVC. Le mode fonctionnel lie une fonction de traitement à un chemin d'URL spécifié, tandis que le mode MVC lie un contrôleur à un chemin d'URL. Le framework génère automatiquement des chemins d'URL correspondants en fonction des règles de nommage des méthodes du contrôleur, et lie automatiquement les fonctions de contrôleur correspondantes.

Liaison de route fonctionnelle

Le modèle de routage le plus simple dans le framework iris, où vous pouvez lier une fonction à n'importe quelle URL.

func main() {
    // Crée une application iris avec un middleware par défaut :
    // Par défaut, il utilise le niveau de journalisation "debug".
    // Il prend en charge la localisation située sous le répertoire "./locales".
    // Les modèles HTML se trouvent dans les répertoires "./views" ou "./templates".
    // Les journaux d'accès sont enregistrés dans "./access.log",
    // et le middleware de récupération (sans crash) et l'ID de requête sont déjà attachés.
    app := iris.Default()

	// Lie simplement les fonctions de route en fonction de la méthode de requête HTTP et du chemin, similaire au mécanisme de routage dans Gin, echo, et d'autres 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)
    
	// Écoute sur le port
    app.Listen(":8080")
}

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

    // Ce gestionnaire correspondra à /user/john mais pas à /user/ ou /user
    app.Get("/user/{name}", func(ctx iris.Context) {
        name := ctx.Params().Get("name")
        ctx.Writef("Bonjour %s", name)
    })
    
    // Cependant, ce gestionnaire correspondra à /user/john/ et /user/john/send
    // Si aucune autre route ne correspond à /user/john, il redirigera vers /user/john/
    app.Get("/user/{name}/{action:path}", func(ctx iris.Context) {
        name := ctx.Params().Get("name")
        action := ctx.Params().Get("action")
        message := name + " est " + action
        ctx.WriteString(message)
    })
    
    // Pour chaque requête correspondante, Context conservera la définition de la 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")
}

Types de paramètres intégrés disponibles :

Routage de groupe

Parfois, la gestion de la version de l'API est nécessaire, ou un préfixe unifié est défini pour le routage d'un grand module. C'est là que la capacité de routage de groupe entre en jeu.

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

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

Routage MVC

Le framework Go Iris prend en charge l'architecture MVC, en cartographiant les routes vers des fonctions de contrôleur spécifiques selon certaines règles.

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

// Créer une application iris
func newApp() *iris.Application {
	app := iris.New()
	// Définir deux middleware
	// recover est utilisé pour intercepter les erreurs de panique et éviter une terminaison anormale du programme
	// logger est utilisé pour enregistrer les requêtes
	app.Use(recover.New())
	app.Use(logger.New())

	// Enregistrer le contrôleur sur la route racine "/"
	mvc.New(app).Handle(new(ExampleController))
	
	// Il peut également être enregistré sur un chemin spécifique à l'aide d'un regroupement de routes
	// Exemple : Enregistrer le contrôleur sous le chemin "/livres"
	// mvc.New(app.Party("/livres")).Handle(new(ExampleController))
}

func main() {
	// Créer l'application
	app := newApp()

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

// Définir ExampleController pour gérer les requêtes pour "/", "/ping" et "/hello".
type ExampleController struct{}

// Gérer la demande GET
// URL de la requête : http://localhost:8080
func (c *ExampleController) Get() mvc.Result {
	return mvc.Response{
		ContentType: "text/html",
		Text:        "<h1>Bienvenue</h1>",
	}
}

// GetPing retourne
// Méthode :   GET
// URL de la requête : http://localhost:8080/ping
func (c *ExampleController) GetPing() string {
	return "pong"
}

// GetHello sert
// Méthode :   GET
// URL de la requête : http://localhost:8080/hello
func (c *ExampleController) GetHello() interface{} {
	return map[string]string{"message": "Bonjour Iris!"}
}

// GetHelloWorld sert
// Méthode :   GET
// URL de la requête : http://localhost:8080/hello/world
func (c *ExampleController) GetHelloWorld() interface{} {
	return map[string]string{"message": "Bonjour Iris! CheminParDéfaut"}
}

Relation entre le routage MVC et la règle de nommage des fonctions de contrôleur.

Adresse de la route : Regroupement de routes + Nom de la méthode HTTP + Nom de la fonction (en minuscules)

Par exemple :

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

Comme aucun regroupement de routes n'est défini, cette fonction peut gérer les demandes GET pour la route http://localhost:8080/ping.