Points de base

• L'association polymorphe de Laravel permet à un modèle d'appartenir à plusieurs autres modèles sur une association. Cela simplifie la structure de la base de données, rend le code plus facile à maintenir et permet des relations de données plus dynamiques et flexibles.
• La mise en place des associations polymorphes dans Laravel implique de définir les associations dans le modèle éloquent. La méthode morphTo est utilisée pour recevoir un modèle associé polymorphe, tandis que la méthode morphMany ou morphOne est utilisée pour un modèle associé à d'autres modèles.
• La méthode MorphMap de Laravel peut être utilisée pour instruire Eloquent d'utiliser un nom personnalisé au lieu d'un nom de classe pour chaque modèle. Ceci est utile en cas de modifications de l'espace de noms de modèle ou d'espaces de noms trop longs.
• Laravel prend en charge les relations polymorphes de plusieurs à plusieurs, permettant à un modèle d'appartenir à plusieurs modèles de plusieurs à plusieurs. Ceci est particulièrement utile dans des applications complexes.

Cet article a été évalué par des pairs par Younes Rafie. Merci à tous les pairs examinateurs de SitePoint pour rendre le contenu de SitePoint parfait!

Vous pouvez avoir utilisé différents types de relations entre les modèles ou les tables de base de données, tels que communs à Laravel: un à un, un-à-plusieurs, plusieurs à plusieurs et has-hauts. Mais il existe un autre type moins commun: association polymorphe. Alors, qu'est-ce que l'association polymorphe?

L'association polymorphe fait référence à un modèle qui peut appartenir à plusieurs autres modèles dans une association.

Pour illustrer cela, créons une scène fictive où nous avons des modèles de sujet et de publication. Les utilisateurs peuvent laisser des commentaires sur des sujets et des publications. En utilisant des relations polymorphes, nous pouvons utiliser un seul tableau de commentaires pour les deux cas. étonnamment, non? Cela semble un peu impraticable car, idéalement, nous devons créer la table Post_comments et la table topic_comments pour distinguer les commentaires. En utilisant des relations polymorphes, nous n'avons pas besoin de deux tables. Comprenons les relations polymorphes à travers un exemple pratique.

ce que nous allons construire

Nous allons créer une application de musique de démonstration qui contient des chansons et des albums. Dans cette application, nous pouvons aimer les chansons et les albums. En utilisant des relations polymorphes, nous utiliserons une seule table upvotes pour les deux cas. Tout d'abord, examinons la structure du tableau requise pour construire cette relation:

<code>albums
    id - integer
    name - string

songs
    id - integer
    title - string
    album_id - integer

upvotes
    id - integer
    upvoteable_id - integer
    upvoteable_type - string
</code>

Discutons des colonnes upvoteable_id et upvoteable_type, qui peuvent sembler un peu étranges à ceux qui n'ont pas utilisé de relations polymorphes auparavant. La colonne upvoteable_id contiendra la valeur d'ID de l'album ou de la chanson, tandis que la colonne upvoteable_type contiendra le nom de classe qui possède le modèle. La colonne upvoteable_type est de savoir comment l'ORM détermine quel "type" à retourner pour posséder le modèle lors de l'accès à la relation upvoteable.

générer des modèles et une migration

Je suppose que vous avez déjà une application Laravel en cours d'exécution. Sinon, ce cours avancé à démarrage rapide peut être utile. Créons d'abord trois modèles et migrations, puis modifions les migrations en fonction de nos besoins.

<code>albums
    id - integer
    name - string

songs
    id - integer
    title - string
    album_id - integer

upvotes
    id - integer
    upvoteable_id - integer
    upvoteable_type - string
</code>

Notez que le passage de l'indicateur -m lors de la création d'un modèle génère également des migrations associées à ces modèles. Ajustez les méthodes up de ces migrations pour obtenir la structure de la table souhaitée:

{some_timestamp}_create_albums_table.php

<code>php artisan make:model Album -m
php artisan make:model Song -m
php artisan make:model Upvote -m
</code>

