Routing con Go Iris

Il framework iris ha due modalità per il binding delle route, una è funzionale e l'altra è MVC. La modalità funzionale collega una funzione di gestione a un percorso URL specificato, mentre la modalità MVC collega un controller a un percorso URL. Il framework genera automaticamente percorsi URL corrispondenti in base alle regole di denominazione dei metodi del controller e collega automaticamente le funzioni del controller corrispondenti.

Binding della Route Funzionale

Il modello di routing più semplice nel framework iris, in cui è possibile collegare una funzione a qualsiasi URL.

func main() {
    // Crea un'applicazione iris con middleware predefiniti:
    // Per impostazione predefinita, utilizza il livello di registro "debug".
    // Supporta la localizzazione situata sotto la directory "./locales".
    // I modelli HTML sono situati sotto le directory "./views" o "./templates".
    // I log degli accessi vengono salvati in "./access.log",
    // e il middleware di recovery (senza crash) e ID della richiesta sono già allegati.
    app := iris.Default()

	// Collega semplicemente le funzioni della route in base al metodo di richiesta HTTP e al percorso, simile al meccanismo di routing in Gin, echo e altri framework.
    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)
    
	// Ascolta sulla porta
    app.Listen(":8080")
}

package main

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

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

    // Questo gestore corrisponderà a /user/john ma non a /user/ o /user
    app.Get("/user/{name}", func(ctx iris.Context) {
        name := ctx.Params().Get("name")
        ctx.Writef("Ciao %s", name)
    })

    // Tuttavia, questo gestore corrisponderà a /user/john/ e /user/john/send
    // Se nessun'altra route corrisponde a /user/john, verrà reindirizzato a /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)
    })

    // Per ogni richiesta corrispondente, Context conserverà la definizione della 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")
}

Tipi di parametri incorporati disponibili:

## Gruppo di Routing

A volte è necessaria la gestione della versione dell'API, oppure viene impostato un prefisso unificato per il routing di un ampio modulo. Qui entra in gioco la capacità di creare gruppi di routing.

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

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

Routing MVC

Il framework Go Iris supporta l'architettura MVC, mappando le route a specifiche funzioni del controller attraverso determinate regole.

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

// Crea un'applicazione iris
func newApp() *iris.Application {
	app := iris.New()
	// Imposta due middleware
	// recover è utilizzato per intercettare gli errori di panico per evitare la terminazione anomala del programma
	// logger è utilizzato per registrare le richieste
	app.Use(recover.New())
	app.Use(logger.New())

	// Registra il controller alla route root "/"
	mvc.New(app).Handle(new(ExampleController))
	
	// Può anche essere registrato in un percorso specifico con l'ausilio dei gruppi di route
	// Esempio: Registra il controller sotto il percorso /books
	// mvc.New(app.Party("/books")).Handle(new(ExampleController))
}

func main() {
	// Crea l'applicazione
	app := newApp()

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

// Definisci ExampleController per gestire le richieste per "/", "/ping" e "/hello".
type ExampleController struct{}

// Gestisci la richiesta GET
// URL della richiesta: http://localhost:8080
func (c *ExampleController) Get() mvc.Result {
	return mvc.Response{
		ContentType: "text/html",
		Text:        "<h1>Benvenuto</h1>",
	}
}

// GetPing serve
// Metodo:   GET
// URL della richiesta: http://localhost:8080/ping
func (c *ExampleController) GetPing() string {
	return "pong"
}

// GetHello serve
// Metodo:   GET
// URL della richiesta: http://localhost:8080/hello
func (c *ExampleController) GetHello() interface{} {
	return map[string]string{"message": "Ciao Iris!"}
}

// GetHelloWorld serve
// Metodo:   GET
// URL della richiesta: http://localhost:8080/hello/world
func (c *ExampleController) GetHelloWorld() interface{} {
	return map[string]string{"message": "Ciao Iris! DefaultPath"}
}

Relazione tra il routing MVC e la regola di denominazione delle funzioni del controller.

Indirizzo della Route: Gruppo della Route + Nome del metodo HTTP + Nome della funzione (in minuscolo)

Per esempio:

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

Poiché non è stato impostato alcun gruppo di route, questa funzione può gestire le richieste GET per la route http://localhost:8080/ping.