Eloquent: 关系

介绍
定义关系
查询关系
插入相关模型
- 多对多关系
- 更新父级时间戳

介绍

数据库表通常是相互关联的。例如，一篇博客文章可能有很多评论，或者一个订单可能与下单的用户相关。Eloquent 使得管理和处理这些关系变得简单，并支持几种不同类型的关系：

一对一
一对多
多对多
通过中间表的多对多
多态关系
多对多多态关系

定义关系

Eloquent 关系被定义为 Eloquent 模型类上的函数。由于 Eloquent 模型本身也作为强大的查询构建器，将关系定义为函数提供了强大的方法链和查询功能。例如：

php

$user->posts()->where('active', 1)->get();

但在深入使用关系之前，让我们先学习如何定义每种类型：

一对一

一对一关系是非常基本的关系。例如，一个 User 模型可能与一个 Phone 相关联。要定义这种关系，我们在 User 模型上放置一个 phone 方法。phone 方法应返回基础 Eloquent 模型类上的 hasOne 方法的结果：

php

<?php

namespace App;

use Illuminate\Database\Eloquent\Model;

class User extends Model
{
    /**
     * 获取与用户关联的电话记录。
     */
    public function phone()
    {
        return $this->hasOne('App\Phone');
    }
}

传递给 hasOne 方法的第一个参数是相关模型的名称。一旦定义了关系，我们可以使用 Eloquent 的动态属性检索相关记录。动态属性允许您像访问模型上定义的属性一样访问关系函数：

php

$phone = User::find(1)->phone;

Eloquent 根据模型名称假定关系的外键。在这种情况下，Phone 模型被自动假定为具有 user_id 外键。如果您希望覆盖此约定，可以将第二个参数传递给 hasOne 方法：

php

return $this->hasOne('App\Phone', 'foreign_key');

此外，Eloquent 假定外键应具有与父级的 id 列匹配的值。换句话说，Eloquent 将在 Phone 记录的 user_id 列中查找用户的 id 列的值。如果您希望关系使用 id 以外的值，可以将第三个参数传递给 hasOne 方法指定您的自定义键：

php

return $this->hasOne('App\Phone', 'foreign_key', 'local_key');

定义关系的反向

因此，我们可以从 User 访问 Phone 模型。现在，让我们在 Phone 模型上定义一个关系，以便我们可以访问拥有电话的 User。我们可以使用 belongsTo 方法定义 hasOne 关系的反向：

php

<?php

namespace App;

use Illuminate\Database\Eloquent\Model;

class Phone extends Model
{
    /**
     * 获取拥有电话的用户。
     */
    public function user()
    {
        return $this->belongsTo('App\User');
    }
}

在上面的示例中，Eloquent 将尝试将 Phone 模型中的 user_id 与 User 模型中的 id 匹配。Eloquent 通过检查关系方法的名称并在方法名称后加上 _id 来确定默认的外键名称。但是，如果 Phone 模型上的外键不是 user_id，您可以将自定义键名作为第二个参数传递给 belongsTo 方法：

php

/**
 * 获取拥有电话的用户。
 */
public function user()
{
    return $this->belongsTo('App\User', 'foreign_key');
}

如果您的父模型不使用 id 作为其主键，或者您希望将子模型连接到不同的列，可以将第三个参数传递给 belongsTo 方法指定您的父表的自定义键：

php

/**
 * 获取拥有电话的用户。
 */
public function user()
{
    return $this->belongsTo('App\User', 'foreign_key', 'other_key');
}

一对多

一对多关系用于定义一个模型拥有任意数量其他模型的关系。例如，一篇博客文章可能有无限数量的评论。像所有其他 Eloquent 关系一样，一对多关系通过在 Eloquent 模型上放置一个函数来定义：

php

<?php

namespace App;

use Illuminate\Database\Eloquent\Model;

class Post extends Model
{
    /**
     * 获取博客文章的评论。
     */
    public function comments()
    {
        return $this->hasMany('App\Comment');
    }
}