{some_timestamp}_create_songs_table.php

public function up()
{
    Schema::create('albums', function (Blueprint $table) {
       $table->increments('id');
        $table->string('name');
        $table->timestamps();
    });
}

{some_timestamp}_create_upvotes_table.php

public function up()
{
    Schema::create('songs', function (Blueprint $table) {
        $table->increments('id');
        $table->string('title');
        $table->integer('album_id')->unsigned()->index();
        $table->timestamps();

        $table->foreign('album_id')->references('id')->on('albums')->onDelete('cascade');
    });
}

Maintenant, nous pouvons exécuter la commande Artisan Migrate pour créer ces trois tables:

public function up()
{
    Schema::create('upvotes', function (Blueprint $table) {
        $table->increments('id');
        $table->morphs('upvoteable'); // 添加無符號整數 upvoteable_id 和字符串 upvoteable_type
        $table->timestamps();
    });
}

Configurons notre modèle pour prêter attention à la relation polymorphe entre les albums, les chansons et les go?ts:

app/Upvote.php

<code>php artisan migrate</code>

app/Album.php

[...]
class Upvote extends Model
{
    /**
     * 獲取所有擁有模型。
     */
    public function upvoteable()
    {
        return $this->morphTo();
    }
}

app/Song.php

class Album extends Model
{
    protected $fillable = ['name'];

    public function songs()
    {
        return $this->hasMany(Song::class);
    }

    public function upvotes()
    {
        return $this->morphMany(Upvote::class, 'upvoteable');
    }
}

dans les modèles d'album et de chansons upvotes définit la relation polymorphe un à plusieurs entre ces modèles et le modèle Upvote et nous aidera à obtenir toutes les instances de modèle particulières.

Après avoir défini la relation, nous pouvons maintenant essayer l'application pour mieux comprendre comment fonctionnent les relations polymorphes. Nous ne créerons aucune vue pour cette application, nous n'essaierons que notre application à partir de la console.

Si vous considérez le contr?leur et où nous devons placer la méthode similaire, je suggère de créer un albumPvoteController et un SongupVoteController. De cette fa?on, lorsque nous traitons des relations polymorphes, nous pouvons strictement connecter les choses à l'objet sur lequel nous opérons. Dans notre cas, nous pouvons aimer l'album et la chanson. Les likes ne sont pas un album ou une chanson. De plus, ce n'est pas un général comme, ce qui est l'opposé de la fa?on dont nous avons un contr?leur upvotes dans la plupart des relations un-à-plusieurs. J'espère que cela a du sens.

Commen?ons la console:

class Song extends Model
{
    protected $fillable = ['title', 'album_id'];

    public function album()
    {
        return $this->belongsTo(Album::class);
    }

    public function upvotes()
    {
        return $this->morphMany(Upvote::class, 'upvoteable');
    }
}

Relation de récupération

Maintenant que nous avons des données prêtes, nous pouvons accéder à nos relations via notre modèle. Voici une capture d'écran des données dans le tableau UpVotes:

Pour accéder à tous les go?ts de l'album, nous pouvons utiliser upvotes Attribut dynamique:

<code>php artisan tinker
>>> $album = App\Album::create(['name' => 'More Life']);
>>> $song = App\Song::create(['title' => 'Free smoke', 'album_id' => 1]);
>>> $upvote1 = new App\Upvote;
>>> $upvote2 = new App\Upvote;
>>> $upvote3 = new App\Upvote;
>>> $album->upvotes()->save($upvote1);
>>> $song->upvotes()->save($upvote2);
>>> $album->upvotes()->save($upvote3);</code>

peut également récupérer le propriétaire d'une relation polymorphe du modèle polymorphe en accédant au nom de la méthode qui effectue l'appel à morphTo. Dans notre cas, c'est la méthode upvoteable sur le modèle upvote. Par conséquent, nous accéderons à la méthode en tant que propriété dynamique:

$album = App\Album::find(1);
$upvotes = $album->upvotes;
$upvotescount = $album->upvotes->count();

