Laravel Eloquent-Beziehungen: Leitfaden zu hasMany und belongsTo

Laravel Eloquent-Beziehungen erlauben es Ihnen, die Verbindungen zwischen Ihren Datenbanktabellen über lesbare, elegante PHP-Objekte auszudrücken. Die Kommentare eines Blogbeitrags, die Bestellungen eines Benutzers, die Produkte einer Kategorie… Anstatt JOIN-Abfragen von Hand zu schreiben, um diese Verknüpfungen zu verwalten, definieren Sie sie mit einer einzigen Methode an Ihren Eloquent-Modellen. In diesem Artikel behandeln wir die beiden häufigsten Beziehungen — hasMany und belongsTo — mit Beispielen und gehen anschließend auf die übrigen Beziehungstypen sowie auf Eager Loading ein, das Rückgrat der relationalen Performance.

Überblick über die Beziehungstypen

Eloquent erlaubt es, verwandte Modelle als Methoden zu deklarieren. In einer typischen Anwendung begegnen Ihnen diese Beziehungen:

Eins-zu-eins (hasOne / belongsTo): Ein Benutzer hat ein einziges Profil.
Eins-zu-viele (hasMany / belongsTo): Ein Beitrag hat viele Kommentare.
Viele-zu-viele (belongsToMany): Ein Beitrag hat viele Tags, und ein Tag gehört zu vielen Beiträgen.
Entfernte und polymorphe Beziehungen: fortgeschrittenere Szenarien wie hasManyThrough und morphMany.

Dieser Artikel konzentriert sich auf den Grundpfeiler, die Eins-zu-viele-Beziehung, denn hasMany und sein Gegenstück belongsTo arbeiten zusammen.

hasMany: „ein Datensatz besitzt viele Datensätze"

Das klassische Beispiel ist ein Blog: Ein Post enthält viele Comment-Datensätze. Auf Datenbankseite besitzt die Tabelle comments eine Spalte post_id. Dieser Fremdschlüssel gibt an, welcher Kommentar zu welchem Beitrag gehört.

// app/Models/Post.php
class Post extends Model
{
    public function comments()
    {
        return $this->hasMany(Comment::class);
    }
}

Standardmäßig nimmt Eloquent an, dass der Fremdschlüssel der Name des übergeordneten Modells (Singular) + _id ist, also post_id. Heißt Ihre Spalte anders, können Sie dies mit dem zweiten und dritten Argument ausdrücklich angeben:

return $this->hasMany(Comment::class, 'post_id', 'id');

Sie können nun auf die Kommentare eines Beitrags zugreifen, als wären sie eine Eigenschaft:

$post = Post::find(1);

foreach ($post->comments as $comment) {
    echo $comment->body;
}

$post->comments ohne Klammern gibt eine Collection zurück, während $post->comments() einen Query Builder liefert. Mit Letzterem können Sie die Beziehung einschränken:

$approved = $post->comments()
    ->where('approved', true)
    ->latest()
    ->get();

belongsTo: das andere Ende der Beziehung

belongsTo ist die Umkehrung von hasMany. Denken Sie aus Sicht des Kommentars: Jeder Kommentar gehört zu einem Beitrag. Die Seite, die den Fremdschlüssel hält — die Tabelle comments mit ihrer Spalte post_id — ist immer die belongsTo-Seite.

// app/Models/Comment.php
class Comment extends Model
{
    public function post()
    {
        return $this->belongsTo(Post::class);
    }
}

So gelangen Sie leicht von einem Kommentar zum übergeordneten Beitrag:

$comment = Comment::find(5);
echo $comment->post->title;

Beide Seiten zu definieren ist gute Praxis: hasMany am Post und belongsTo am Comment. So können Sie die Beziehung in beide Richtungen durchlaufen und machen Ihre Absicht für jeden, der den Code liest, klar.

Datensätze über eine Beziehung erstellen

Eloquent-Beziehungen dienen nicht nur dem Lesen; Sie können neue Datensätze mit automatisch gefülltem Fremdschlüssel erstellen. Die Methoden save und create setzen post_id für Sie:

$post = Post::find(1);

