Symfony : – EntityManager

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.

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 :

1. Récupérez l’entité cible à l’aide de son repository.
2. Modifiez ses propriétés avec les mutateurs (setters).
3. 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 :

1. Récupérez l’entité cible.
2. Appelez la méthode remove() de l’EntityManager.
3. 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
  

 

1. 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;
   }
   

2. Limiter le flush() : Évitez d’exécuter flush() après chaque modification mineure. Regroupez les opérations pour améliorer les performances.
3. 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;
   }
   

1. Documentation Symfony – Doctrine ORM
2. 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.