sur le modèle upvoteable upvote renverra une instance d'album, comme cela est la propriété de l'instance de l'instance de l'album.

Parce que nous pouvons obtenir le nombre de likes pour une chanson ou un album, nous pouvons trier la chanson ou l'album basé sur les go?ts sur la vue. C'est ainsi que fonctionnent les cartes de musique.

Pour les chansons, nous aurons des go?ts comme ceci:

<code>albums
    id - integer
    name - string

songs
    id - integer
    title - string
    album_id - integer

upvotes
    id - integer
    upvoteable_id - integer
    upvoteable_type - string
</code>

Type polymorphe personnalisé

Par défaut, Laravel utilisera des noms de classe entièrement qualifiés pour stocker les types du modèle pertinent. Par exemple, dans l'exemple ci-dessus, Upvote peut appartenir à l'album ou à la chanson, et la valeur par défaut upvoteable_type est respectivement App\Album ou App\Song.

Cependant, cela a un gros inconvénient. Et si l'espace de noms du modèle d'album change? Nous devrons faire une sorte de migration pour renommer toutes les occurrences dans le tableau Upvotes. C'est un peu délicat! Que se passe-t-il si l'espace de noms est long (par exemple App\Models\Data\Topics\Something\SomethingElse)? Cela signifie que nous devons définir une très longue longueur maximale sur la colonne. C'est là que la méthode MorphMap peut nous aider.

La méthode "Morphmap" demandera à Eloquent d'utiliser un nom personnalisé pour chaque modèle, pas le nom de classe:

<code>php artisan make:model Album -m
php artisan make:model Song -m
php artisan make:model Upvote -m
</code>

Nous pouvons enregistrer MorphMap dans la fonction de démarrage de l'approvider AppService, ou créer un fournisseur de services distinct. Pour que les nouvelles modifications prennent effet, nous devons exécuter la commande de blinde de compositeur Autoload. Alors maintenant, nous pouvons ajouter ce nouvel enregistrement comme:

public function up()
{
    Schema::create('albums', function (Blueprint $table) {
       $table->increments('id');
        $table->string('name');
        $table->timestamps();
    });
}

Il se comporte exactement de la même manière que l'exemple précédent.

Conclusion

Même si vous n'avez peut-être jamais rencontré de situation où vous devez utiliser des relations polymorphes, ce jour peut éventuellement arriver. L'avantage de l'utilisation de Laravel est que la gestion de cette situation est très facile et il ne faut pas faire de trucs d'association de modèles pour faire fonctionner les choses. Laravel soutient même les relations polymorphes de plusieurs à plusieurs. Vous pouvez en savoir plus ici.

J'espère que vous avez maintenant compris les relations polymorphes et ce qui peut être nécessaire pour ces types de relations. Un autre exemple légèrement plus avancé de relations polymorphes est ici. Si vous trouvez cela utile, veuillez le partager avec vos amis et n'oubliez pas de cliquer sur le bouton Like. N'hésitez pas à laisser vos pensées dans la section des commentaires ci-dessous!

FAQ sur les relations polymorphes d'Eloquent

Quels sont les avantages de l'utilisation des relations polymorphes à Laravel?

Les relations polymorphes dans Laravel fournissent un moyen flexible et efficace de traiter les données connexes entre différents modèles. Ils permettent à un modèle d'appartenir à plusieurs autres types de modèles dans une association. Cela signifie que vous pouvez avoir une seule liste d'identificateurs unique de toutes les données pertinentes quel que soit leur type. Cela peut simplifier considérablement votre structure de base de données et rendre votre code plus facile à maintenir. Il permet également des relations de données plus dynamiques et flexibles, qui sont particulièrement utiles dans des applications complexes.

Comment définir les relations polymorphes à Laravel?

La mise en place des relations polymorphes dans Laravel implique de définir des relations dans le modèle éloquent. Tout d'abord, vous devez définir la relation sur le modèle qui recevra la relation polymorphe. Cela se fait à l'aide de la méthode morphTo. Ensuite, sur le modèle qui sera associé aux autres modèles, utilisez la méthode morphMany ou morphOne en fonction de la question de savoir si la relation est un à plusieurs ou un à un.