$post->comments()->create([
    'body'   => 'Großartiger Artikel, danke!',
    'author' => 'Lena',
]);

Um create verwenden zu können, denken Sie daran, die betreffenden Felder dem $fillable-Array des Modells hinzuzufügen. In der anderen Richtung verwenden Sie associate, um einen bestehenden Kommentar an einen Beitrag anzuhängen:

$comment->post()->associate($post);
$comment->save();

Das N+1-Problem und Eager Loading

Der häufigste Fehler bei Beziehungen ist eine versteckte Performance-Falle: das N+1-Abfrageproblem. Stellen Sie sich vor, Sie greifen in einer Schleife auf den Autor jedes Beitrags zu:

$posts = Post::all(); // 1 Abfrage

foreach ($posts as $post) {
    echo $post->author->name; // 1 weitere Abfrage pro Beitrag
}

Bei 50 Beiträgen sind das 1 + 50 = 51 Abfragen. Die Lösung ist Eager Loading: Mit der Methode with laden Sie die Beziehung im Voraus mit einer einzigen zusätzlichen Abfrage.

$posts = Post::with('author')->get(); // insgesamt 2 Abfragen

foreach ($posts as $post) {
    echo $post->author->name; // keine zusätzliche Abfrage
}

Hinter den Kulissen führt Eloquent eine WHERE ... IN (...)-Abfrage aus, um alle Autoren auf einmal zu laden. Sie können auch verschachtelte und mehrere Beziehungen eager laden:

$posts = Post::with(['author', 'comments.user'])->get();

Um diesen Fehler früh in der Entwicklung zu erkennen, können Sie Lazy Loading mit Model::preventLazyLoading() verbieten oder die Abfragezahl mit einem Tool wie Laravel Debugbar überwachen. Wenn Sie nur die Anzahl der verbundenen Datensätze benötigen, verwenden Sie withCount, statt alle Zeilen in den Speicher zu laden:

$posts = Post::withCount('comments')->get();
echo $posts->first()->comments_count;

Praktische Tipps

Legen Sie immer einen Datenbankindex auf Fremdschlüsselspalten an; das beschleunigt Beziehungsabfragen spürbar.
Verwenden Sie in Migrationen foreignId('post_id')->constrained()->cascadeOnDelete(), um sowohl den Index als auch eine Integritätsbedingung zu erstellen.
Wählen Sie sinnvolle Beziehungsmethodennamen, die Singular/Plural konsistent halten: Plural für hasMany (comments), Singular für belongsTo (post).
Auf Listenansichten fast immer with verwenden; auf einer Detailseite eines einzelnen Datensatzes nur das Nötige laden.

Häufige Fragen

Was ist der Unterschied zwischen hasMany und belongsTo?

hasMany wird auf der „Eltern"-Seite der Beziehung definiert und steht für viele untergeordnete Datensätze. belongsTo sitzt auf der „Kind"-Seite, die den Fremdschlüssel hält, und verweist auf einen einzelnen übergeordneten Datensatz. Es sind zwei Richtungen derselben Beziehung.

Kann ich einen Fremdschlüssel-Spaltennamen verwenden, der von Eloquents Annahme abweicht?

Ja. Übergeben Sie den Fremdschlüssel als zweites Argument und den lokalen Schlüssel als drittes: hasMany(Comment::class, 'article_id', 'id'). Sofern nicht anders angegeben, nimmt Eloquent den Modellnamen im Singular + _id an.

Sollte ich immer Eager Loading verwenden?

Wenn Sie in einer Schleife auf verbundene Daten zugreifen, ja — das verhindert das N+1-Problem. Greifen Sie jedoch nie auf die Beziehung zu, laden Sie sie nicht unnötig; das kostet zusätzliche Abfragen und Speicher. Stimmen Sie die Balance auf Ihren Bedarf ab.

Beziehungen richtig zu modellieren ist die Grundlage einer schnellen, wartbaren Laravel-Anwendung. Wenn Sie Hilfe bei der Eloquent-Modellierung, der N+1-Optimierung oder einer vollständigen Laravel-Backend-Entwicklung für Ihr Projekt benötigen, kontaktieren Sie mich, und wir legen gemeinsam ein solides Fundament.