Roteamento no Iris de Go

O framework iris tem dois modos para vinculação de rotas, um é funcional e o outro é o MVC. O modo funcional vincula uma função de manipulação a um caminho de URL especificado, enquanto o modo MVC vincula um controlador a um caminho de URL. O framework gera automaticamente os caminhos de URL correspondentes com base nas regras de nomeação dos métodos do controlador e vincula automaticamente as funções do controlador correspondentes.

Vinculação de Rota Funcional

O modelo de roteamento mais simples no framework iris, onde você pode vincular uma função a qualquer URL.

func main() {
    // Crie uma aplicação iris com middleware padrão:
    // Por padrão, ele usa o nível de log "debug".
    // Ele suporta localização localizada no diretório "./locales".
    // Os modelos HTML estão localizados nos diretórios "./views" ou "./templates".
    // Logs de acesso são salvos em "./access.log",
    // e a recuperação (sem travamento) e o middleware de ID de solicitação já estão anexados.
    app := iris.Default()

	// Simplesmente vincule funções de rota com base no método de solicitação HTTP e caminho, semelhante ao mecanismo de roteamento em Gin, echo e outros 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)
    
	// Escute na porta
    app.Listen(":8080")
}

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

    // Este manipulador irá corresponder a /user/john mas não a /user/ ou /user
    app.Get("/user/{name}", func(ctx iris.Context) {
        name := ctx.Params().Get("name")
        ctx.Writef("Olá %s", name)
    })
    
    // No entanto, este manipulador irá corresponder a /user/john/ e /user/john/send
    // Se nenhuma outra rota corresponder a /user/john, redirecionará para /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)
    })
    
    // Para cada requisição correspondida, o Context manterá a definição da rota
    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 embutidos disponíveis:

Group Routing

Às vezes, é necessário o gerenciamento de versão da API, ou um prefixo unificado é definido para o roteamento de um grande módulo. É aqui que entra a capacidade do roteamento de grupo.

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

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

Roteamento MVC

O framework Go Iris suporta a arquitetura MVC, mapeando rotas para funções de controle específicas através de regras específicas.

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

// Cria uma aplicação iris
func newApp() *iris.Application {
	app := iris.New()
	// Configura dois middlewares
	// recover é usado para interceptar erros de pânico e evitar a terminação anormal do programa
	// logger é usado para registrar pedidos
	app.Use(recover.New())
	app.Use(logger.New())

	// Registra o controlador na rota raiz "/"
	mvc.New(app).Handle(new(ExampleController))
	
	// Também pode ser registrado em um caminho específico com a ajuda do agrupamento de rotas
	// Exemplo: Registra o controlador no caminho /livro
	// mvc.New(app.Party("/livro")).Handle(new(ExampleController))
}

func main() {
	// Cria a aplicação
	app := newApp()

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

// Define o ExampleController para lidar com pedidos para "/", "/ping" e "/hello".
type ExampleController struct{}

// Lida com o pedido GET
// URL do pedido: http://localhost:8080
func (c *ExampleController) Get() mvc.Result {
	return mvc.Response{
		ContentType: "text/html",
		Text:        "<h1>Bem-vindo</h1>",
	}
}

// GetPing serve
// Método:   GET
// URL do pedido: http://localhost:8080/ping
func (c *ExampleController) GetPing() string {
	return "pong"
}

// GetHello serve
// Método:   GET
// URL do pedido: http://localhost:8080/hello
func (c *ExampleController) GetHello() interface{} {
	return map[string]string{"message": "Olá Iris!"}
}

// GetHelloWorld serve
// Método:   GET
// URL do pedido: http://localhost:8080/hello/mundo
func (c *ExampleController) GetHelloWorld() interface{} {
	return map[string]string{"message": "Olá Iris! DefaultPath"}
}

Relação entre o roteamento MVC e a regra de nomeação das funções do controlador.

Endereço da Rota: Grupo de Rotas + Nome do Método HTTP + Nome da Função (minúsculo)

Por exemplo:

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

Como nenhum agrupamento de rota foi definido, esta função pode lidar com pedidos GET para a rota http://localhost:8080/ping.