Symfony: struttura e funzionamento

Conosciamo il pattern MVC ed esaminiamo il funzionamento del framework, basato sul modello del front controller


Entriamo nel vivo! Ora che abbiamo creato un progetto Symfony funzionante, possiamo vedere finalmente cosa c’è in questo scatolone magico.

Il pattern MVC

Da bravi sviluppatori è fondamentale conoscere il pattern architetturale dello strumento che stiamo utilizzando e capire il ruolo di ogni componente. Symfony usa il pattern MVC. Ora, esistono libri su libri riguardo a questo argomento e probabilmente sarebbe opportuno creare almeno un articolo a parte, ma cercherò di semplificare al massimo.

Innanzitutto un pattern architetturale è un insieme di accorgimenti e regole che si impongono per far sì che un progetto sia costruito secondo un certo criterio e che ogni sviluppatore scriva codice opportunamente.

MVC sta per Model View Controller, i tre componenti del pattern. In breve:

  • Il Controller riceve i comandi dall’utente e comunica al Model cosa fare;
  • Il Model si occupa di preparare i dati necessari, ad esempio effettuando query al database;
  • La View riceve i dati estrapolati dal Model e li visualizza;

Per fare un esempio pratico, supponete di voler visualizzare l’articolo di un blog. Il Controller individua la richiesta fatta tramite la URL e la comunica al Model, che estrae l’articolo dal database e lo passa alla View, che si occupa di visualizzare la pagina richiesta.

Pattern MVC
via Wikimedia Commons

È fondamentale capire il ruolo di ognuno di questi componenti, perché il pattern deve essere sempre rispettato. Pensate sempre che, anche se non lavorate in team, prima o poi un altro programmatore potrebbe dover mettere le mani sul vostro codice. Naturalmente deve essere messo in condizioni di poter capire cosa avete fatto. Dico questo perché potreste obbiettare sul fatto che un framework costringa ad un certo approccio e che per questo vi lasci poche libertà, che tarpi le ali del vostro efficientissimo stile di programmazione. Ebbene, questo è vero, ma è un fattore positivo! Sappiate che lo “stile di programmazione” non esiste. In un progetto tutti gli sviluppatori devono seguire la stessa filosofia, il medesimo approccio: i vantaggi sono infiniti!

Il filesystem

Ora che per sommi capi sappiamo cosa aspettarci, possiamo finalmente esaminare il contenuto di un progetto Symfony. Posizionandoci nella directory principale e digitando il comando ls, notiamo una serie di file e cartelle. Concentriamo la nostra attenzione sulle directory del primo livello:

$ ls -d */

app/    bin/    src/    tests/    var/    vendor/    web/

app contiene dei file di configurazione del progetto e il file AppKernel.php, di cui parleremo più tardi;

web è la root del progetto, contiene gli assets (ovvero file js, css, immagini) utilizzati effettivamente dal sito e il file app.php (e l’analogo app_dev.php), fondamentale, che costituisce il front controller del framework;

src contiene i file su cui lavorerete di più, perché sono quelli che contengono il codice che determina il comportamento dell’applicazione;

bin è una cartella su cui potreste non metterete mai le mani, ma contiene console, un’applicazione per la linea di comando che useremo abbondantemente;

var contiene i file di log e di cache;

tests contiene i test automatici, ossia metodi che si occupano di effettuare operazioni strategiche per capire se la web app funziona correttamente o se qualcosa si è rotto.

vendor tecnicamente non c’entra con Symfony, ma con Composer, un gestore di pacchetti che vedremo tra qualche articolo. In sostanza questa directory contiene le dipendenze del progetto, come i Symfony Components, di cui abbiamo parlato nell’articolo introduttivo.

Front controller e Kernel

Sia chiaro nella mente come funziona il web. Quando visitate una pagina Internet, di fatto state facendo una richiesta HTTP (che contiene una URL) con il vostro browser (il client) ad un server. Quest’ultimo fa le sue elaborazioni e restituisce una risposta, che è la pagina HTML che visualizzate sullo schermo.

Molti dei framework MVC moderni – tra cui anche Symfony – adottano un modello che fa uso di un front controller. Si tratta di un punto centralizzato da cui passa ogni richiesta HTTP, indipendentemente dalla URL.

Nel caso di Symfony, il ruolo di front controller è assunto dal file app.php in ambiente di produzione (cioè sul sito Internet destinato agli utenti finali), oppure da app_dev.php in ambiente di sviluppo (in locale, sul vostro PC), entrambi nella directory /web. Per semplicità, d’ora in poi farò riferimento all’utilizzo di app.php come front controller.

Il compito principale di app.php è quello di creare un’istanza del kernel, il nucleo di Symfony, che si occupa di caricare i componenti che fanno parte del progetto, i bundle (che studieremo approfonditamente). Ad assumerne il ruolo è AppKernel.php, nella directory /app.

A questo punto la rotta (ossia il percorso specificato nella URL) viene esaminata e viene richiamata l’opportuna sezione di codice, detta action, atta a soddisfare la richiesta.

Principio di funzionamento
Principio di funzionamento, via Symfony doc

L’insieme di front controller, kernel e action costituiscono il componente Controller del pattern MVC.

Nel prossimo articolo metteremo finalmente mano al codice, per vedere come creare nuove pagine per la nostra webapp.


Se ti è piaciuto l'articolo seguimi sulla pagina Facebook


Commenti

Lascia un commento

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *