El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
HOME Els meus cursos Finalitzats
◄ Anterior
◄

Enrutament

Següent ►
►

En aquest tema, aprendrem com gestionar les rutes en una aplicació web escrita en Go. L'enrutament és una part fonamental de qualsevol aplicació web, ja que permet definir com es gestionen les diferents sol·licituds HTTP que arriben al servidor.

Objectius

  • Entendre què és l'enrutament i per què és important.
  • Aprendre a definir rutes bàsiques en Go.
  • Utilitzar un paquet de tercers per a l'enrutament avançat.
  • Gestionar paràmetres en les rutes.
  • Implementar middleware per a les rutes.

Què és l'Enrutament?

L'enrutament és el procés de mapejar les sol·licituds HTTP a funcions específiques que gestionen aquestes sol·licituds. En una aplicació web, les rutes defineixen com es gestionen les sol·licituds per a diferents URL.

Definint Rutes Bàsiques

Comencem amb un exemple senzill d'enrutament utilitzant el paquet net/http de la biblioteca estàndard de Go.

package main

import (
    "fmt"
    "net/http"
)

func homeHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Benvingut a la pàgina principal!")
}

func aboutHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Aquesta és la pàgina sobre nosaltres.")
}

func main() {
    http.HandleFunc("/", homeHandler)
    http.HandleFunc("/about", aboutHandler)
    http.ListenAndServe(":8080", nil)
}

Explicació del Codi

  1. Importació de Paquets: Importem els paquets necessaris (fmt i net/http).
  2. Definició de Funcions de Gestió: Definim dues funcions (homeHandler i aboutHandler) que gestionen les sol·licituds per a les rutes / i /about, respectivament.
  3. Mapeig de Rutes: Utilitzem http.HandleFunc per mapar les rutes a les funcions de gestió.
  4. Inici del Servidor: Utilitzem http.ListenAndServe per iniciar el servidor a localhost en el port 8080.

Utilitzant un Paquet de Tercers: gorilla/mux

Per a una gestió d'enrutament més avançada, podem utilitzar el paquet gorilla/mux.

Instal·lació

Per instal·lar gorilla/mux, executa:

go get -u github.com/gorilla/mux

Exemple amb gorilla/mux

package main

import (
    "fmt"
    "net/http"
    "github.com/gorilla/mux"
)

func homeHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Benvingut a la pàgina principal!")
}

func aboutHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Aquesta és la pàgina sobre nosaltres.")
}

func main() {
    r := mux.NewRouter()
    r.HandleFunc("/", homeHandler)
    r.HandleFunc("/about", aboutHandler)
    http.ListenAndServe(":8080", r)
}

Explicació del Codi

  1. Importació de Paquets: A més dels paquets fmt i net/http, importem github.com/gorilla/mux.
  2. Creació del Router: Utilitzem mux.NewRouter per crear un nou router.
  3. Mapeig de Rutes: Utilitzem r.HandleFunc per mapar les rutes a les funcions de gestió.
  4. Inici del Servidor: Utilitzem http.ListenAndServe per iniciar el servidor, passant el router com a segon argument.

Gestionant Paràmetres en les Rutes

Amb gorilla/mux, podem gestionar paràmetres en les rutes de manera senzilla.

Exemple amb Paràmetres

package main

import (
    "fmt"
    "net/http"
    "github.com/gorilla/mux"
)

func articleHandler(w http.ResponseWriter, r *http.Request) {
    vars := mux.Vars(r)
    articleID := vars["id"]
    fmt.Fprintf(w, "Estàs veient l'article amb ID: %s", articleID)
}

func main() {
    r := mux.NewRouter()
    r.HandleFunc("/article/{id}", articleHandler)
    http.ListenAndServe(":8080", r)
}

Explicació del Codi

  1. Funció de Gestió amb Paràmetres: La funció articleHandler utilitza mux.Vars per obtenir els paràmetres de la ruta.
  2. Definició de la Ruta amb Paràmetres: Utilitzem {id} per definir un paràmetre en la ruta /article/{id}.

Implementant Middleware

El middleware és una funció que s'executa abans que la funció de gestió de la ruta. Pot ser utilitzat per a tasques com l'autenticació, el registre, etc.

Exemple de Middleware

package main

import (
    "fmt"
    "net/http"
    "github.com/gorilla/mux"
)

func loggingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        fmt.Println("Sol·licitud rebuda:", r.Method, r.URL)
        next.ServeHTTP(w, r)
    })
}

func homeHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Benvingut a la pàgina principal!")
}

func main() {
    r := mux.NewRouter()
    r.Use(loggingMiddleware)
    r.HandleFunc("/", homeHandler)
    http.ListenAndServe(":8080", r)
}

Explicació del Codi

  1. Funció de Middleware: La funció loggingMiddleware registra la sol·licitud i després crida next.ServeHTTP per passar la sol·licitud a la següent funció de gestió.
  2. Aplicació del Middleware: Utilitzem r.Use per aplicar el middleware al router.

Exercicis Pràctics

  1. Exercici 1: Crea una aplicació web que tingui les següents rutes:

    • /: Mostra un missatge de benvinguda.
    • /contact: Mostra informació de contacte.
    • /product/{id}: Mostra informació sobre un producte específic basat en l'ID.

  2. Exercici 2: Implementa un middleware que registri el temps que triga a processar cada sol·licitud.

Solucions

Solució Exercici 1

package main

import (
    "fmt"
    "net/http"
    "github.com/gorilla/mux"
)

func homeHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Benvingut a la pàgina principal!")
}

func contactHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Contacta'ns a: [email protected]")
}

func productHandler(w http.ResponseWriter, r *http.Request) {
    vars := mux.Vars(r)
    productID := vars["id"]
    fmt.Fprintf(w, "Estàs veient el producte amb ID: %s", productID)
}

func main() {
    r := mux.NewRouter()
    r.HandleFunc("/", homeHandler)
    r.HandleFunc("/contact", contactHandler)
    r.HandleFunc("/product/{id}", productHandler)
    http.ListenAndServe(":8080", r)
}

Solució Exercici 2

package main

import (
    "fmt"
    "net/http"
    "time"
    "github.com/gorilla/mux"
)

func timingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        next.ServeHTTP(w, r)
        duration := time.Since(start)
        fmt.Println("Temps de processament:", duration)
    })
}

func homeHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Benvingut a la pàgina principal!")
}

func main() {
    r := mux.NewRouter()
    r.Use(timingMiddleware)
    r.HandleFunc("/", homeHandler)
    http.ListenAndServe(":8080", r)
}

Conclusió

En aquesta secció, hem après els conceptes bàsics de l'enrutament en Go, com definir rutes bàsiques, utilitzar un paquet de tercers per a l'enrutament avançat, gestionar paràmetres en les rutes i implementar middleware. Amb aquests coneixements, estàs preparat per gestionar les rutes de la teva aplicació web de manera eficient i organitzada.

◄ Anterior
◄
Següent ►
►
El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
© Copyright 2024. Tots els drets reservats