请记住，Eloquent 将自动确定 Comment 模型上的正确外键列。按照惯例，Eloquent 将采用拥有模型的“蛇形命名”并在其后加上 _id。因此，对于此示例，Eloquent 将假定 Comment 模型上的外键是 post_id。

一旦定义了关系，我们可以通过访问 comments 属性来访问评论集合。请记住，由于 Eloquent 提供了“动态属性”，我们可以像访问模型上定义的属性一样访问关系函数：

php

$comments = App\Post::find(1)->comments;

foreach ($comments as $comment) {
    //
}

当然，由于所有关系也作为查询构建器，您可以通过调用 comments 方法并继续将条件链接到查询来添加进一步的约束以检索哪些评论：

php

$comments = App\Post::find(1)->comments()->where('title', 'foo')->first();

像 hasOne 方法一样，您还可以通过传递其他参数给 hasMany 方法来覆盖外键和本地键：

php

return $this->hasMany('App\Comment', 'foreign_key');

return $this->hasMany('App\Comment', 'foreign_key', 'local_key');

定义关系的反向

现在我们可以访问所有文章的评论，让我们定义一个关系以允许评论访问其父文章。要定义 hasMany 关系的反向，请在子模型上定义一个调用 belongsTo 方法的关系函数：

php

<?php

namespace App;

use Illuminate\Database\Eloquent\Model;

class Comment extends Model
{
    /**
     * 获取拥有评论的文章。
     */
    public function post()
    {
        return $this->belongsTo('App\Post');
    }
}

一旦定义了关系，我们可以通过访问 post “动态属性”来检索 Comment 的 Post 模型：

php

$comment = App\Comment::find(1);

echo $comment->post->title;

在上面的示例中，Eloquent 将尝试将 Comment 模型中的 post_id 与 Post 模型中的 id 匹配。Eloquent 通过检查关系方法的名称并在方法名称后加上 _id 来确定默认的外键名称。但是，如果 Comment 模型上的外键不是 post_id，您可以将自定义键名作为第二个参数传递给 belongsTo 方法：

php

/**
 * 获取拥有评论的文章。
 */
public function post()
{
    return $this->belongsTo('App\Post', 'foreign_key');
}

如果您的父模型不使用 id 作为其主键，或者您希望将子模型连接到不同的列，可以将第三个参数传递给 belongsTo 方法指定您的父表的自定义键：

php

/**
 * 获取拥有评论的文章。
 */
public function post()
{
    return $this->belongsTo('App\Post', 'foreign_key', 'other_key');
}

多对多

多对多关系比 hasOne 和 hasMany 关系稍微复杂一些。此类关系的一个示例是具有多个角色的用户，其中角色也由其他用户共享。例如，许多用户可能具有“管理员”角色。要定义这种关系，需要三个数据库表：users、roles 和 role_user。role_user 表是从相关模型名称的字母顺序派生的，并包含 user_id 和 role_id 列。

多对多关系通过编写一个调用基础 Eloquent 类上的 belongsToMany 方法的方法来定义。例如，让我们在 User 模型上定义 roles 方法：

php

<?php

namespace App;

use Illuminate\Database\Eloquent\Model;

class User extends Model
{
    /**
     * 属于用户的角色。
     */
    public function roles()
    {
        return $this->belongsToMany('App\Role');
    }
}

一旦定义了关系，您可以使用 roles 动态属性访问用户的角色：

php

$user = App\User::find(1);

foreach ($user->roles as $role) {
    //
}

当然，像所有其他关系类型一样，您可以调用 roles 方法以继续将查询约束链接到关系：

php

$roles = App\User::find(1)->roles()->orderBy('name')->get();

如前所述，为了确定关系连接表的表名，Eloquent 将按字母顺序连接两个相关模型名称。但是，您可以自由地覆盖此约定。您可以通过将第二个参数传递给 belongsToMany 方法来实现：

php

return $this->belongsToMany('App\Role', 'user_roles');

