Symfony : – Création des entités

Doctrine facilite la gestion des bases de données relationnelles en permettant de manipuler des entités PHP au lieu d’écrire directement des requêtes SQL. Cet article détaille la création des entités et leur configuration (ou mapping) pour une utilisation optimale avec Doctrine.

Conception des Entités

Exemple de classe d’entité

Prenons l’exemple d’une application qui gère des livres, chaque livre ayant un id, un titre, et une date de parution. Voici une entité définissant ces propriétés :

namespace App\Entity;

class Livre
{
    private $id;
    private $titre;
    private $dateParution;

    public function getId(): ?int
    {
        return $this->id;
    }

    public function setTitre(?string $titre): self
    {
        $this->titre = $titre;
        return $this;
    }

    public function getTitre(): ?string
    {
        return $this->titre;
    }

    public function setDateParution(?\DateTimeInterface $dateParution): self
    {
        $this->dateParution = $dateParution;
        return $this;
    }

    public function getDateParution(): ?\DateTimeInterface
    {
        return $this->dateParution;
    }
}

Points importants :

1. Propriétés privées : Les propriétés des entités doivent toujours être privées ou protégées, jamais publiques.
2. Accesseurs et mutateurs (getters/setters) : Ces méthodes permettent d’accéder aux données ou de les modifier, tout en respectant les principes d’encapsulation.

Syntaxes pour le Mapping des Entités

Le mapping consiste à associer une classe PHP (entité) à une table de base de données, ainsi que ses propriétés aux colonnes de cette table. Doctrine prend en charge plusieurs formats pour le mapping :

• Annotations
• Attributs PHP (par défaut avec Symfony 6+)
• Fichiers YAML
• Fichiers XML

Exemple de mapping avec les attributs PHP

Les attributs PHP sont intégrés directement dans le code et permettent une configuration claire et rapide :

namespace App\Entity;

use Doctrine\ORM\Mapping as ORM;
use Doctrine\DBAL\Types\Types;

#[ORM\Entity]
#[ORM\Table(name: 'livre')]
class Livre
{
    #[ORM\Id]
    #[ORM\GeneratedValue]
    #[ORM\Column(type: Types::INTEGER)]
    private ?int $id = null;

    #[ORM\Column(type: Types::STRING, length: 255)]
    private ?string $titre = null;

    #[ORM\Column(type: Types::DATE_MUTABLE, nullable: true)]
    private ?\DateTimeInterface $dateParution = null;
}

Commande pour synchroniser le schéma

Une fois les entités créées et mappées, synchronisez votre base de données avec la commande :

php bin/console doctrine:schema:update --force

Pour afficher les requêtes SQL générées sans appliquer les modifications :

php bin/console doctrine:schema:update --dump-sql

Le Mapping des Entités Simples

a) Attribut #[ORM\Entity]

Cet attribut marque une classe comme une entité utilisable par Doctrine. Exemple :

#[ORM\Entity]
class MonEntite
{
    // ...
}

b) Attribut #[ORM\Column]

Configure une propriété pour qu’elle soit associée à une colonne de la table :

#[ORM\Column(type: Types::STRING, length: 255, nullable: true)]
private ?string $nom = null;

Propriétés courantes de #[ORM\Column] :

• type : Type de données (ex. Types::STRING, Types::DATE).
• length : Longueur pour les colonnes de type STRING.
• nullable : Autorise les valeurs NULL.
• unique : Crée un index unique sur la colonne.

c) Attribut #[ORM\Table]

Permet de configurer des options liées à la table, comme son nom :

#[ORM\Table(name: 'membre')]
class Utilisateur
{
    // ...
}

d) Clés Primaires

Une clé primaire se configure avec l’attribut #[ORM\Id]. Si la base doit générer automatiquement la valeur de cette clé, utilisez également #[ORM\GeneratedValue] :

#[ORM\Id]
#[ORM\GeneratedValue]
#[ORM\Column(type: Types::INTEGER)]
private ?int $id = null;

e) Index et Contraintes Uniques

• Pour créer un index simple ou multi-colonnes :

  #[ORM\Table(name: 'ma_table')]
  #[ORM\Index(name: 'multi_idx', columns: ['col_1', 'col_2'])]
  class MonEntite { /* ... */ }
  

• Pour créer une contrainte unique multi-colonnes :

  #[ORM\Table(name: 'membre')]
  #[ORM\UniqueConstraint(name: 'uniq', columns: ['nom', 'prenom'])]
  class Utilisateur { /* ... */ }
  

Mapping des Relations (Clés Étrangères)

Les relations entre entités s’appuient sur leur cardinalité :

• 1-1 : Une entité A correspond à une entité B.
• 1-n : Une entité B est associée à plusieurs entités A.
• n-n : Plusieurs entités A sont associées à plusieurs entités B.

a) Relation #[ORM\OneToOne] (1-1)

#[ORM\OneToOne(targetEntity: 'Auteur')]
#[ORM\JoinColumn(name: 'auteur_id', referencedColumnName: 'id')]
private ?Auteur $auteur = null;

b) Relation #[ORM\ManyToOne] (n-1)

#[ORM\ManyToOne(targetEntity: 'App\Entity\Livre')]
private ?Livre $livre = null;

c) Relation #[ORM\ManyToMany] (n-n)

#[ORM\ManyToMany(targetEntity: 'Theme')]
#[ORM\JoinTable(name: 'livre_theme')]
private Collection $themes;

Outils de la Console Symfony

Symfony fournit plusieurs commandes pour gérer les entités et leur mapping.

a) Vérifier le mapping

Validez le mapping des entités avec :

php bin/console doctrine:schema:validate

b) Générer le schéma

• Voir les requêtes SQL :

  php bin/console doctrine:schema:update --dump-sql
  

• Appliquer les modifications :

  php bin/console doctrine:schema:update --force
  

1. Documentation Symfony – Doctrine ORM
2. Documentation Doctrine ORM

Le mapping des entités est une étape essentielle pour structurer et gérer vos données avec Doctrine. Grâce à ses outils et à son intégration avec Symfony, Doctrine offre une méthode robuste pour définir, manipuler et synchroniser vos entités avec la base de données, tout en simplifiant le développement et la maintenance des applications web.