Utilisation de traits dans des entités de doctrine

Les plats clés

• Les traits, disponibles depuis PHP 5.4.0, fournissent un moyen de réutiliser le code en incluant un ensemble de méthodes au sein d'une autre classe, réduisant la répétition du code. Ils peuvent être utilisés en conjonction avec la doctrine ORM dans un environnement Symfony.
• Les traits ne doivent pas être confondus avec les interfaces. Alors qu'une interface est un contrat qui indique ce qu'un objet peut faire, un trait donne à l'objet la possibilité de le faire.
• Les traits peuvent être particulièrement utiles pour organiser l'architecture de la base de données et éviter la duplication de code. Par exemple, lors de la création d'entités d'articles et de commentaires qui nécessitent à la fois des champs «créé_at» et «updated_at», ces propriétés communes peuvent être incluses dans un trait pour éviter la répétition.
• Bien que les traits soient un excellent outil pour produire du code plus léger et plus flexible, ils ne doivent pas être surutilisés. Parfois, il peut être préférable de construire une implémentation de classe unique. Il est crucial de prendre suffisamment de temps pour concevoir correctement votre application.

Depuis PHP 5.4.0, PHP prend en charge une jolie façon de réutiliser le code appelé «traits» - un ensemble de méthodes que vous pouvez inclure dans une autre classe afin de ne pas vous répéter. Vous pouvez en savoir plus sur les traits dans les articles de point de point publiés précédemment: ici, ici et ici.

Aujourd'hui, je vais vous montrer comment ils peuvent être utilisés avec Doctrine Orm dans un environnement Symfony.

Bases sur les traits

<span><span><?php </span></span><span><span>trait ExampleTrait {
</span></span><span>    <span>public function sayHello() {
</span></span><span>        <span>echo "Hello";
</span></span><span>    <span>}
</span></span><span><span>}
</span></span><span>
</span><span><span>class A {
</span></span><span>    <span>use ExampleTrait;
</span></span><span><span>}
</span></span><span>
</span><span><span>class B {
</span></span><span>    <span>use ExampleTrait;
</span></span><span><span>}
</span></span><span>
</span><span><span>$one = new A();
</span></span><span><span>$one->sayHello();    /* return `Hello` */
</span></span><span>
</span><span><span>$two = new B();
</span></span><span><span>$two->sayHello();    /* return `Hello`, too */</span></span></span>

Comme nous pouvons le voir, une méthode de base sayhello () est déclarée à l'intérieur d'un trait implémenté par les classes A et B avec une instruction d'utilisation. Facile, non? Cet exemple est vraiment court mais il devrait vous donner les connaissances de base pour travailler avec les traits.

Si vous êtes intéressé par les traits, je vous recommande de lire la documentation officielle et les articles de point de site publiés précédemment ici, ici et ici, pour saisir pleinement le concept.
Permettez-moi de vous avertir du fait que beaucoup de gens ont tendance à ne pas voir de différence entre les traits et les interfaces. Voici une explication pragmatique:

Une interface est un contrat qui dit "cet objet est capable de faire cette chose", alors qu'un trait donne à l'objet la possibilité de faire la chose.

Pour une explication plus approfondie, n'hésitez pas à jeter un œil à ce post perspicace de Philip Brown, dont vient la citation précédente.

En ce qui concerne l'organisation de l'architecture de la base de données, il n'est pas rare de faire face à la duplication de code. Par exemple, supposons que nous devons développer l'application de blog habituelle. À un moment donné, il est probable que nous allons créer une entité d'article de base et probablement également une entité de commentaire.

Les deux entités bénéficieraient des champs Created_at et Updated_at (afin que nous puissions trier les résultats sur ces colonnes plus tard). Mais avant de creuser dans les traits, voyons comment nous pourrions construire ces entités en doctrine sans eux.

Étape 1: Créez les entités

entité de l'article