除了自定义连接表的名称，您还可以通过传递其他参数给 belongsToMany 方法来自定义表上键的列名。第三个参数是您定义关系的模型的外键名称，而第四个参数是您要连接的模型的外键名称：

php

return $this->belongsToMany('App\Role', 'user_roles', 'user_id', 'role_id');

定义关系的反向

要定义多对多关系的反向，只需在相关模型上再次调用 belongsToMany。为了继续我们的用户角色示例，让我们在 Role 模型上定义 users 方法：

php

<?php

namespace App;

use Illuminate\Database\Eloquent\Model;

class Role extends Model
{
    /**
     * 属于角色的用户。
     */
    public function users()
    {
        return $this->belongsToMany('App\User');
    }
}

如您所见，关系的定义与其 User 对应关系完全相同，只是简单地引用了 App\User 模型。由于我们重用了 belongsToMany 方法，因此在定义多对多关系的反向时，所有常见的表和键自定义选项都可用。

检索中间表列

如您所知，处理多对多关系需要中间表的存在。Eloquent 提供了一些非常有用的方法来与此表交互。例如，假设我们的 User 对象有许多 Role 对象与之相关。在访问此关系后，我们可以使用模型上的 pivot 属性访问中间表：

php

$user = App\User::find(1);

foreach ($user->roles as $role) {
    echo $role->pivot->created_at;
}

请注意，我们检索的每个 Role 模型都会自动分配一个 pivot 属性。此属性包含一个表示中间表的模型，并可以像任何其他 Eloquent 模型一样使用。

默认情况下，只有模型键会出现在 pivot 对象上。如果您的 pivot 表包含额外的属性，您必须在定义关系时指定它们：

php

return $this->belongsToMany('App\Role')->withPivot('column1', 'column2');

如果您希望 pivot 表具有自动维护的 created_at 和 updated_at 时间戳，请在关系定义上使用 withTimestamps 方法：

php

return $this->belongsToMany('App\Role')->withTimestamps();

通过中间表的多对多

“通过中间表的多对多”关系提供了一种方便的快捷方式，通过中间关系访问远程关系。例如，一个 Country 模型可能通过中间的 User 模型拥有许多 Post 模型。在此示例中，您可以轻松地收集给定国家的所有博客文章。让我们看看定义此关系所需的表：

php

countries
    id - integer
    name - string

users
    id - integer
    country_id - integer
    name - string

posts
    id - integer
    user_id - integer
    title - string

尽管 posts 不包含 country_id 列，但 hasManyThrough 关系通过 $country->posts 提供对国家的文章的访问。为了执行此查询，Eloquent 检查中间 users 表上的 country_id。在找到匹配的用户 ID 后，它们用于查询 posts 表。

现在我们已经检查了关系的表结构，让我们在 Country 模型上定义它：

php

<?php

namespace App;

use Illuminate\Database\Eloquent\Model;

class Country extends Model
{
    /**
     * 获取国家的所有文章。
     */
    public function posts()
    {
        return $this->hasManyThrough('App\Post', 'App\User');
    }
}

传递给 hasManyThrough 方法的第一个参数是我们希望访问的最终模型的名称，而第二个参数是中间模型的名称。

在执行关系查询时，将使用典型的 Eloquent 外键约定。如果您希望自定义关系的键，可以将它们作为第三个和第四个参数传递给 hasManyThrough 方法。第三个参数是中间模型上的外键名称，而第四个参数是最终模型上的外键名称。

php

class Country extends Model
{
    public function posts()
    {
        return $this->hasManyThrough('App\Post', 'App\User', 'country_id', 'user_id');
    }
}

多态关系

表结构

多态关系允许一个模型在单个关联上属于多个其他模型。例如，假设您想为员工和产品存储照片。使用多态关系，您可以为这两种情况使用单个 photos 表。首先，让我们检查构建此关系所需的表结构：

php

staff
    id - integer
    name - string

products
    id - integer
    price - integer

