Maîtrisez les relations entre modèles Eloquent dans Laravel 11.x

Introduction

Les relations Eloquent : fondamentales pour une gestion efficace des données
Nouveautés et améliorations dans Laravel 11.x
Objectif : comprendre et implémenter les différents types de relations

One-to-One Relation

Définition : Un modèle est associé à un seul autre modèle.
Exemple : Un utilisateur a un seul profil détaillé.
Méthodes Eloquent : hasOne(), belongsTo()

Code :

 1// Dans le modèle User
 2public function profile()
 3{
 4    return $this->hasOne(Profile::class);
 5}
 6 
 7// Dans le modèle Profile
 8public function user()
 9{
10    return $this->belongsTo(User::class);
11}
12 
13// Utilisation
14$user = User::find(1);
15$profile = $user->profile; 1// Dans le modèle User
 2public function profile()
 3{
 4    return $this->hasOne(Profile::class);
 5}
 6 
 7// Dans le modèle Profile
 8public function user()
 9{
10    return $this->belongsTo(User::class);
11}
12 
13// Utilisation
14$user = User::find(1);
15$profile = $user->profile;

One-to-Many Relation

Définition : Un modèle peut avoir plusieurs modèles associés.
Exemple : Un auteur peut avoir écrit plusieurs livres.
Méthodes Eloquent : hasMany(), belongsTo()

Code :

 1// Dans le modèle Author
 2public function books()
 3{
 4    return $this->hasMany(Book::class);
 5}
 6 
 7// Dans le modèle Book
 8public function author()
 9{
10    return $this->belongsTo(Author::class);
11}
12 
13// Utilisation
14$author = Author::find(1);
15$books = $author->books;
16 
17foreach ($books as $book) {
18    echo $book->title;
19} 1// Dans le modèle Author
 2public function books()
 3{
 4    return $this->hasMany(Book::class);
 5}
 6 
 7// Dans le modèle Book
 8public function author()
 9{
10    return $this->belongsTo(Author::class);
11}
12 
13// Utilisation
14$author = Author::find(1);
15$books = $author->books;
16 
17foreach ($books as $book) {
18    echo $book->title;
19}

Many-to-Many Relation

Définition : Plusieurs modèles peuvent être associés à plusieurs autres modèles.
Exemple : Un étudiant peut s'inscrire à plusieurs cours, et un cours peut avoir plusieurs étudiants.
Méthodes Eloquent : belongsToMany()

Code :

 1// Dans le modèle Student
 2public function courses()
 3{
 4    return $this->belongsToMany(Course::class);
 5}
 6 
 7// Dans le modèle Course
 8public function students()
 9{
10    return $this->belongsToMany(Student::class);
11}
12 
13// Utilisation
14$student = Student::find(1);
15$courses = $student->courses;
16 
17// Ajouter un étudiant à un cours
18$course = Course::find(1);
19$course->students()->attach($student->id); 1// Dans le modèle Student
 2public function courses()
 3{
 4    return $this->belongsToMany(Course::class);
 5}
 6 
 7// Dans le modèle Course
 8public function students()
 9{
10    return $this->belongsToMany(Student::class);
11}
12 
13// Utilisation
14$student = Student::find(1);
15$courses = $student->courses;
16 
17// Ajouter un étudiant à un cours
18$course = Course::find(1);
19$course->students()->attach($student->id);

Has-One-Through Relation

Définition : Un modèle est relié à un autre via un modèle intermédiaire.
Exemple : Un pays a une capitale via une ville.
Méthodes Eloquent : hasOneThrough()

Code :

 1// Dans le modèle Country
 2public function capital()
 3{
 4    return $this->hasOneThrough(
 5        Capital::class,
 6        City::class,
 7        'country_id', // Clé étrangère sur City
 8        'city_id',    // Clé étrangère sur Capital
 9        'id',         // Clé locale sur Country
10        'id'          // Clé locale sur City
11    );
12}
13 
14// Utilisation
15$country = Country::find(1);
16$capital = $country->capital; 1// Dans le modèle Country
 2public function capital()
 3{
 4    return $this->hasOneThrough(
 5        Capital::class,
 6        City::class,
 7        'country_id', // Clé étrangère sur City
 8        'city_id',    // Clé étrangère sur Capital
 9        'id',         // Clé locale sur Country
10        'id'          // Clé locale sur City
11    );
12}
13 
14// Utilisation
15$country = Country::find(1);
16$capital = $country->capital;