<span><span><?php </span></span><span><span>trait ExampleTrait {
</span></span><span>    <span>public function sayHello() {
</span></span><span>        <span>echo "Hello";
</span></span><span>    <span>}
</span></span><span><span>}
</span></span><span>
</span><span><span>class A {
</span></span><span>    <span>use ExampleTrait;
</span></span><span><span>}
</span></span><span>
</span><span><span>class B {
</span></span><span>    <span>use ExampleTrait;
</span></span><span><span>}
</span></span><span>
</span><span><span>$one = new A();
</span></span><span><span>$one->sayHello();    /* return `Hello` */
</span></span><span>
</span><span><span>$two = new B();
</span></span><span><span>$two->sayHello();    /* return `Hello`, too */</span></span></span>

Entité de commentaire

<span><span><?php </span></span><span><span>namespace Blog<span>\AppBundle\Entity</span>;
</span></span><span>
</span><span><span>use Doctrine<span>\ORM\Mapping</span> as ORM;
</span></span><span>
</span><span><span>/**
</span></span><span><span> * @ORM\Table(name="article")
</span></span><span><span> * @ORM\Entity(repositoryClass="Blog\AppBundle\Entity\ArticleRepository")
</span></span><span><span> */
</span></span><span><span>class Article
</span></span><span><span>{
</span></span><span>    <span>/**
</span></span><span><span>     * @ORM\Column(name="idArticle" type="integer")
</span></span><span><span>     * @ORM\Id()
</span></span><span><span>     * @ORM\GeneratedValue(strategy="AUTO")
</span></span><span><span>     */
</span></span><span>    <span>private $id;
</span></span><span>
</span><span>    <span>/* Other properties you need in your entity: $title, $content, $author...  */
</span></span><span>
</span><span>    <span>/** @ORM\Column(name="created_at" type="datetime") */
</span></span><span>    <span>private $createdAt;
</span></span><span>
</span><span>    <span>/** @ORM\Column(name="updated_at" type="datetime") */
</span></span><span>    <span>private $updatedAt;
</span></span><span>
</span><span>   <span>/* Getters & Setters */
</span></span><span><span>}</span></span></span>

Les mêmes propriétés $ CreateDat et $ updatedat sont incluses dans les deux classes. C'est loin d'être sec. Les traits pourraient-ils nous aider à nettoyer ce code?

Étape 2: Créez le trait

<span><span><?php </span></span><span><span>namespace Blog<span>\AppBundle\Entity</span>;
</span></span><span>
</span><span><span>use Doctrine<span>\ORM\Mapping</span> as ORM;
</span></span><span>
</span><span><span>/**
</span></span><span><span> * @ORM\Table(name="comment")
</span></span><span><span> * @ORM\Entity(repositoryClass="Blog\AppBundle\Entity\CommentRepository")
</span></span><span><span> */
</span></span><span><span>class Comment
</span></span><span><span>{
</span></span><span>    <span>/**
</span></span><span><span>     * @ORM\Column(name="idComment" type="integer")
</span></span><span><span>     * @ORM\Id()
</span></span><span><span>     * @ORM\GeneratedValue(strategy="AUTO")
</span></span><span><span>     */
</span></span><span>    <span>private $id;
</span></span><span>
</span><span>    <span>/* Other properties you need in your entity */
</span></span><span>
</span><span>    <span>/** @ORM\Column(name="created_at" type="datetime") */
</span></span><span>    <span>private $createdAt;
</span></span><span>
</span><span>    <span>/** @ORM\Column(name="updated_at" type="datetime") */
</span></span><span>    <span>private $updatedAt;
</span></span><span>
</span><span>    <span>/* Getters & Setters */
</span></span><span><span>}</span></span></span>

Voici un joli fichier de trait dans lequel nous avons déplacé le code dupliqué initial. $ CreateDat et $ updatedat ainsi que toutes les méthodes associées sont désormais séparées des entités. En conséquence, il sera beaucoup plus facile de les utiliser ailleurs. N'oubliez pas la section d'introduction avec l'utilisation des mots clés.

Étape 3: Refactor les entités

entité de l'article