photos
    id - integer
    path - string
    imageable_id - integer
    imageable_type - string

需要注意的两个重要列是 photos 表上的 imageable_id 和 imageable_type 列。imageable_id 列将包含拥有员工或产品的 ID 值，而 imageable_type 列将包含拥有模型的类名。imageable_type 列是 ORM 在访问 imageable 关系时确定返回哪种“类型”拥有模型的方式。

模型结构

接下来，让我们检查构建此关系所需的模型定义：

php

<?php

namespace App;

use Illuminate\Database\Eloquent\Model;

class Photo extends Model
{
    /**
     * 获取所有拥有 imageable 模型。
     */
    public function imageable()
    {
        return $this->morphTo();
    }
}

class Staff extends Model
{
    /**
     * 获取员工的所有照片。
     */
    public function photos()
    {
        return $this->morphMany('App\Photo', 'imageable');
    }
}

class Product extends Model
{
    /**
     * 获取产品的所有照片。
     */
    public function photos()
    {
        return $this->morphMany('App\Photo', 'imageable');
    }
}

检索多态关系

一旦定义了数据库表和模型，您可以通过模型访问关系。例如，要访问员工的所有照片，我们可以简单地使用 photos 动态属性：

php

$staff = App\Staff::find(1);

foreach ($staff->photos as $photo) {
    //
}

您还可以通过访问执行 morphTo 调用的方法的名称从多态模型中检索多态关系的所有者。在我们的例子中，这是 Photo 模型上的 imageable 方法。因此，我们将作为动态属性访问该方法：

php

$photo = App\Photo::find(1);

$imageable = $photo->imageable;

Photo 模型上的 imageable 关系将返回 Staff 或 Product 实例，具体取决于哪个类型的模型拥有照片。

自定义多态类型

默认情况下，Laravel 将使用完全限定的类名来存储相关模型的类型。例如，给定上面的示例，其中 Like 可能属于 Post 或 Comment，默认的 likable_type 将分别是 App\Post 或 App\Comment。但是，您可能希望将数据库与应用程序的内部结构解耦。在这种情况下，您可以定义关系“morph map”以指示 Eloquent 使用与每个模型关联的表名而不是类名：

php

Relation::morphMap([
    App\Post::class,
    App\Comment::class,
]);

或者，您可以为每个模型指定一个自定义字符串：

php

Relation::morphMap([
    'posts' => App\Post::class,
    'likes' => App\Like::class,
]);

您可以在 AppServiceProvider 中注册 morphMap，或者如果您愿意，可以创建一个单独的服务提供者。

多对多多态关系

表结构

除了传统的多态关系，您还可以定义“多对多”多态关系。例如，博客 Post 和 Video 模型可以共享与 Tag 模型的多态关系。使用多对多多态关系允许您拥有一个在博客文章和视频中共享的唯一标签列表。首先，让我们检查表结构：

php

posts
    id - integer
    name - string

videos
    id - integer
    name - string

tags
    id - integer
    name - string

taggables
    tag_id - integer
    taggable_id - integer
    taggable_type - string

模型结构

接下来，我们准备在模型上定义关系。Post 和 Video 模型都将有一个 tags 方法，该方法调用基础 Eloquent 类上的 morphToMany 方法：

php

<?php

namespace App;

use Illuminate\Database\Eloquent\Model;

class Post extends Model
{
    /**
     * 获取文章的所有标签。
     */
    public function tags()
    {
        return $this->morphToMany('App\Tag', 'taggable');
    }
}

定义关系的反向

接下来，在 Tag 模型上，您应该为每个相关模型定义一个方法。因此，对于此示例，我们将定义一个 posts 方法和一个 videos 方法：

php

<?php

namespace App;

use Illuminate\Database\Eloquent\Model;

class Tag extends Model
{
    /**
     * 获取分配此标签的所有文章。
     */
    public function posts()
    {
        return $this->morphedByMany('App\Post', 'taggable');
    }

