Doctrine 2 est un mapper objet-relationnel pour PHP 5.3.3+ qui fournis de la persistance transparente pour des objets PHP. La séparation complète de la logique et de la persistance dans un système de stockage relationnel est le but principale.

L'avantage de Doctrine pour un programmeur est de permettre un meilleur focus sur sur la logique objet orienté et de pouvoir considérer la persistance comme un problème secondaire.

Les fonctions clés de Doctrine 2 incluent :

• Prends en charge un grand nombre de base de données via le DBAL.
• Possibilité de reverse engineer une base de données existante en classes.
• Supporte les hooks et les événements à différentes étapes dans le code.
• Joins automatique sur les foreign keys.
• Polymorphisme sur une seule table avec une colonne pour le type.
• Possibilité d'utiliser un système de cache comme memcached, SQLite ou APC.
• Transactions ACID (Atomicité, Consistance, Isolation, Durabilité).
• Migrations de base de données.
• Possibilité de compiler plusieurs fichier PHP pour limiter le nombre d'inclusions et augmenter la performance.

En utilisant MySQLi :

$stmt = $mysqli->prepare('INSERT INTO users (username, password) VALUES (?, ?)');
$stmt->bind_param('s', $username);
$stmt->bind_param('s', $password);
$stmt->execute();
echo $mysqli->insert_id;

En utilisant Doctrine 2 :

$user = new User();
$user->username = $username;
$user->password = $password;
$entityManager->persist($user);
$entityManager->flush();
echo $user->id;

Doctrine utilise les commentaires pour permettre au programmeur d'attacher des méta-données aux membres d'une classe afin de contrôler la persistance.

/**
 * @Entity @Table(name="table")
 **/

Les principaux éléments sont:

• @Entity — Déclare que la classe qui suit est un entity.
• @Table — Contrôle les propriétés de la table qui accueillera l'entity.
• @Id — Détermine que la colonne est une clé primaire.
• @Column — Contrôle la colonne associé au membre de l'objet suivant.
• @GeneratedValue — Indique que la valeur du champ doit être générée automatiquement.

La propriété @Column est une des instructions les plus importantes. Elle comporte un grand nombre d'options :

• type — Le type de la colonne, beaucoup de type sont supportés.
• name — Le nom de la colonne.
• length — La longueur pour les string.
• unique — Si la valeur de la colonne doit être unique.
• nullable — Si la colonne peut être null.
• precision — Précision pour les nombres décimaux.
• scale — L'envergure pour les nombres décimaux.
• columnDefinition — Permet de fournir un morceaux de DDL manuel.
• options — Options passés au driver de base de données.

/**
 * @Entity @Table(name="users")
 **/
class User
{
    /** @Id @Column(type="integer") @GeneratedValue **/
    protected $id;
    /** @Column(type="string") **/
    protected $username;
    /** @Column(type="string") **/
    protected $password;

    // ...

Doctrine supporte tous les scénarios d'associations par l'utilisation de propriétés en commentaire.

• @OneToOne
• @OneToMany
• @ManyToOne
• @ManyToMany

Dans tous les cas, le paramètres targetEntity est nécessaire et dans les cas ou l'association est bidirectionnelle, mappedBy est nécessaire au propriétaire et inversedBy pour l'autre côté de l'association.

L'EntityManager est la pièce centrale qui permet d'accéder au système de persistance.

Une installation standard de Doctrine 2 va exposer une variable $entityManager ou similaire pour y permettre l'accès.

Les fonctions membres principales de l'EntityManager sont les suivantes :

• find('Entity', $id) — Raccourci pour trouver un entity par sa clé primaire.
• getRepository('Entity') — Récupère une Repository pour effectuer des requêtes sur l'entity désiré.
• persist($entity) — Enregistre l'entity en question dans la base de données.
• flush() — Exécute tous les opérations de persistance dans le buffer en attente. flush() doit être exécuté pour commettre les modifications dans la base de données.

L'EntityManager permet l'accès à un objet Repository pour effectuer des requêtes sur les entity en base de données.

$repo = $entityManager->getRepository('Entity');

L'objet expose les fonctions suivantes :

• findAll() — Récupère tous les entities.
• find($id) — Trouve un entity par son ID.
• findBy($condition) — Trouve tous les entities respectant la condition.
• findOneBy($condition) — Trouve un seul entity respectant la condition.
• findBy<ColumnName>($value) — Il existe une variante pour chaque colonne dans l'entity. Trouve tous les entities par la valeur d'une colonne.
• findOneBy<ColumnName>($value) — Il existe une variante pour chaque colonne dans l'entity. Trouve un entity par la valeur d'une colonne.

Un nouvel entity peut être persisté en base de données par l'EntityManager.

$gab = new Gab();
$gab->money = 31337;
$entityManager->persist($gab);
$entityManager->flush();

Les objets déja en base de données soit récupéré par un Repository ou précédemment persisté sont déjà lié à l'EntityManager et il suffit d'exécuter la méthode flush() pour sauvegarder les changements.

$repo = $entityManager->getRepository('Gab');
$gab = $repo->find(42);
$gab->money = 1337;
$entityManager->flush();

La structure et la nomenclature des fichiers joue un rôle très important dans tout projet PHP, mais particulièrement lorsqu'un framework est en jeu.

L'organisation typique d'un projet avec Doctrine 2 est la suivante :

• MonProjet/
  • public/
  • src/
    • Contient tous les entities.
  • vendor/
    • Contient toutes les dépendances installées par Composer.
  • bootstrap.php
  • cli-config.php
  • composer.json
  • index.php

Le fichier cli-config.php est utilisé par l'outil en ligne de commande pour identifier les entities et les paramètres de connexion.

use Doctrine\ORM\Tools\Console\ConsoleRunner;

require_once 'bootstrap.php';

return ConsoleRunner::createHelperSet($entityManager);

À ce stade, on peux générer la base de données à partir des entities en utilisant la ligne de commande.

$ cd MonProjet
$ php vendor/bin/doctrine orm:shema-tool:create

Comme dans l'exemple d'association, le projet fera usage de deux entity, soit un Post et un Comment.

Définition du Post :

• Id — int auto-increment
• Title — string
• Body — string
• Comments — Comment[]

Définition du Comment :

• Id — int auto-increment
• Body — string
• Post — Post

Un Post possède plusieurs Comment.