Enrutamiento con Iris en Go

El framework iris tiene dos modos para la vinculación de rutas, uno es funcional y el otro es MVC. El modo funcional vincula una función de manejo a una ruta URL especificada, mientras que el modo MVC vincula un controlador a una ruta URL. El framework genera automáticamente rutas URL correspondientes basadas en las reglas de nombrado de los métodos del controlador, y vincula automáticamente las funciones del controlador correspondientes.

Vinculación de Ruta Funcional

El modelo de enrutamiento más simple en el framework iris, donde puedes vincular una función a cualquier URL.

func main() {
    // Crea una aplicación iris con middleware predeterminado:
    // De forma predeterminada, utiliza el nivel de registro "debug".
    // Admite la localización ubicada en el directorio "./locales".
    // Las plantillas HTML se encuentran en los directorios "./views" o "./templates".
    // Los registros de acceso se guardan en "./access.log",
    // y la recuperación (sin fallos) y el middleware de identificación de solicitud ya están adjuntos.
    app := iris.Default()

	// Simplemente vincula funciones de ruta según el método de solicitud HTTP y la ruta, similar al mecanismo de enrutamiento en Gin, echo y otros frameworks.
    app.Get("/someGet", obteniendo)
    app.Post("/somePost", enviando)
    app.Put("/somePut", poniendo)
    app.Delete("/someDelete", eliminando)
    app.Patch("/somePatch", parchando)
    app.Header("/someHead", cabecera)
    app.Options("/someOptions", opciones)
    
	// Escucha en el puerto
    app.Listen(":8080")
}

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

    // Este controlador coincidirá con /user/john pero no con /user/ o /user
    app.Get("/user/{name}", func(ctx iris.Context) {
        name := ctx.Params().Get("name")
        ctx.Writef("Hola %s", name)
    })
    
    // Sin embargo, este controlador coincidirá con /user/john/ y /user/john/send
    // Si ninguna otra ruta coincide con /user/john, redireccionará a /user/john/
    app.Get("/user/{name}/{action:path}", func(ctx iris.Context) {
        name := ctx.Params().Get("name")
        action := ctx.Params().Get("action")
        mensaje := name + " es " + action
        ctx.WriteString(mensaje)
    })
    
    // Para cada solicitud coincidente, el Contexto mantendrá la definición de ruta
    app.Post("/user/{name:string}/{action:path}", func(ctx iris.Context) {
        ctx.GetCurrentRoute().Tmpl().Src == "/user/{name:string}/{action:path}" // true
    })
    
    app.Listen(":8080")
}

Tipos de parámetros integrados disponibles:

Enrutamiento de grupo

A veces, es necesario gestionar la versión de la API o establecer un prefijo unificado para el enrutamiento de un módulo grande. Aquí es donde entra en juego la capacidad de enrutamiento de grupo.

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

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

Enrutamiento MVC

El marco Go Iris admite la arquitectura MVC, mapeando rutas a funciones de controlador específicas a través de ciertas reglas.

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

// Crear una aplicación Iris
func newApp() *iris.Application {
	app := iris.New()
	// Configurar dos middleware
	// recover se utiliza para interceptar errores de pánico y evitar la terminación anormal del programa
	// logger se utiliza para registrar las solicitudes
	app.Use(recover.New())
	app.Use(logger.New())

	// Registrar el controlador en la ruta raíz "/" aquí.
	mvc.New(app).Handle(new(ExampleController))
	
	// También se puede registrar en una ruta específica con la ayuda de la agrupación de rutas
	// Ejemplo: Registrar el controlador en la ruta /books
	// mvc.New(app.Party("/books")).Handle(new(ExampleController))
}

func main() {
	// Crear la aplicación
	app := newApp()

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

// Definir ExampleController para manejar las solicitudes para "/", "/ping" y "/hello".
type ExampleController struct{}

// Manejar la solicitud GET
// URL de la solicitud: http://localhost:8080
func (c *ExampleController) Get() mvc.Result {
	return mvc.Response{
		ContentType: "text/html",
		Text:        "<h1>Bienvenido</h1>",
	}
}

// GetPing devuelve
// Método: GET
// URL de la solicitud: http://localhost:8080/ping
func (c *ExampleController) GetPing() string {
	return "pong"
}

// GetHello devuelve
// Método: GET
// URL de la solicitud: http://localhost:8080/hello
func (c *ExampleController) GetHello() interface{} {
	return map[string]string{"mensaje": "¡Hola Iris!"}
}

// GetHelloWorld devuelve
// Método: GET
// URL de la solicitud: http://localhost:8080/hello/world
func (c *ExampleController) GetHelloWorld() interface{} {
	return map[string]string{"mensaje": "¡Hola Iris! Ruta predeterminada"}
}

Relación entre el enrutamiento MVC y la regla de nombrado de las funciones de controlador.

Dirección de la ruta: Grupo de rutas + nombre del método HTTP + nombre de la función (en minúsculas)

Por ejemplo:

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

Como no se establece ningún grupo de rutas, esta función puede manejar las solicitudes GET para la ruta http://localhost:8080/ping.