    /**
     * 获取分配此标签的所有视频。
     */
    public function videos()
    {
        return $this->morphedByMany('App\Video', 'taggable');
    }
}

检索关系

一旦定义了数据库表和模型，您可以通过模型访问关系。例如，要访问文章的所有标签，您可以简单地使用 tags 动态属性：

php

$post = App\Post::find(1);

foreach ($post->tags as $tag) {
    //
}

您还可以通过访问执行 morphedByMany 调用的方法的名称从多态模型中检索多态关系的所有者。在我们的例子中，这是 Tag 模型上的 posts 或 videos 方法。因此，您将作为动态属性访问这些方法：

php

$tag = App\Tag::find(1);

foreach ($tag->videos as $video) {
    //
}

查询关系

由于所有类型的 Eloquent 关系都是通过函数定义的，您可以调用这些函数以获取关系的实例，而无需实际执行关系查询。此外，所有类型的 Eloquent 关系也作为查询构建器，允许您在最终对数据库执行 SQL 之前继续将约束链接到关系查询。

例如，想象一个博客系统，其中 User 模型有许多关联的 Post 模型：

php

<?php

namespace App;

use Illuminate\Database\Eloquent\Model;

class User extends Model
{
    /**
     * 获取用户的所有文章。
     */
    public function posts()
    {
        return $this->hasMany('App\Post');
    }
}

您可以查询 posts 关系并向关系添加其他约束，如下所示：

php

$user = App\User::find(1);

$user->posts()->where('active', 1)->get();

请注意，您可以在关系上使用任何查询构建器方法！

关系方法与动态属性

如果您不需要向 Eloquent 关系查询添加其他约束，您可以简单地将关系作为属性访问。例如，继续使用我们的 User 和 Post 示例模型，我们可以像这样访问用户的所有文章：

php

$user = App\User::find(1);

foreach ($user->posts as $post) {
    //
}

动态属性是“延迟加载”的，这意味着它们只会在您实际访问它们时加载其关系数据。因此，开发人员通常使用预加载来预加载他们知道在加载模型后将访问的关系。预加载显著减少了必须执行的 SQL 查询以加载模型的关系。

查询关系存在性

在访问模型的记录时，您可能希望根据关系的存在限制结果。例如，假设您想检索所有至少有一个评论的博客文章。为此，您可以将关系的名称传递给 has 方法：

php

// 检索所有至少有一个评论的文章...
$posts = App\Post::has('comments')->get();

您还可以指定一个运算符和计数以进一步自定义查询：

php

// 检索所有至少有三个评论的文章...
$posts = Post::has('comments', '>=', 3)->get();

嵌套的 has 语句也可以使用“点”符号构造。例如，您可以检索所有至少有一个评论和投票的文章：

php

// 检索所有至少有一个带投票的评论的文章...
$posts = Post::has('comments.votes')->get();

如果您需要更强大的功能，可以使用 whereHas 和 orWhereHas 方法在 has 查询上添加“where”条件。这些方法允许您向关系约束添加自定义约束，例如检查评论的内容：

php

// 检索所有至少有一个包含 foo% 的评论的文章
$posts = Post::whereHas('comments', function ($query) {
    $query->where('content', 'like', 'foo%');
})->get();

预加载

在将 Eloquent 关系作为属性访问时，关系数据是“延迟加载”的。这意味着关系数据在您首次访问属性之前不会实际加载。然而，Eloquent 可以在查询父模型时“预加载”关系。预加载缓解了 N + 1 查询问题。为了说明 N + 1 查询问题，考虑一个与 Author 相关的 Book 模型：

php

<?php

namespace App;

use Illuminate\Database\Eloquent\Model;

class Book extends Model
{
    /**
     * 获取撰写书籍的作者。
     */
    public function author()
    {
        return $this->belongsTo('App\Author');
    }
}

现在，让我们检索所有书籍及其作者：

php

$books = App\Book::all();

foreach ($books as $book) {
    echo $book->author->name;
}