<span><span><?php </span></span><span><span>// src/Blog/AppBundle/Entity/Traits/TimestampableTrait.php
</span></span><span>
</span><span><span>namespace Blog<span>\AppBundle\Entity\Traits</span>;
</span></span><span>
</span><span><span>use Doctrine<span>\ORM\Mapping</span> as ORM;
</span></span><span>
</span><span><span>trait TimestampableTrait
</span></span><span><span>{
</span></span><span>    <span>/**
</span></span><span><span>     * <span>@var datetime $createdAt
</span></span></span><span><span>     *
</span></span><span><span>     * @ORM\Column(name="created_at", type="datetime")
</span></span><span><span>     */
</span></span><span>    <span>private $createdAt;
</span></span><span>
</span><span>    <span>/**
</span></span><span><span>     * <span>@var datetime $updatedAt
</span></span></span><span><span>     *
</span></span><span><span>     * @ORM\Column(name="updated_at", type="datetime")
</span></span><span><span>     */
</span></span><span>    <span>private $updatedAt;
</span></span><span>
</span><span>
</span><span>    <span>/**
</span></span><span><span>     * Get createdAt
</span></span><span><span>     *
</span></span><span><span>     * <span>@return datetime
</span></span></span><span><span>     */
</span></span><span>    <span>public function getCreatedAt()
</span></span><span>    <span>{
</span></span><span>        <span>return $this->createdAt;
</span></span><span>    <span>}
</span></span><span>
</span><span>    <span>/**
</span></span><span><span>     * Set createdAt
</span></span><span><span>     *
</span></span><span><span>     * <span>@param datetime $createdAt
</span></span></span><span><span>     */
</span></span><span>    <span>public function setCreatedAt($createdAt)
</span></span><span>    <span>{
</span></span><span>        <span>$this->createdAt = $createdAt;
</span></span><span>
</span><span>        <span>return $this;
</span></span><span>    <span>}
</span></span><span>
</span><span>    <span>/**
</span></span><span><span>     * Get updatedAt
</span></span><span><span>     *
</span></span><span><span>     * <span>@return datetime
</span></span></span><span><span>     */
</span></span><span>    <span>public function getUpdatedAt()
</span></span><span>    <span>{
</span></span><span>        <span>return $this->updatedAt;
</span></span><span>    <span>}
</span></span><span>
</span><span>    <span>/**
</span></span><span><span>     * Set updatedAt
</span></span><span><span>     *
</span></span><span><span>     * <span>@param datetime $updatedAt
</span></span></span><span><span>     */
</span></span><span>    <span>public function setUpdatedAt($updatedAt)
</span></span><span>    <span>{
</span></span><span>        <span>$this->updatedAt = $updatedAt;
</span></span><span>
</span><span>        <span>return $this;
</span></span><span>    <span>}
</span></span><span><span>}</span></span></span>

Entité de commentaire

<span><span><?php </span></span><span><span>// src/Blog/AppBundle/Entity/Article.php
</span></span><span>
</span><span><span>namespace Blog<span>\AppBundle\Entity</span>;
</span></span><span>
</span><span><span>use Doctrine<span>\ORM\Mapping</span> as ORM;
</span></span><span><span>use Blog<span>\AppBundle\Entity\Traits\TimestampableTrait</span>;
</span></span><span>
</span><span><span>class Article
</span></span><span><span>{
</span></span><span>    <span>use TimestampableTrait;
</span></span><span>
</span><span>    <span>/**
</span></span><span><span>     * @ORM\Column(name="idArticle" type="integer")
</span></span><span><span>     * @ORM\Id()
</span></span><span><span>     * @ORM\GeneratedValue(strategy="AUTO")
</span></span><span><span>     */
</span></span><span>    <span>private $id;
</span></span><span>
</span><span>    <span>/* Other properties you need in your entity */
</span></span><span>
</span><span>    <span>/* Getters & Setters */
</span></span><span><span>}</span></span></span>

fait! Jouons avec la ligne de commande. Tout d'abord, créons les entités de notre base de données:

<span><span><?php </span></span><span><span>// src/Blog/AppBundle/Entity/Comment.php
</span></span><span>
</span><span><span>namespace Blog<span>\AppBundle\Entity</span>;
</span></span><span>
</span><span><span>use Doctrine<span>\ORM\Mapping</span> as ORM;
</span></span><span><span>use Blog<span>\AppBundle\Entity\Traits\TimestampableTrait</span>;
</span></span><span>
</span><span><span>/**
</span></span><span><span> * @ORM\Table(name="comment")
</span></span><span><span> * @ORM\Entity(repositoryClass="Blog\AppBundle\Entity\CommentRepository")
</span></span><span><span> */
</span></span><span><span>class Comment
</span></span><span><span>{
</span></span><span>    <span>use TimestampableTrait;
</span></span><span>
</span><span>    <span>/**
</span></span><span><span>     * @ORM\Column(name="idComment" type="integer")
</span></span><span><span>     * @ORM\Id()
</span></span><span><span>     * @ORM\GeneratedValue(strategy="AUTO")
</span></span><span><span>     */
</span></span><span>    <span>private $id;
</span></span><span>
</span><span>    <span>/* Other properties you need in your entity */
</span></span><span>
</span><span>    <span>/* Getters & Setters */
</span></span><span><span>}</span></span></span>

Cette commande céderait:

php app/console doctrine:schema:create

Maintenant, si vous souhaitez créer de nouveaux objets à partir de ces classes, vous constateriez qu'ils ont tous les deux les méthodes communes disponibles:

`Article Entity`
	
	| idArticle | *All our other fields...* | created_at | updated_at |
	|-----------|---------------------------|------------|------------|
	
	`Comment Entity`
	
	| idComment | *All our other fields...* | created_at | updated_at |
	|-----------|---------------------------|------------|------------|

Évidemment, nous sommes maintenant prêts à persister les données.

aller plus loin

Actuellement, dans la sphère Symfony, de nombreux faisceaux et extensions ont tendance à s'en tenir à cette façon de faire les choses. La bibliothèque DoctrineBehaviors de Knplabs offre une grande collection de traits pour les entités et les référentiels. Dans le même état d'esprit, je vous recommande d'avoir un aperçu approfondi du bundle de doctrine de doctrine bien connu et surtout de tout sur l'extension du comportement horodomagie.

Réflexions finales

Les traits ne sont pas difficiles à absorber. Ils sont un excellent moyen de produire du code plus léger et plus flexible. Faites attention à ne pas les abuser: Parfois, il est préférable de construire une mise en œuvre unique de classe. Je ne peux pas insister suffisamment à quel point il est crucial de prendre suffisamment de temps pour concevoir correctement votre application. Essayez-les si vous pensez qu'ils pourraient vous aider. Créez le vôtre, testez-les et dites-nous comment vous les avez utilisés!

Questions fréquemment posées (FAQ) sur l'utilisation des traits dans les entités de doctrine

Quels sont les avantages de l'utilisation des traits dans les entités de doctrine?

Les traits dans les entités de doctrine fournissent un moyen de réutiliser le code dans des langues comme PHP qui ne prennent pas en charge les héritances multiples. Ils vous permettent de créer des extraits de code réutilisables qui peuvent être insérés dans différentes classes pour fournir des fonctionnalités supplémentaires. Cela peut conduire à un code plus propre et plus maintenable, car vous pouvez éviter de dupliquer le code sur plusieurs classes. Les traits peuvent également être utilisés pour remplacer les méthodes dans les classes dans lesquelles ils sont utilisés, fournissant un outil puissant pour modifier le comportement de manière flexible.

Comment utiliser les traits dans les entités de doctrine?

Pour utiliser un trait dans une entité de doctrine, vous devez d'abord définir le trait. Cela se fait à l'aide du mot clé du trait, suivi du nom du trait et d'un bloc de code contenant les méthodes et les propriétés fournies par le trait. Une fois le trait défini, vous pouvez l'utiliser dans une classe en ajoutant une instruction d'utilisation dans la définition de la classe, suivie du nom du trait. Cela rendra toutes les méthodes et propriétés du trait disponibles dans la classe.