Pouvez-vous fournir un exemple de relations polymorphes dans Laravel?

Bien s?r, considérons une plate-forme de blog où les publications et les utilisateurs peuvent avoir des commentaires. Dans ce cas, le modèle de commentaire aura une relation polymorphe avec le post et les modèles d'utilisateurs. Voici comment définir cette relation:

<code>albums
    id - integer
    name - string

songs
    id - integer
    title - string
    album_id - integer

upvotes
    id - integer
    upvoteable_id - integer
    upvoteable_type - string
</code>

Comment utiliser les relations polymorphes pour récupérer les enregistrements connexes?

Vous pouvez récupérer des enregistrements pertinents dans les relations polymorphes comme vous le feriez avec toute autre relation éloquente. Par exemple, si vous souhaitez récupérer tous les commentaires d'un post, vous pouvez le faire:

<code>php artisan make:model Album -m
php artisan make:model Song -m
php artisan make:model Upvote -m
</code>

Comment enregistrer des enregistrements connexes à l'aide de relations polymorphes?

Enregistrer les enregistrements connexes dans les relations polymorphes également similaires à d'autres relations éloquentes. Vous pouvez associer le modèle à l'aide de la méthode associate et enregistrer le modèle. Voici un exemple:

public function up()
{
    Schema::create('albums', function (Blueprint $table) {
       $table->increments('id');
        $table->string('name');
        $table->timestamps();
    });
}

Quels sont les cas d'utilisation courants pour les relations polymorphes?

Les relations polymorphes sont particulièrement utiles dans les situations où le modèle peut appartenir à plusieurs autres types de modèles. Certains cas d'utilisation courants incluent des commentaires qui peuvent appartenir aux publications et aux utilisateurs, aux balises qui peuvent être appliquées à plusieurs types de contenu, et des images ou des fichiers qui peuvent être joints à divers types d'entités.

Quelles sont les limites ou les inconvénients de l'utilisation de relations polymorphes?

Bien que les relations polymorphes offrent beaucoup de flexibilité, elles peuvent également être plus complexes et plus difficiles à mettre en place et à gérer que les relations éloquentes standard. Ils prennent également en charge toutes les caractéristiques des relations standard, telles que le désir de charger des contraintes.

Comment supprimer les enregistrements pertinents dans les relations polymorphes?

Vous pouvez utiliser la méthode delete sur la relation pour supprimer les enregistrements pertinents dans une relation polymorphe. Par exemple, pour supprimer tous les commentaires d'un post, vous pouvez le faire:

public function up()
{
    Schema::create('songs', function (Blueprint $table) {
        $table->increments('id');
        $table->string('title');
        $table->integer('album_id')->unsigned()->index();
        $table->timestamps();

        $table->foreign('album_id')->references('id')->on('albums')->onDelete('cascade');
    });
}

Puis-je utiliser des relations polymorphes avec des relations multiples à plusieurs?

Oui, Laravel prend en charge les relations polymorphes de plusieurs à plusieurs à travers les méthodes morphToMany et morphedByMany. Cela permet à un modèle d'appartenir à plusieurs modèles de plusieurs à plusieurs.

Comment gérer les relations polymorphes dans la migration de la base de données?

Dans une migration de base de données, vous ajoutez généralement deux colonnes au tableau qui recevra des relations polymorphes: l'une pour l'ID de modèle associé et l'autre pour le type de modèle associé. Laravel fournit une méthode pratique morphs pour ajouter ces colonnes:

public function up()
{
    Schema::create('upvotes', function (Blueprint $table) {
        $table->increments('id');
        $table->morphs('upvoteable'); // 添加無符號整數 upvoteable_id 和字符串 upvoteable_type
        $table->timestamps();
    });
}

Cela ajoute des colonnes commentable_id et commentable_type à la table.

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!