Comment travailler avec les relations polymorphes à Laravel

Les relations polymorphes dans Laravel permettent à un modèle de commentaire ou d'image d'appartenir à plusieurs modèles tels que la publication, la vidéo ou l'utilisateur en utilisant une seule association. 2. Le schéma de base de données nécessite des colonnes {relation} _id et {relation} _type, illustrées par commentable_id et commentable_type dans un tableau de commentaires, avec un index composite pour les performances. 3. Dans les modèles, utilisez Morphmany ou Morphone dans les modèles du propriétaire (par exemple, post) et Morphto dans le modèle polymorphe (par exemple, commentaire), correspondant au nom de la relation avec le préfixe de la colonne. 4. Lors de la création d'enregistrements, Laravel définit automatiquement l'ID et la classe dans les colonnes _ID et _TYPE, permettant la propriété dynamique. 5. Pour les cas un à un, utilisez Morphone et Morphto, comme une image appartenant à un utilisateur ou à un message. 6. Recherchez les relations polymorphes en utilisant par où ou direct où les clauses sur le type et l'identifiant, et utilisent avec («relation») avec les propriétaires de charge avides et empêchent N 1 requêtes. 7. Facultativement, définissez une carte Morph personnalisée dans AppServiceProvider pour stocker des alias de chaînes courts au lieu de noms de classe complets, améliorant la lisibilité et réduisant le stockage. Les relations polymorphes offrent un moyen flexible et efficace de partager des fonctionnalités entre les modèles, permettant des fonctionnalités réutilisables telles que des commentaires, des images ou des likes à travers divers types de modèles de manière transparente.

Travailler avec des relations polymorphes dans Laravel permet à un modèle d'appartenir à plus d'un autre modèle sur une seule association. Ceci est utile lorsque vous souhaitez une relation partagée sur plusieurs modèles - par exemple, la connexion de commentaires ou d'images à des publications, des vidéos ou des utilisateurs sans créer de tables séparées pour chacune.

Voici comment configurer et utiliser efficacement les relations polymorphes dans Laravel.

1. Comprendre les relations polymorphes

Une relation polymorphe permet à un modèle (comme Comment ou Image ) appartient à plusieurs autres modèles (comme Post , Video , User ) en utilisant une seule relation morphable.

Il existe deux types:

• Polymorphe un à un
• Polymorphe un-à-plusieurs

Par exemple:

• Un Comment peut appartenir à un Post ou à une Video .
• Une Image peut être attachée à un Product , User ou Article .

2. Configuration du schéma de base de données

Pour que cela fonctionne, vous avez besoin de deux colonnes dans votre table polymorphe:

• {model}_id - stocke l'ID du modèle connexe.
• {model}_type - stocke le nom de classe (entièrement qualifié) du modèle connexe.

Par exemple, pour un tableau comments :

 Schéma :: Create ('commentaires', fonction (tableau Blueprint $) {
    $ table-> id ();
    $ table-> text ('corps');
    $ table-> unsignedBigInteger ('commentable_id');
    $ table-> String ('commentable_type');
    $ Table-> TimeStamps ();

    $ table-> index (['commentable_id', 'commentable_type']);
});

Ici, commentable_id et commentable_type définissent ensemble quel modèle et enregistrer le commentaire appartient.

3. Définissez les modèles

Dans le modèle morphable (par exemple, post, vidéo)

Ces modèles peuvent avoir des commentaires. Vous définissez une relation morphMany .

 // post.php
Le poste de classe étend le modèle
{
    Commentaires de la fonction publique ()
    {
        retourner $ this-> morphmany (commentaire :: class, «commentable»);
    }
}

// video.php
La vidéo de classe étend le modèle
{
    Commentaires de la fonction publique ()
    {
        retourner $ this-> morphmany (commentaire :: class, «commentable»);
    }
}

Le deuxième argument de morphMany est le nom de la relation morph , qui devrait correspondre au préfixe de commentable_id et commentable_type .

Dans le modèle polymorphe (par exemple, commentaire)

Ce modèle appartient à un message ou à une vidéo.

 // comment.php
Le commentaire de classe étend le modèle
{
    fonction publique commentable ()
    {
        retourner $ this-> morphto ();
    }
}

La méthode morphTo() détecte automatiquement le propriétaire du commentaire basé sur commentable_type et commentable_id .

4. Utilisation de la relation