此循环将执行 1 个查询以检索表上的所有书籍，然后为每本书执行另一个查询以检索作者。因此，如果我们有 25 本书，此循环将运行 26 个查询：1 个用于原始书籍，25 个用于检索每本书的作者。

幸运的是，我们可以使用预加载将此操作减少到仅 2 个查询。在查询时，您可以使用 with 方法指定应预加载哪些关系：

php

$books = App\Book::with('author')->get();

foreach ($books as $book) {
    echo $book->author->name;
}

对于此操作，将仅执行两个查询：

sql

select * from books

select * from authors where id in (1, 2, 3, 4, 5, ...)

预加载多个关系

有时您可能需要在单个操作中预加载多个不同的关系。为此，只需将其他参数传递给 with 方法：

php

$books = App\Book::with('author', 'publisher')->get();

嵌套预加载

要预加载嵌套关系，您可以使用“点”语法。例如，让我们在一个 Eloquent 语句中预加载所有书籍的作者和所有作者的个人联系人：

php

$books = App\Book::with('author.contacts')->get();

约束预加载

有时您可能希望预加载关系，但也为预加载查询指定其他查询约束。以下是一个示例：

php

$users = App\User::with(['posts' => function ($query) {
    $query->where('title', 'like', '%first%');

}])->get();

在此示例中，Eloquent 只会预加载帖子，如果帖子的 title 列包含单词 first。当然，您可以调用其他查询构建器以进一步自定义预加载操作：

php

$users = App\User::with(['posts' => function ($query) {
    $query->orderBy('created_at', 'desc');

}])->get();

延迟预加载

有时您可能需要在父模型已经检索到之后预加载关系。例如，如果您需要动态决定是否加载相关模型，这可能会很有用：

php

$books = App\Book::all();

if ($someCondition) {
    $books->load('author', 'publisher');
}

如果您需要在预加载查询上设置其他查询约束，可以将 Closure 传递给 load 方法：

php

$books->load(['author' => function ($query) {
    $query->orderBy('published_date', 'asc');
}]);

插入相关模型

保存方法

Eloquent 提供了方便的方法来向关系添加新模型。例如，也许您需要为 Post 模型插入一个新的 Comment。而不是手动设置 Comment 上的 post_id 属性，您可以直接从关系的 save 方法插入 Comment：

php

$comment = new App\Comment(['message' => 'A new comment.']);

$post = App\Post::find(1);

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

请注意，我们没有将 comments 关系作为动态属性访问。相反，我们调用了 comments 方法以获取关系的实例。save 方法将自动将适当的 post_id 值添加到新的 Comment 模型。

如果您需要保存多个相关模型，可以使用 saveMany 方法：

php

$post = App\Post::find(1);

$post->comments()->saveMany([
    new App\Comment(['message' => 'A new comment.']),
    new App\Comment(['message' => 'Another comment.']),
]);

保存和多对多关系

在处理多对多关系时，save 方法接受一个数组作为其第二个参数，用于附加中间表的额外属性：

php

App\User::find(1)->roles()->save($role, ['expires' => $expires]);

创建方法

除了 save 和 saveMany 方法，您还可以使用 create 方法，该方法接受一个属性数组，创建一个模型并将其插入数据库。同样，save 和 create 的区别在于 save 接受一个完整的 Eloquent 模型实例，而 create 接受一个普通的 PHP array：

php

$post = App\Post::find(1);

$comment = $post->comments()->create([
    'message' => 'A new comment.',
]);

在使用 create 方法之前，请务必查看有关属性批量赋值的文档。

更新“属于”关系

在更新 belongsTo 关系时，您可以使用 associate 方法。此方法将设置子模型上的外键：

php

$account = App\Account::find(10);

$user->account()->associate($account);

$user->save();

在删除 belongsTo 关系时，您可以使用 dissociate 方法。此方法将重置子模型上的外键以及关系：

php

$user->account()->dissociate();

$user->save();

多对多关系

附加/分离

