Symfony 4: struttura e funzionamento

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

Symfony: struttura e funzionamento

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

Il pattern MVC

Se non siete proprio degli esperti e vi state approcciando ad un framework per la prima volta, probabilmente siete abituati a creare un file PHP per ogni pagina del sito, contenente un mix di logica e stampe a video. Ebbene, Symfony segue un approccio del tutto differente, perciò, prima di partire, è fondamentale conoscere il pattern architetturale che utilizza, ossia il pattern MVC. Esistono libri su libri su questo argomento e probabilmente sarebbe opportuno creare almeno un articolo a parte, ma cercherò di semplificare al massimo.

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

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 */

bin/ config/ public/ src/ templates/ var/ vendor/

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

config contiene dei file di configurazione che riguardano le rotte, i servizi e i package che installarete;

public è la root del progetto e contiene essenzialmente index.php, il front controller del framework, ossia il primo file che viene eseguito da Symfony e che spiegherò a breve. Inoltre la directory contiene gli asset del progetto (ovvero i file statici, come css, js e le immagini); nelle edizioni precedenti la directory public si chiamava web e il file index.php era app.php;

src contiene i file su cui lavorerete di più, perché sono quelli che contengono il codice che determina il comportamento dell’applicazione; in pratica contiene parti del codice corrispondente ai componenti Controller e Model del pattern MVC;

templates contiene le viste, che come intuirete costituiscono il componente View;

var contiene i file di log e di cache;

vendor tecnicamente non c’entra con Symfony, ma con Composer, il gestore di pacchetti che ormai è uno strumento essenziale per questo framework. In sostanza questa directory contiene le dipendenze del progetto, come i Symfony Components, di cui abbiamo parlato nell’articolo introduttivo.

Rispetto alle edizioni precedenti, concettualmente non è cambiato molto, ma seppure Symfony 4 abbia riorganizzato leggermente il filesystem, secondo me il miglioramento è stato enorme. Il concetto di bundle è stato ridimensionato e ogni file si trova nel punto più “naturale”.

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 HTTP, contenente la pagina HTML che visualizzate sullo schermo.

Symfony, come molti altri framework MVC, si basa sul modello del front controller, ovvero un punto centralizzato da cui passa ogni richiesta HTTP, indipendentemente dalla URL. Come dicevamo precedentemente, il ruolo di front controller è assunto dal file public/index.php. In Symfony, l’operazione principale che compie index.php è creare un’istanza di Kernel (src/kernel.php), il nucleo del framework, che si occupa di caricare i package che fanno parte del progetto.

A questo punto la richiesta contenente la rotta (ossia il percorso specificato nella URL) viene passata all’oggetto Kernel, esaminata e infine viene richiamata l’opportuna sezione di codice, detta action, atta a soddisfare il task richiesto.

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.

L'autore

Ciao, sono Antonio D'Amore, e sono un ingegnere informatico con la forte passione per il web. Sguazzo nell'ambiente startup, grazie a Tobevy, di cui sono co-founder e CTO, e adoro la divulgazione, ragion per cui ho creato questo blog