Créer un commentaire pour un message

 $ post = post :: find (1);
$ comment = $ post-> commentaires () -> créer ([[
    'corps' => 'super post!'
]));

Laravel définit automatiquement:

• commentable_id → 1
• commentable_type → App\Models\Post

Créer un commentaire pour une vidéo

 $ vidéo = vidéo :: find (2);
$ comment = $ video-> commentaires () -> créer ([[
    'corps' => 'belle vidéo!'
]));

Maintenant:

• commentable_id → 2
• commentable_type → App\Models\Video

Accéder au propriétaire

 $ comment = commentaire :: trouver (1);
$ propriétaire = $ comment-> commentable; // Renvoie le message ou l'instance vidéo

Laravel utilise le commentable_type pour déterminer la classe et charge le modèle correct.

5. Exemple polymorphe un à un

Dites qu'un User ou Post peut avoir une Image .

Migration

 Schéma :: Create ('Images', fonction (Table Blueprint $) {
    $ table-> id ();
    $ table-> String ('url');
    $ table-> unsignedBigInteger ('Imageable_id');
    $ Table-> String ('Imageable_Type');
    $ Table-> TimeStamps ();

    $ Table-> index (['Imageable_id', 'Imageable_Type']);
});

Modèles

 // image.php
L'image de classe étend le modèle
{
    fonction publique imagable ()
    {
        retourner $ this-> morphto ();
    }
}

// user.php
L'utilisateur de classe étend le modèle
{
    Image de fonction publique ()
    {
        return $ this-> morphone (image :: class, 'imagable');
    }
}

// post.php
Le poste de classe étend le modèle
{
    Image de fonction publique ()
    {
        return $ this-> morphone (image :: class, 'imagable');
    }
}

Usage

 $ user = user :: find (1);
$ user-> image () -> create (['url' => 'avatar.jpg']);

6. Interroger les relations polymorphes

Vous pouvez interroger en fonction du type Morph.

Obtenez tous les commentaires sur les messages

 $ commentaire = commentaire :: wherehas ('commentable', fonction ($ query) {
    $ query-> où ('commentable_type', post :: class);
}) -> get ();

Ou filtre directement sur le type:

 $ commentaire = commentaire :: où ('commentable_type', 'app \ modèles \ post')
    -> où ('commentable_id', 1)
    -> get ();

Chargement avide

Lors de la récupération des commentaires, vous pouvez charger les propriétaires:

 $ commentaire = commentaire :: avec ('commentable') -> get ();

foreach ($ commentaires comme $ comment) {
    echo $ comment-> commentable-> titre ?? $ comment-> commentable-> nom;
}

Cela évite n 1 requêtes.

7. Carte Morph personnalisée (facultative mais recommandée)

Par défaut, Laravel utilise le nom de classe entièrement qualifié dans la colonne *_type , qui peut être longue et cassante.

Vous pouvez définir une carte Morph personnalisée dans AppServiceProvider@boot :

 Utiliser illuminate \ database \ elogent \ relations \ relation;

Boot de fonction publique ()
{
    Relation :: morphmap ([[
        'post' => 'app \ modèles \ post',
        'video' => 'app \ modèles \ video',
        'utilisateur' => 'app \ modèles \ user',
    ]));
}

Maintenant, au lieu de stocker App\Models\Post , il stocke simplement post dans la colonne commentable_type .

⚠️ Si vous utilisez des cartes MORPH, assurez-vous de les enregistrer tôt (dans un fournisseur de services) et utilisez des clés cohérentes.

Résumé

Les relations polymorphes sont puissantes lorsque vous avez besoin d'associations flexibles. Points clés:

• Utilisez morphTo() dans le modèle polymorphe (par exemple, commentaire).
• Utilisez morphMany() ou morphOne() dans les modèles qui peuvent posséder le modèle polymorphe.
• Indexez toujours les colonnes {relation}_id et {relation}_type .
• Envisagez d'utiliser Relation::morphMap() pour garder les valeurs de type propre.
• Relations de charge impatientes pour éviter les problèmes de performances.

Avec cette configuration, vous pouvez créer des fonctionnalités réutilisables comme des commentaires, des goûts, des balises ou des médias qui fonctionnent sur plusieurs modèles de manière transparente.

Fondamentalement, c'est un moyen propre de dire «cette chose peut appartenir à de nombreux types de choses.»

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!