在处理多对多关系时，Eloquent 提供了一些额外的辅助方法，使处理相关模型更加方便。例如，假设一个用户可以有多个角色，一个角色可以有多个用户。要通过在连接模型的中间表中插入记录来将角色附加到用户，请使用 attach 方法：

php

$user = App\User::find(1);

$user->roles()->attach($roleId);

在将关系附加到模型时，您还可以传递一个数组以插入中间表的额外数据：

php

$user->roles()->attach($roleId, ['expires' => $expires]);

当然，有时可能需要从用户中删除角色。要删除多对多关系记录，请使用 detach 方法。detach 方法将从中间表中删除适当的记录；然而，两个模型将保留在数据库中：

php

// 从用户中分离单个角色...
$user->roles()->detach($roleId);

// 从用户中分离所有角色...
$user->roles()->detach();

为了方便起见，attach 和 detach 也接受 ID 数组作为输入：

php

$user = App\User::find(1);

$user->roles()->detach([1, 2, 3]);

$user->roles()->attach([1 => ['expires' => $expires], 2, 3]);

方便的同步

您还可以使用 sync 方法来构建多对多关联。sync 方法接受一个 ID 数组以放置在中间表中。任何不在给定数组中的 ID 将从中间表中删除。因此，在此操作完成后，中间表中将仅存在数组中的 ID：

php

$user->roles()->sync([1, 2, 3]);

您还可以将额外的中间表值与 ID 一起传递：

php

$user->roles()->sync([1 => ['expires' => true], 2, 3]);

更新父级时间戳

当一个模型 belongsTo 或 belongsToMany 另一个模型时，例如一个 Comment 属于一个 Post，在更新子模型时有时有助于更新父级的时间戳。例如，当更新 Comment 模型时，您可能希望自动“触摸”拥有的 Post 的 updated_at 时间戳。Eloquent 使这变得简单。只需在子模型中添加一个包含关系名称的 touches 属性：

php

<?php

namespace App;

use Illuminate\Database\Eloquent\Model;

class Comment extends Model
{
    /**
     * 所有要触摸的关系。
     *
     * @var array
     */
    protected $touches = ['post'];

    /**
     * 获取评论所属的文章。
     */
    public function post()
    {
        return $this->belongsTo('App\Post');
    }
}

现在，当您更新 Comment 时，拥有的 Post 也会更新其 updated_at 列：

php

$comment = App\Comment::find(1);

$comment->text = 'Edit to this comment!';

$comment->save();

Eloquent: 关系 ​

介绍 ​

定义关系 ​

一对一 ​

定义关系的反向 ​

一对多 ​

定义关系的反向 ​

多对多 ​

定义关系的反向 ​

检索中间表列 ​

通过中间表的多对多 ​

多态关系 ​

表结构 ​

模型结构 ​

检索多态关系 ​

自定义多态类型 ​

多对多多态关系 ​

表结构 ​

模型结构 ​

定义关系的反向 ​

检索关系 ​

查询关系 ​

关系方法与动态属性 ​

查询关系存在性 ​

预加载 ​

预加载多个关系 ​

嵌套预加载 ​

约束预加载 ​

延迟预加载 ​

插入相关模型 ​

保存方法 ​

保存和多对多关系 ​

创建方法 ​

更新“属于”关系 ​

多对多关系 ​

附加/分离 ​

方便的同步 ​

更新父级时间戳 ​

Eloquent: 关系

介绍

定义关系

一对一

定义关系的反向

一对多

定义关系的反向

多对多

定义关系的反向

检索中间表列

通过中间表的多对多

多态关系

表结构

模型结构

检索多态关系

自定义多态类型

多对多多态关系

表结构

模型结构

定义关系的反向

检索关系

查询关系

关系方法与动态属性

查询关系存在性

预加载

预加载多个关系

嵌套预加载

约束预加载

延迟预加载

插入相关模型

保存方法

保存和多对多关系

创建方法

更新“属于”关系

多对多关系

附加/分离

方便的同步

更新父级时间戳