Symfony : - Création Des Entités | Conception Et Création De Sites Web

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 :

Propriétés privées : Les propriétés des entités doivent toujours être privées ou protégées, jamais publiques.
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





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


				
				
				
				
				
				
				
				
				
				
				
				
					 par admin4460