Comunicare con il database

Nelle precedenti lezioni abbiamo introdotto la funzione di login caricando i dati dell'utente in memoria. Come già anticipato non può essere considerata una soluzione accettabile per un'applicazione, era semplicemente una soluzione temporanea.

Nella realtà per memorizzare le informazioni degli utenti abbiamo bisogno di un database e di uno strumento che ci consenta di leggere e scrivere su di esso.

Quindi, per registrare un utente sulla nostra applicazione dobbiamo prima conoscere come Symfony si interfaccia al database e quali strumenti abbiamo a disposizione.

Tutte le operazioni che effettuiamo con il database, dalla connessione alle query di lettura, inserimento, ecc. avvengono grazie a Doctrine.

Doctrine

Il Doctrine Project consiste in una serie di librerie che consentono di gestire il database attraverso PHP. È composto principalmente da un Object Relational Mapper (ORM) a da un Database Abstraction Layer (DBAL).

La libreria DBAL consente di creare un livello di astrazione tra l'applicazione ed il database. Questo ci permette di avere la stessa interfaccia - e gli stessi metodi - indipendentemente dal tipo di database che si utilizza (MySQL, PostreSQL, Oracle..). Possiamo considerare DBAL come un'estensione della libreria PDO presente in PHP.

L'ORM è uno strumento che consente di creare un mapping tra la tabella nel database e una classe PHP. La mappatura permette di effettuare operazioni sul database e di mantenere contemporaneamente aggiornati gli oggetti. Il tutto in maniera automatica senza il bisogno di scrivere query manualmente. L'ORM fa ampio uso della libreria DBAL, possiamo infatti considerare l'accesso al database nascosto da diversi livelli di astrazione, come nell'immagine seguente:

Vediamo in concreto in cosa consiste persistere un oggetto sul database. Il codice che vedremo è a titolo esemplificativo, mancano alcuni passaggi importanti che vedremo non appena avremo configurato Doctrine sulla nostra applicazione per comunicare con il database.

class User
{
	private $id;
    private $username;
    private $password;
	//...getters e setters per i campi
}
$entityManager = $this->getDoctrine()->getManager();
$user = new User();
$user->setUsername('pippo');
$user->setPassword('password');
$entityManager->persist($user);
$entityManager->flush();

Il codice appena visto si converte, qualora usassimo un database MySQL, in una query simile alla seguente:

INSERT INTO users (username, password) VALUES ('pippo', 'password');

e, in caso di inserimento avvenuto con successo, con la proprietà User::$id che sarà popolata con l'id dell'utente. Il tutto in maniera del tutto indipendente dal database utilizzato e senza aver scritto nemmeno una riga di codice SQL.

L'Entity Manager

Nell'esempio possiamo notare l'utilizzo di un nuovo servizio: l'Entity Manager. Tale oggetto è considerato il più importante in Doctrine dato che ha la responsabilità di salvare e recuperare le informazioni dal database. Abbiamo quindi introdotto due metodi che ci accompagneranno sempre con Doctrine:

• persist() che prende in ingresso gli oggetti che devono essere salvati sul database. Tale metodo non esegue alcuna query ma semplicemente dice a Doctrine che quell'oggetto deve essere salvato sul database. È anche possibile richiamare il metodo su più oggetti prima di richiamare flush(),
• flush() si occupa di verificare che gli oggetti aggiunti attraverso persist() necessitino o meno di essere salvati. In questa fase viene anche verificato se l'oggetto esiste o meno nel database, nel caso fosse già presente verrà effettuato un UPDATE anziché un INSERT.