Puis-je utiliser plusieurs traits dans une seule entité de doctrine?

Oui, vous pouvez utiliser plusieurs traits dans une seule doctrine entité. Cela se fait en ajoutant plusieurs instructions d'utilisation à l'intérieur de la définition de classe, chacune suivie du nom d'un trait différent. Les méthodes et propriétés de tous les traits seront disponibles dans la classe. S'il y a un conflit de dénomination entre les méthodes ou les propriétés dans différents traits, vous pouvez le résoudre en utilisant la place de la place et en tant qu'opérateurs.

Les traits peuvent-ils avoir des services injectés?

Les traits eux-mêmes ne peuvent pas avoir des services injectés directement , car ce ne sont pas des classes et ne soutiennent pas l'injection de constructeur. Cependant, vous pouvez injecter des services dans les classes qui utilisent les traits. Les méthodes du trait peuvent ensuite accéder à ces services via la classe.

Les traits peuvent-ils remplacer les méthodes dans des entités de doctrine?

Oui, les traits peuvent remplacer les méthodes dans les classes dans lesquelles ils sont utilisés. C'est. fait en définissant une méthode dans le trait avec le même nom qu'une méthode dans la classe. Lorsque la méthode est appelée sur un objet de la classe, la version du trait sera utilisée à la place de la version de la classe.

Puis-je utiliser des traits en conjonction avec l'héritage?

Oui , vous pouvez utiliser des traits conjointement avec l'héritage. Une classe peut hériter d'une classe parent et utiliser également un ou plusieurs traits. Les méthodes et propriétés de la classe parent et les traits seront tous disponibles dans la classe. S'il y a un conflit de dénomination entre les méthodes ou les propriétés dans la classe parent et un trait, la version dans le trait sera utilisée.

Y a-t-il des limitations ou des inconvénients à l'utilisation de traits?

Alors que Les traits fournissent un outil puissant pour la réutilisation et la flexibilité du code, ils ont également certaines limites et des inconvénients potentiels. Une limitation est que les traits ne peuvent pas être instanciés seuls - ils ne peuvent être utilisés que dans une classe. De plus, si plusieurs traits définissent une méthode avec le même nom, il peut y avoir des conflits qui doivent être résolus manuellement. La surutilisation des traits peut également conduire à un code difficile à comprendre et à entretenir, ils doivent donc être utilisés judicieusement.

Comment tester les entités de doctrine qui utilisent des traits?

Tester les entités de doctrine qui utilisent des traits similaires à tester des entités de doctrine régulières. Vous pouvez créer des tests unitaires qui instancent l'entité et appeler ses méthodes, vérifiant qu'ils se comportent comme prévu. Si un trait fournit des méthodes supplémentaires, vous pouvez les tester de la même manière. Si un trait remplace une méthode dans l'entité, vous devez tester à la fois la version d'origine de la méthode (en la testant sur une entité qui n'utilise pas le trait) et la version remplacée (en la testant sur une entité qui utilise le trait) .

Puis-je utiliser des traits dans des entités de doctrine avec Symfony?

Oui, vous pouvez utiliser des traits dans des entités de doctrine avec Symfony. L'intégration de la doctrine de Symfony soutient l'utilisation des traits dans les entités. Vous pouvez définir vos traits, les utiliser dans vos entités, et Symfony les reconnaîtra et les utilisera lorsque vous travaillez avec vos entités.

Comment déboguer les problèmes avec les traits dans les entités de doctrine?

Problèmes de débogage avec les traits dans les entités de doctrine est similaire aux problèmes de débogage avec des entités de doctrine régulières. Vous pouvez utiliser des outils comme xdebug et var_dump () pour inspecter l'état de vos entités et voir quelles méthodes et propriétés ils ont. Si une méthode ne se comporte pas comme prévu, vous pouvez vérifier si elle est définie dans l'entité elle-même, dans un trait ou dans une classe parentale, et déboguer en conséquence.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!