Has-Many-Through Relation

Définition : Un modèle est relié à plusieurs autres via un modèle intermédiaire.
Exemple : Un médecin a plusieurs patients via des rendez-vous.
Méthodes Eloquent : hasManyThrough()

Code :

 1// Dans le modèle Doctor
 2public function patients()
 3{
 4    return $this->hasManyThrough(
 5        Patient::class,
 6        Appointment::class,
 7        'doctor_id',  // Clé étrangère sur Appointment
 8        'id',         // Clé étrangère sur Patient
 9        'id',         // Clé locale sur Doctor
10        'patient_id'  // Clé locale sur Appointment
11    );
12}
13 
14// Utilisation
15$doctor = Doctor::find(1);
16$patients = $doctor->patients; 1// Dans le modèle Doctor
 2public function patients()
 3{
 4    return $this->hasManyThrough(
 5        Patient::class,
 6        Appointment::class,
 7        'doctor_id',  // Clé étrangère sur Appointment
 8        'id',         // Clé étrangère sur Patient
 9        'id',         // Clé locale sur Doctor
10        'patient_id'  // Clé locale sur Appointment
11    );
12}
13 
14// Utilisation
15$doctor = Doctor::find(1);
16$patients = $doctor->patients;

Polymorphic Relations

Définition : Un modèle peut appartenir à plus d'un type de modèle.
Exemple : Un commentaire peut être associé à un post ou à une vidéo.
Méthodes Eloquent : morphTo(), morphMany(), morphToMany()

Code :

 1// Dans le modèle Comment
 2public function commentable()
 3{
 4    return $this->morphTo();
 5}
 6 
 7// Dans les modèles Post et Video
 8public function comments()
 9{
10    return $this->morphMany(Comment::class, 'commentable');
11}
12 
13// Utilisation
14$post = Post::find(1);
15$comments = $post->comments;
16 
17$video = Video::find(1);
18$videoComments = $video->comments; 1// Dans le modèle Comment
 2public function commentable()
 3{
 4    return $this->morphTo();
 5}
 6 
 7// Dans les modèles Post et Video
 8public function comments()
 9{
10    return $this->morphMany(Comment::class, 'commentable');
11}
12 
13// Utilisation
14$post = Post::find(1);
15$comments = $post->comments;
16 
17$video = Video::find(1);
18$videoComments = $video->comments;

Eager Loading

Définition : Chargement anticipé des relations pour éviter le problème N+1.
Exemple : Charger tous les posts avec leurs auteurs.
Méthodes Eloquent : with(), load()

Code :

 1// Eager loading lors de la requête
 2$posts = Post::with('author')->get();
 3 
 4foreach ($posts as $post) {
 5    echo $post->author->name;
 6}
 7 
 8// Lazy eager loading
 9$books = Book::all();
10$books->load('author'); 1// Eager loading lors de la requête
 2$posts = Post::with('author')->get();
 3 
 4foreach ($posts as $post) {
 5    echo $post->author->name;
 6}
 7 
 8// Lazy eager loading
 9$books = Book::all();
10$books->load('author');

Conclusion et Bonnes Pratiques

Utilisez les relations Eloquent pour une meilleure organisation du code
Optimisez les performances avec l'eager loading
Exploitez les contraintes de clés étrangères dans vos migrations
Utilisez les événements de modèle pour maintenir l'intégrité des relations
Consultez régulièrement la documentation Laravel pour les mises à jour!

#Introduction

#One-to-One Relation

#One-to-Many Relation

#Many-to-Many Relation

#Has-One-Through Relation

#Has-Many-Through Relation

#Polymorphic Relations

#Eager Loading

#Conclusion et Bonnes Pratiques

Introduction

One-to-One Relation

One-to-Many Relation

Many-to-Many Relation

Has-One-Through Relation

Has-Many-Through Relation

Polymorphic Relations

Eager Loading

Conclusion et Bonnes Pratiques