L’EntityManager est un élément central de Doctrine, permettant de gérer les interactions entre les entités de votre application Symfony et la base de données. Il facilite les opérations courantes telles que l’insertion, la modification, et la suppression de données, tout en offrant des mécanismes avancés comme la gestion des transactions et des opérations en cascade.
Table des matières : [Masquer]
Rôle
L’EntityManager gère le cycle de vie des entités, notamment :
- L’insertion de nouvelles entités.
- La mise à jour des entités existantes.
- La suppression des entités.
Contrairement à certaines bibliothèques ou frameworks, Doctrine ne synchronise pas automatiquement les modifications apportées aux entités avec la base de données. Vous devez explicitement indiquer les modifications à l’EntityManager pour qu’elles soient persistées.
Insertion de Données
Pour insérer une nouvelle ligne dans une table, procédez comme suit :
a) Créer une instance de l’entité
use App\Entity\Livre;
$livre = new Livre();
$livre->setTitre('La Ferme des Animaux');
$livre->setDateParution(new \DateTime('1945-08-17'));
b) Persist et Flush
$em = $container->get('doctrine')->getManager();
$em->persist($livre);
$em->flush();
Détails :
persist()
: Indique à Doctrine qu’une nouvelle entité doit être suivie.
flush()
: Envoie toutes les modifications accumulées vers la base de données.
Modification de Données
Étapes :
Récupérez l’entité cible à l’aide de son repository.
Modifiez ses propriétés avec les mutateurs (setters).
Appelez
persist()
et
flush()
.
Exemple :
public function modifierTitreLivre(int $idLivre, string $nouveauTitre)
{
$livre = $this->em->getRepository(Livre::class)->find($idLivre);
if ($livre) {
$livre->setTitre($nouveauTitre);
$this->em->persist($livre);
$this->em->flush();
}
}
Suppression de Données
Étapes :
Récupérez l’entité cible.
Appelez la méthode
remove()
de l’EntityManager.
Exécutez
flush()
.
Exemple :
public function supprimerLivre(int $idLivre)
{
$livre = $this->em->getRepository(Livre::class)->find($idLivre);
if ($livre) {
$this->em->remove($livre);
$this->em->flush();
}
}
Autres Opérations Disponibles avec l’EntityManager
a) refresh()
Met à jour une entité avec les données actuelles de la base de données.
$this->em->refresh($livre);
b) detach()
Détache une entité de l’EntityManager. Les modifications effectuées sur l’entité ne seront pas persistées.
$this->em->detach($livre);
Les Opérations en Cascade
Les relations entre entités peuvent entraîner des dépendances complexes, notamment lors des suppressions ou insertions. Doctrine permet de gérer ces dépendances via des opérations en cascade.
a) Opérations en Cascade au Niveau de la Base de Données
Dans une relation entre un Auteur et ses Livres, vous pouvez configurer une cascade pour que la suppression d’un Auteur entraîne la suppression de tous ses Livres :
#[ORM\ManyToOne(targetEntity: 'Auteur')]
#[ORM\JoinColumn(onDelete: 'CASCADE')]
private ?Auteur $auteur = null;
b) Opérations en Cascade avec Doctrine
Doctrine permet de définir des opérations en cascade au niveau applicatif. Par exemple, pour insérer plusieurs Livres pour un Auteur :
#[ORM\OneToMany(
targetEntity: 'Livre',
mappedBy: 'auteur',
cascade: ['persist', 'remove']
)]
private Collection $livres;
Avec cette configuration :
Les Livres d’un Auteur sont automatiquement persistés lorsque l’Auteur est persisté.
Ils sont également supprimés lorsque l’Auteur est supprimé.
Exemple d’insertion en cascade :
$auteur = new Auteur();
foreach (['Titre 1', 'Titre 2'] as $titre) {
$livre = new Livre();
$livre->setTitre($titre);
$auteur->addLivre($livre);
}
$this->em->persist($auteur);
$this->em->flush();
Exemple de suppression en cascade :
$auteur = $this->em->getRepository(Auteur::class)->find($idAuteur);
$this->em->remove($auteur);
$this->em->flush();
Commandes Utiles pour la Console Symfony
a) Valider le Mapping
Validez la configuration du mapping des entités avec :
php bin/console doctrine:schema:validate
b) Synchroniser la Base de Données
Afficher les requêtes nécessaires à la synchronisation :
php bin/console doctrine:schema:update --dump-sql
Appliquer les modifications à la base :
php bin/console doctrine:schema:update --force
Injecter l’EntityManager : Préférez l’injection de dépendances pour récupérer l’EntityManager dans vos services.
public function __construct(EntityManagerInterface $em)
{
$this->em = $em;
}
Limiter le
flush()
: Évitez d’exécuter
flush()
après chaque modification mineure. Regroupez les opérations pour améliorer les performances.
Gestion des transactions : Doctrine englobe automatiquement les requêtes dans des transactions, mais vous pouvez les gérer manuellement pour des cas spécifiques :
$this->em->beginTransaction();
try {
// Opérations multiples
$this->em->commit();
} catch (\Exception $e) {
$this->em->rollback();
throw $e;
}
Documentation Symfony - Doctrine ORM
Documentation Doctrine ORM
L’EntityManager est un outil puissant et central pour gérer les entités avec Doctrine. En maîtrisant ses fonctionnalités principales (persist, remove, flush, etc.) et avancées (cascade, transactions), vous pouvez gérer efficacement vos données tout en maintenant la cohérence et l’intégrité de votre base de données.