In questo breve articolo vedremo nel dettaglio che cosa sono le rotte e come si applica il routing nel framework Flask.
Innanzitutto, vediamo che cosa sono le rotte:
Le rotte in un framework ci permettono di collegare una richiesta HTTP o HTTPS a una funzione, la quale restituisce una risposta, come ad esempio una vista, del testo, un file JSON o qualsiasi altro contenuto.
Nella barra degli indirizzi la route è tutto ciò che sta dopo l’indirizzo base. Ad esempio:
www.miosito.com/homepage
Vediamo che www.miosito.com è l’indirizzo base, mentre /homepage è la rotta che punta a una determinata funzione, la quale può restituire, ad esempio, una pagina HTML che rappresenta la home del sito.
Consideriamo ora un altro URL:
www.miosito.com/articoli/34
In maniera analoga all’esempio precedente, www.miosito.com è l’indirizzo base, mentre /articoli/34 è la rotta che viene associata a una funzione — ipoteticamente chiamata articoli — che probabilmente restituirà una pagina dinamica contenente un articolo specifico, identificato dall’ID 34.
Come abbiamo detto in precedenza, una rotta collega un URL (detto anche route) a una particolare funzione che in Flask si chiama view function, spesso indicata in gergo come vista. Il collegamento viene fatto attraverso una mappatura. La mappatura delle rotte può essere fatto nei seguenti modi:
- Attraverso il metodo esplicito integrato il core di Flask add_url_rule().
- Attraverso l’uso dei decoratori.
add_url_rule()
add_url_rule() è un metodo dell’oggetto Flask che serve a creare una rotta manualmente, senza usare i decoratori @app.route().
È una funzione potente perché permette un controllo completo sulla configurazione delle rotte. Vediamo un semplice esempio:
from flask import Flask
app = Flask(__name__)
# Definisco la vista
def homepage():
return "Hello world"
# Uso la funzione add_url_rule per creare la rotta
app.add_url_rule("/", "homepage", homepage)
if __name__ == "__main__":
app.run(debug=True)
facciamo un breve descrizione del codice:
- from flask import Flask -> Importo la libreria Flask
- app = Flask(__name__) -> Crea un’ istanza della classe Flask racchiusa in una variabile chiamata app. Questa rappresenta l’applicazione.
- def homepage(): -> Questa è la view function.
- return “Hello world” -> Ciò che restituisce la vista.
- app.add_url_rule(“/”, “homepage”, homepage) -> L’implementazione di app.add_rule()
- app.run(debug=True) -> Avvia il server di sviluppo di Flask in modalità di debug.
Possiamo vedere dall’implementazione della funzione add_url_rule(“/”, “homepage”, homepage) nel codice che vi sono tre parametri principali, in realtà c’è ne esistono anche altri, ma per il momento esaminiamo quelli presenti nel codice di esempio:
- Il primo parametro è detto rule che è l’url della rotta.
- “/”
- “/contatti”
- “articoli/34”
- Il secondo parametro è detto endpoint che è il nome univoco della rotta dentro Flask. (Serve ad esempio per i collegamenti ipertestuali)
- Il terzo parametro è la view function, semplicemente funzione Python da eseguire quando qualcuno visita la rotta.
Vediamo anche altri parametri:
-
- provide_automatic_options e impostato a False, disattiva la generazione automatica della rotta OPTIONS. Di solito non serve modificarlo.
- **options — parametri aggiuntivi. Qui puoi mettere:
- methods. Lista dei metodi HTTP ammessi: methods=[“GET”, “POST”]
- default. Valori di default per i parametri della rotta: view_func=user
- strict_slashes. Se False, accetta sia /rotta che /rotta/: strict_slashes=False
-
- subdomain. Gestione dei sottodomini: subdomain=”api”
Le rotte con i decoratori
Il metodo di mappare le rotte tramite decoratore è semplicemente un’alternativa più elegante e sintetica all’uso della funzione add_url_rule() vista in precedenza. Nel seguente esempio vediamo come si applica.
I decoratori
Vediamo velocemente cosa sono i decoratori di Python. Un decoratore in Python serve a modificare o ad estendere funzionalità ad una funzione senza modificarne la struttura.
Esempio:
def mioDecoratore(func):
def wrapper(nome):
print("Prima della funzione")
func(nome)
print("Dopo la funzione")
return wrapper
@mioDecoratore
def saluta(nome):
print(f"Hello my dear {nome}!")
saluta("Gino")
I decoratori in Python sono uno strumento elegante e potente per estendere o modificare il comportamento di una funzione (o di una classe) senza toccarne il codice originale. Permettono di separare la logica principale da aspetti trasversali come logging, validazione, caching, misurazione dei tempi o controllo degli accessi.
Adesso vediamo come applicare la tecnica dei decoratori alle rotte di Flask.
@app.route("/")
def homepage():
return "Hello world!"
Vediamo ora il codice scritto in precedenza:
@app.route(“/”) -> Definisco il decoratore che come parametro ha l’url.
def homepage(): -> Definisco la view function.
return “Hello world!” -> Restituisco un testo.
L’ uso dei decoratori ci permette di scrivere un codice più immediato, leggibile e pulito che si avvicina di più alle logiche di Flask.
@app.route("/contatti")
def contatti():
return "Questa è la mia pagina dei contatti!"
Come possiamo vedere dal seguente codice il decoratore non fa altro che richiamare direttamente add_url_rule() nella funzione che richiama.
def route(self, rule, **options):
def decorator(f):
self.add_url_rule(rule, f.__name__, f, **options)
return f
return decorator
Passaggio di parametri
Nel sistema di routing possiamo anche passare dei parametri alla view function. Per fare ciò scriviamo la rule mettendo dopo il nome della rotta la variabile scritta nel seguente modo /<nome_variabile> e sempre il nome della variabile come parametro della vista.
Esempio:
- Usando add_url_rule().
def utenti(nome):
return f"Ciao {nome}!"
app.add_url_rule("/utenti/<nome>", “utenti", utenti)
- Usando le rotte.
@app.route("/utente/<nome>")
def utente(nome):
return f"Ciao {nome}!"
Possiamo anche specificare i parametri.
app.add_url_rule("/utenti/<string:nome>", “utenti", utenti)
app.add_url_rule("/contatti/<int:id>", “contatti", contatti)
@app.route("/utente/<string:nome>")
@app.route("/contatti/<int:id>")
Possiamo passare più parametri:
def utenti(nome, cognome):
return f"Ciao {nome} {cognome}!"
app.add_url_rule("/utenti/<nome>/<string:cognome>", “utenti", utenti)
@app.route("/utenti/<nome>/<string:cognome>")
def utenti(nome, cognome):
return f"Ciao {nome} {cognome}!"
Conclusioni
In questo breve articolo abbiamo visto i diversi modi di mappare le rotte in un’applicazione Flask, dal metodo più esplicito tramite add_url_rule() fino alla forma più elegante e leggibile offerta dai decoratori. Abbiamo inoltre osservato come sia possibile arricchire gli URL con variabili dinamiche e tipi specifici, rendendo le nostre rotte più flessibili e adatte a gestire scenari reali.
La gestione delle rotte è uno degli aspetti fondamentali nello sviluppo di un’applicazione web, perché permette di controllare il flusso di navigazione e di collegare in modo chiaro ogni URL alla logica corrispondente. Capire bene questi meccanismi è quindi un passo essenziale per lavorare con Flask in modo efficace.
