模型关联

模型关联


Eloquent: 关联

简介

数据库表通常相互关联。 例如,一篇博客文章可能有许多评论,或者一个订单对应一个下单用户。Eloquent 让这些关联的管理和使用变得简单,并支持多种类型的关联:

定义关联

Eloquent 关联在 Eloquent 模型类中以方法的形式呈现。如同 Eloquent 模型本身,关联也可以作为强大的 查询语句构造器 使用,提供了强大的链式调用和查询功能。例如,我们可以在posts关联的链式调用中附加一个约束条件:

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

不过在深入使用关联之前,让我们先学习如何定义每种关联类型。

一对一

一对一是最基本的关联关系。例如,一个User模型可能关联一个Phone模型。为了定义这个关联,我们要在User模型中写一个phone方法。在phone方法内部调用hasOne方法并返回其结果:

hasOne('App\Phone'); } }

hasOne方法的第一个参数是关联模型的类名。一旦定义了模型关联,我们就可以使用 Eloquent 动态属性获得相关的记录。动态属性允许你访问关系方法就像访问模型中定义的属性一样:

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

Eloquent 会基于模型名决定外键名称。在这种情况下,会自动假设Phone模型有一个user_id外键。如果你想覆盖这个约定,可以传递第二个参数给hasOne方法:

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

另外,Eloquent 假设外键的值是与父级 id (或自定义 $primaryKey) 列的值相匹配的。换句话说,Eloquent 将会在 Phone 记录的 user_id 列中查找与用户表的 id 列相匹配的值。如果您希望该关联使用 id 以外的自定义键名,则可以给 hasOne 方法传递第三个参数:

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

定义反向关联

我们已经能从User模型访问到Phone模型了。现在,让我们再在Phone模型上定义一个关联,这个关联能让我们访问到拥有该电话的User模型。我们可以使用与hasOne方法对应的belongsTo方法来定义反向关联:

belongsTo('App\User'); } }

在上面的例子中, Eloquent 会尝试匹配Phone模型上的user_idUser模型上的id。它是通过检查关系方法的名称并使用_id作为后缀名来确定默认外键名称的。但是,如果Phone模型的外键不是user_id,那么可以将自定义键名作为第二个参数传递给belongsTo方法:

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

如果父级模型没有使用id作为主键,或者是希望用不同的字段来连接子级模型,则可以通过给belongsTo方法传递第三个参数的形式指定父级数据表的自定义键:

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

一对多

『一对多』关联用于定义单个模型拥有任意数量的其它关联模型。例如,一篇博客文章可能会有无限多条评论。正如其它所有的 Eloquent 关联一样,一对多关联的定义也是在 Eloquent 模型中写一个方法:

hasMany('App\Comment'); } }

记住一点,Eloquent 将会自动确定Comment模型的外键属性。按照约定,Eloquent 将会使用所属模型名称的 『snake case』形式,再加上_id后缀作为外键字段。因此,在上面这个例子中,Eloquent 将假定Comment对应到Post模型上的外键就是post_id

一旦关系被定义好以后,就可以通过访问Post模型的comments属性来获取评论的集合。记住,由于 Eloquent 提供了『动态属性』 ,所以我们可以像访问模型的属性一样访问关联方法:

$comments = App\Post::find(1)->comments;foreach ($comments as $comment) { //}

当然,由于所有的关联还可以作为查询语句构造器使用,因此你可以使用链式调用的方式,在comments方法上添加额外的约束条件:

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

正如hasOne方法一样,你也可以在使用hasMany方法的时候,通过传递额外参数来覆盖默认使用的外键与本地键:

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

一对多(反向)

现在,我们已经能获得一篇文章的所有评论,接着再定义一个通过评论获得所属文章的关联关系。这个关联是hasMany关联的反向关联,需要在子级模型中使用belongsTo方法定义它:

belongsTo('App\Post'); } }

这个关系定义好以后,我们就可以通过访问Comment模型的post这个『动态属性』来获取关联的Post模型了:

$comment = App\Comment::find(1); echo $comment->post->title;

在上面的例子中,Eloquent 会尝试用Comment模型的post_idPost模型的id进行匹配。默认外键名是 Eloquent 依据关联名,并在关联名后加上 _ 再加上主键字段名作为后缀确定的。当然,如果Comment模型的外键不是post_id,那么可以将自定义键名作为第二个参数传递给belongsTo方法:

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

如果父级模型没有使用id作为主键,或者是希望用不同的字段来连接子级模型,则可以通过给belongsTo方法传递第三个参数的形式指定父级数据表的自定义键:

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

多对多

多对多关联比hasOnehasMany关联稍微复杂些。举个例子,一个用户可以拥有很多种角色,同时这些角色也被其他用户共享。例如,许多用户可能都有 「管理员」 这个角色。要定义这种关联,需要三个数据库表:usersrolesrole_userrole_user表的命名是由关联的两个模型按照字母顺序来的,并且包含了user_idrole_id字段。

多对多关联通过调用belongsToMany这个内部方法返回的结果来定义,例如,我们在User模型中定义roles方法:

belongsToMany('App\Role'); } }

一旦关联关系被定义后,你可以通过roles动态属性获取用户角色:

$user = App\User::find(1); foreach ($user->roles as $role) { // }

当然,像其它所有关联模型一样,你可以使用roles方法,利用链式调用对查询语句添加约束条件:

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

正如前面所提到的,为了确定关联连接表的表名,Eloquent 会按照字母顺序连接两个关联模型的名字。当然,你也可以不使用这种约定,传递第二个参数到belongsToMany方法即可:

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

除了自定义连接表的表名,你还可以通过传递额外的参数到belongsToMany方法来定义该表中字段的键名。第三个参数是定义此关联的模型在连接表里的外键名,第四个参数是另一个模型在连接表里的外键名:

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

定义反向关联

要定义多对多的反向关联, 你只需要在关联模型中调用belongsToMany方法。我们在Role模型中定义users方法:

belongsToMany('App\User'); } }

如你所见,除了引入模型为App\User外,其它与在User模型中定义的完全一样。由于我们重用了belongsToMany方法,自定义连接表表名和自定义连接表里的键的字段名称在这里同样适用。

获取中间表字段

就如你刚才所了解的一样,多对多的关联关系需要一个中间表来提供支持, Eloquent 提供了一些有用的方法来和这张表进行交互。例如,假设我们的User对象关联了多个Role对象。在获得这些关联对象后,可以使用模型的pivot属性访问中间表的数据:

$user = App\User::find(1); foreach ($user->roles as $role) { echo $role->pivot->created_at; }

需要注意的是,我们获取的每个Role模型对象,都会被自动赋予pivot属性,它代表中间表的一个模型对象,并且可以像其他的 Eloquent 模型一样使用。

默认情况下,pivot对象只包含两个关联模型的主键,如果你的中间表里还有其他额外字段,你必须在定义关联时明确指出:

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

如果你想让中间表自动维护created_atupdated_at时间戳,那么在定义关联时附加上withTimestamps方法即可:

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

自定义pivot属性名称

如前所述,来自中间表的属性可以使用pivot属性访问。但是,你可以自由定制此属性的名称,以便更好的反应其在应用中的用途。

例如,如果你的应用中包含可能订阅的用户,则用户与博客之间可能存在多对多的关系。如果是这种情况,你可能希望将中间表访问器命名为subscription取代pivot。这可以在定义关系时使用as方法完成:

return $this->belongsToMany('App\Podcast') ->as('subscription') ->withTimestamps();

一旦定义完成,你可以使用自定义名称访问中间表数据:

$users = User::with('podcasts')->get(); foreach ($users->flatMap->podcasts as $podcast) { echo $podcast->subscription->created_at; }

通过中间表过滤关系

在定义关系时,你还可以使用wherePivotwherePivotIn方法来过滤belongsToMany返回的结果:

return $this->belongsToMany('App\Role')->wherePivot('approved', 1); return $this->belongsToMany('App\Role')->wherePivotIn('priority', [1, 2]);

定义中间表模型

定义自定义中间表模型
如果你想定义一个自定义模型来表示关联关系中的中间表,可以在定义关联时调用using方法。自定义多对多中间表模型都必须扩展自 Illuminate\Database\Eloquent\Relations\Pivot 类,自定义多对多(多态)中间表模型必须继承 Illuminate\Database\Eloquent\Relations\MorphPivot 类。例如,
我们在写 Role 模型的关联时,使用自定义中间表模型UserRole

belongsToMany('App\User')->using('App\UserRole'); } }

当定义UserRole模型时,我们要扩展Pivot类:


      

你可以组合使用usingwithPivot从中间表来检索列。例如,通过将列名传递给withPivot方法,就可以从UserRole中间表中检索出created_byupdated_by两列数据。

belongsToMany('App\User') ->using('App\UserRole') ->withPivot([ 'created_by', 'updated_by' ]); } }

带有递增 ID 的自定义中继模型

如果你用一个自定义的中继模型定义了多对多的关系,而且这个中继模型拥有一个自增的主键,你应当确保这个自定义中继模型类中定义了一个incrementing属性其值为true

/** * 标识 ID 是否自增。 * * @var bool */ public $incrementing = true;

远程一对一关系

远程一对一关联通过一个中间关联模型实现。
例如,如果每个供应商都有一个用户,并且每个用户与一个用户历史记录相关联,那么供应商可以通过用户访问用户的历史记录,让我们看看定义这种关系所需的数据库表:

suppliers id - integer users id - integer supplier_id - integer history id - integer user_id - integer

虽然history表不包含supplier_id,但hasOneThrough关系可以提供对用户历史记录的访问,以访问供应商模型。现在我们已经检查了关系的表结构,让我们在Supplier模型上定义相应的方法:

hasOneThrough('App\History', 'App\User'); } }

传递给hasOneThrough方法的第一个参数是希望访问的模型名称,第二个参数是中间模型的名称。

当执行关联查询时,通常会使用 Eloquent 约定的外键名。如果你想要自定义关联的键,可以通过给hasOneThrough方法传递第三个和第四个参数实现,第三个参数表示中间模型的外键名,第四个参数表示最终模型的外键名。第五个参数表示本地键名,而第六个参数表示中间模型的本地键名:

class Supplier extends Model{ /** * 用户的历史记录。 */ public function userHistory() { return $this->hasOneThrough( 'App\History', 'App\User', 'supplier_id', // 用户表外键 'user_id', // 历史记录表外键 'id', // 供应商本地键 'id' // 用户本地键 ); } }

远程一对多关联

远程一对多关联提供了方便、简短的方式通过中间的关联来获得远层的关联。例如,一个Country模型可以通过中间的User模型获得多个Post模型。在这个例子中,你可以轻易地收集给定国家的所有博客文章。让我们来看看定义这种关联所需的数据表:

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 会先检查中间表userscountry_id字段,找到所有匹配的用户 ID 后,使用这些 ID,在posts表中完成查找。

现在,我们已经知道了定义这种关联所需的数据表结构,接下来,让我们在Country模型中定义它:

hasManyThrough('App\Post', 'App\User'); } }

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

当执行关联查询时,通常会使用 Eloquent 约定的外键名。如果你想要自定义关联的键,可以通过给hasManyThrough方法传递第三个和第四个参数实现,第三个参数表示中间模型的外键名,第四个参数表示最终模型的外键名。第五个参数表示本地键名,而第六个参数表示中间模型的本地键名:

class Country extends Model{ public function posts() { return $this->hasManyThrough( 'App\Post', 'App\User', 'country_id', // 用户表外键 'user_id', // 文章表外键 'id', // 国家表本地键 'id' // 用户表本地键 ); } }

多态关联

多态关联允许目标模型借助单个关联从属于多个模型。

一对一(多态)

表结构

一对一多态关联与简单的一对一关联类似;不过,目标模型能够在一个关联上从属于多个模型。例如,博客PostUser可能共享一个关联到Image模型的关系。使用一对一多态关联允许使用一个唯一图片列表同时用于博客文章和用户账户。让我们先看看表结构:

posts id - integer name - string users id - integer name - string images id - integer url - string imageable_id - integer imageable_type - string

要特别留意images表的imageable_idimageable_type列。imageable_id列包含文章或用户的 ID 值,而imageable_type列包含的则是父模型的类名。Eloquent 在访问imageable时使用imageable_type列来判断父模型的 「类型」。

模型结构

接下来,再看看建立关联的模型定义:

morphTo(); } } class Post extends Model{ /** * 获取文章图片。 */ public function image() { return $this->morphOne('App\Image', 'imageable'); } } class User extends Model{ /** * 获取用户图片。 */ public function image() { return $this->morphOne('App\Image', 'imageable'); } }

获取关联

一旦定义了表和模型,就可以通过模型访问此关联。比如,要获取文章图片,可以使用image动态属性:

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

还可以通过访问执行morphTo调用的方法名来从多态模型中获知父模型。在这个例子中,就是Image模型的imageable方法。所以,我们可以像动态属性那样访问这个方法:

$image = App\Image::find(1); $imageable = $image->imageable;

Image模型的imageable关联将返回PostUser实例,其结果取决于图片属性哪个模型。

一对多(多态)

表结构

一对多多态关联与简单的一对多关联类似;不过,目标模型可以在一个关联中从属于多个模型。假设应用中的用户可以同时 「评论」 文章和视频。使用多态关联,可以用单个comments表同时满足这些情况。我们还是先来看看用来构建这种关联的表结构:

posts id - integer title - string body - text videos id - integer title - string url - string comments id - integer body - text commentable_id - integer commentable_type - string

模型结构

接下来,看看构建这种关联的模型定义:

morphTo(); } } class Post extends Model{ /** * 获取此文章的所有评论。 */ public function comments() { return $this->morphMany('App\Comment', 'commentable'); } } class Video extends Model{ /** * 获取此视频的所有评论。 */ public function comments() { return $this->morphMany('App\Comment', 'commentable'); } }

获取关联

一旦定义了数据库表和模型,就可以通过模型访问关联。例如,可以使用comments动态属性访问文章的全部评论:

$post = App\Post::find(1);foreach ($post->comments as $comment) { // }

还可以通过访问执行morphTo调用的方法名来从多态模型获取其所属模型。在本例中,就是Comment模型的commentable方法:

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

Comment模型的commentable关联将返回PostVideo实例,其结果取决于评论所属的模型。

多对多(多态)

表结构

多对多多态关联比morphOnemorphMany关联略微复杂一些。例如,博客PostVideo模型能够共享关联到Tag模型的多态关系。使用多对多多态关联允许使用一个唯一标签在博客文章和视频间共享。以下是多对多多态关联的表结构:

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

模型结构

接下来,在模型上定义关联。PostVideo模型都有调用 Eloquent 基类上morphToMany方法的tags方法:

morphToMany('App\Tag', 'taggable'); } }

定义反向关联关系

下面,需要在Tag模型上为每个关联模型定义一个方法。在这个示例中,我们将会定义posts方法和videos方法:

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

获取关联

一旦定义了数据库表和模型,就可以通过模型访问关联。例如,可以使用tags动态属性访问文章的所有标签:

$post = App\Post::find(1);foreach ($post->tags as $tag) { // }

还可以访问执行morphedByMany方法调用的方法名来从多态模型获取其所属模型。在这个示例中,就是Tag模型的postsvideos方法。可以像动态属性一样访问这些方法:

$tag = App\Tag::find(1);foreach ($tag->videos as $video) { // }

自定义多态类型

默认情况下, Laravel 使用完全限定类名存储关联模型类型。在上面的一对多示例中, 因为Comment可能从属于一个Post或一个Video,默认的commentable_type就将分别是App\PostApp\Video。不过,你可能希望数据库与应用的内部结构解耦。在这种情况下,可以定义一个 「morph 映射」 来通知 Eloquent 使用自定义名称代替对应的类名:

use Illuminate\Database\Eloquent\Relations\Relation; Relation::morphMap([ 'posts' => 'App\Post', 'videos' => 'App\Video', ]);

可以在AppServiceProviderboot函数中注册morphMap,或者创建一个单独的服务提供者。

查询关联

由于 Eloquent 关联的所有类型都通过方法定义,你可以调用这些方法,而无需真实执行关联查询。另外,所有 Eloquent 关联类型用作 查询构造器,允许你在数据库上执行 SQL 之前,持续通过链式调用添加约束。

例如,假设一个博客系统的User模型有许多关联的Post模型:

hasMany('App\Post'); } }

你可以查询posts关联,并为其添加额外的约束:

$user = App\User::find(1); $user->posts()->where('active', 1)->get();

你可以在关联上使用任意 查询构造器 方法,请查阅查询构造器文档,学习那些对你有用的方法。

关联方法 Vs. 动态属性

如果不需要向 Eloquent 关联查询添加额外的约束,可以像属性一样访问关联。例如,继续使用UserPost示例模型,可以这样访问用户的全部文章:

$user = App\User::find(1); foreach ($user->posts as $post) { // }

动态属性是「懒加载」的,这意味着它们仅在你真实访问关联数据时才被载入。因此,开发者经常使用预加载预先加载那些他们确知在载入模型后将访问的关联。对载入模型关联中必定被执行的 SQL 查询而言,预加载显著减少了查询的执行次数。

查询已存在的关联

在访问模型记录时,可能希望基于关联的存在限制查询结果。比如想要获取至少存在一条评论的所有文章,可以通过给hasorHas方法传递关联名称来实现:

// 获取至少存在一条评论的所有文章... $posts = App\Post::has('comments')->get();

还可以指定运算符和数量进一步自定义查询:

// 获取评论超过三条的文章... $posts = App\Post::has('comments', '>=', 3)->get();

还可以用 「点」语法构造嵌套的has语句。比如,可以获取拥有至少一条评论和投票的文章:

// 获取拥有至少一条带有投票评论的文章... $posts = App\Post::has('comments.votes')->get();

如果需要更多功能,可以使用whereHasorWhereHas方法将「where」 条件放到has查询上。这些方法允许你向关联加入自定义约束,比如检查评论内容:

use Illuminate\Database\Eloquent\Builder; // 获取至少带有一条评论内容包含 foo% 关键词的文章... $posts = App\Post::whereHas('comments', function ($query) { $query->where('content', 'like', 'foo%');})->get(); // 获取至少带有十条评论内容包含 foo% 关键词的文章... $posts = App\Post::whereHas('comments', function ($query) { $query->where('content', 'like', 'foo%'); }, '>=', 10)->get();

查询不存在的关联

在访问模型记录时,可能希望基于关联不存在来限制查询结果。假设想要获取存在任何评论的文章,可以通过向doesntHaveorDoesntHave方法传递关联名称来实现:

$posts = App\Post::doesntHave('comments')->get();

如果需要更多功能,可以使用whereDoesntHaveorWhereDoesntHave方法将「where」 条件加到doesntHave查询上。这些方法允许你向关联加入自定义限制,比如检测评论内容:

use Illuminate\Database\Eloquent\Builder; $posts = App\Post::whereDoesntHave('comments', function (Builder $query) { $query->where('content', 'like', 'foo%'); })->get();

还可以使用 「点」 语法执行嵌套关联查询。例如,下面的查询用于获取带有没被禁用的作者发表评论的文章:

use Illuminate\Database\Eloquent\Builder; $posts = App\Post::whereDoesntHave('comments.author', function (Builder $query) { $query->where('banned', 1); })->get();

关联模型计数

如果想要只计算关联结果的统计数量而不需要真实加载它们,可以使用withCount方法,它将放在结果模型的{relation}_count列。示例如下:

$posts = App\Post::withCount('comments')->get(); foreach ($posts as $post) { echo $post->comments_count; }

可以像给查询添加限制一样为多个关系添加「计数」:

$posts = App\Post::withCount(['votes', 'comments' => function ($query) { $query->where('content', 'like', 'foo%'); }])->get(); echo $posts[0]->votes_count;echo $posts[0]->comments_count;

还可以给关联计数结果起别名,这允许你在同一关联上添加多个计数:

$posts = App\Post::withCount([ 'comments', 'comments as pending_comments_count' => function ($query) { $query->where('approved', false); }])->get(); echo $posts[0]->comments_count; echo $posts[0]->pending_comments_count;

如果将withCountselect查询组装在一起,请确保在select方法之后调用withCount

$query = App\Post::select(['title', 'body'])->withCount('comments'); echo $posts[0]->title; echo $posts[0]->body; echo $posts[0]->comments_count;

预加载

当以属性方式访问 Eloquent 关联时,关联数据「懒加载」。这着直到第一次访问属性时关联数据才会被真实加载。不过 Eloquent 能在查询父模型时「预先载入」子关联。预加载可以缓解 N + 1 查询问题。为了说明 N + 1 查询问题,考虑Book模型关联到Author的情形:

belongsTo('App\Author'); } }

现在,我们来获取所有的书籍及其作者:

$books = App\Book::all(); foreach ($books as $book) { echo $book->author->name; }

此循环将执行一个查询,用于获取全部书籍,然后为每本书执行获取作者的查询。如果我们有 25 本书,此循环将运行 26 个查询:1 个用于查询书籍,25 个附加查询用于查询每本书的作者。

谢天谢地,我们能够使用预加载将操作压缩到只有 2 个查询。在查询时,可以使用with方法指定想要预加载的关联:

$books = App\Book::with('author')->get(); foreach ($books as $book) { echo $book->author->name; }

在这个例子中,仅执行了两个查询:

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

预加载多个关联

有时,你可能需要在单一操作中预加载几个不同的关联。要达成此目的,只要向with方法传递多个关联名称构成的数组参数:

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

嵌套预加载

可以使用 「点」 语法预加载嵌套关联。比如在一个 Eloquent 语句中预加载所有书籍作者及其联系方式:

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

预加载指定列

并不是总需要获取关系的每一列。在这种情况下,Eloquent 允许你为关联指定想要获取的列:

$users = App\Book::with('author:id,name')->get();

{note} 在使用这个特性时,一定要在要获取的列的列表中包含id列。

为预加载添加约束

有时,可能希望预加载一个关联,同时为预加载查询添加额外查询条件,就像下面的例子:

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

在这个例子中, Eloquent 将仅预加载那些title列包含first关键词的文章。也可以调用其它的 查询构造器 方法进一步自定义预加载操作:

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

{note} 在约束预加载时,不能使用limittake查询构造器方法。

预加载

有可能你还希望在模型加载完成后在进行渴求式加载。举例来说,如果你想要动态的加载关联数据,那么load方法对你来说会非常有用:

$books = App\Book::all(); if ($someCondition) { $books->load('author', 'publisher'); }

如果你想要在渴求式加载的查询语句中进行条件约束,你可以通过数组的形式去加载,键为对应的关联关系,值为Closure闭包函数,该闭包的参数为一个query实例:

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

当关联关系没有被加载时,你可以使用loadMissing方法:

public function format(Book $book){ $book->loadMissing('author'); return [ 'name' => $book->name, 'author' => $book->author->name ]; }

嵌套延迟加载 &morphTo

如果希望快速加载morphTo关系,以及该关系可能返回的各种实体上的嵌套关系,可以使用loadMorph方法。

这个方法接受morphTo关系的名称作为它的第一个参数,第二个参数接收模型数组、关系数组。为了帮助说明这个方法,可以看一下以下模型例子:

morphTo(); } }

在这个例子中,让我们假设EventPhotoPost模型可以创建ActivityFeed模型。此外,让我们假设Event模型属于Calendar模型,Photo模型与Tag模型相关联,Post模型属于Author模型。

使用这些模型定义和关系,我们可以检索ActivityFeed模型实例,并立即加载所有parentable模型及其各自的嵌套关系:

$activities = ActivityFeed::with('parentable') ->get() ->loadMorph('parentable', [ Event::class => ['calendar'], Photo::class => ['tags'], Post::class => ['author'], ]);

插入 & 更新关联模型

保存方法

Eloquent 为新模型添加关联提供了便捷的方法。例如,也许你需要添加一个新的Comment到一个Post模型中。你不用在Comment中手动设置post_id属性,就可以直接使用关联模型的save方法将Comment直接插入:

$comment = new App\Comment(['message' => 'A new comment.']); $post = App\Post::find(1); $post->comments()->save($comment);

需要注意的是,我们并没有使用动态属性的方式访问comments关联。相反,我们调用comments方法来获得关联实例。save方法将自动添加适当的post_id值到Comment模型中。

如果你需要保存多个关联模型,你可以使用saveMany方法:

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

递归保存模型和关联数据

如果你想save你的模型及其所有关联数据,你可以使用push方法:

$post = App\Post::find(1); $post->comments[0]->message = 'Message'; $post->comments[0]->author->name = 'Author Name';$post->push();

新增方法

除了savesaveMany方法外,你还可以使用create方法。它接受一个属性数组,同时会创建模型并插入到数据库中。 还有,save方法和create方法的不同之处在于,save方法接受一个完整的 Eloquent 模型实例,而create则接受普通的 PHP 数组:

$post = App\Post::find(1); $comment = $post->comments()->create([ 'message' => 'A new comment.', ]);

{tip} 在使用create方法前,请务必确保查看过本文档的 批量赋值 章节。

你还可以使用createMany方法去创建多个关联模型:

$post = App\Post::find(1);$post->comments()->createMany([ [ 'message' => 'A new comment.', ], [ 'message' => 'Another new comment.', ], ]);

你还可以使用findOrNewfirstOrNewfirstOrCreateupdateOrCreate方法来 创建和更新关系模型.

更新belongsTo关联

当更新belongsTo关联时,可以使用associate方法。此方法将会在子模型中设置外键:

$account = App\Account::find(10); $user->account()->associate($account);$user->save();

当移除belongsTo关联时,可以使用dissociate方法。此方法会将关联外键设置为null:

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

默认模型

belongsTo关系允许你指定默认模型,当给定关系为null时,将会返回默认模型。 这种模式被称作Null 对象模式,可以减少你代码中不必要的检查。在下面的例子中,如果发布的帖子没有找到作者,user关系会返回一个空的App\User模型:

/** * 获取帖子的作者。 */ public function user(){ return $this->belongsTo('App\User')->withDefault(); }

如果需要在默认模型里添加属性, 你可以传递数组或者回调方法到withDefault中:

/** * 获取帖子的作者。 */ public function user(){ return $this->belongsTo('App\User')->withDefault([ 'name' => 'Guest Author', ]); } /** * 获取帖子的作者。 */ public function user(){ return $this->belongsTo('App\User')->withDefault(function ($user) { $user->name = 'Guest Author'; }); }

多对多关联

附加 / 分离

Eloquent 也提供了一些额外的辅助方法,使相关模型的使用更加方便。例如,我们假设一个用户可以拥有多个角色,并且每个角色都可以被多个用户共享。给某个用户附加一个角色是通过向中间表插入一条记录实现的,可以使用attach方法完成该操作:

$user = App\User::find(1); $user->roles()->attach($roleId);

在将关系附加到模型时,还可以传递一组要插入到中间表中的附加数据:

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

当然,有时也需要移除用户的角色。可以使用detach移除多对多关联记录。detach方法将会移除中间表对应的记录;但是这 2 个模型都将会保留在数据库中:

// 移除用户的一个角色... $user->roles()->detach($roleId); // 移除用户的所有角色... $user->roles()->detach();

为了方便,attachdetach也允许传递一个 ID 数组:

$user = App\User::find(1); $user->roles()->detach([1, 2, 3]); $user->roles()->attach([ 1 => ['expires' => $expires], 2 => ['expires' => $expires] ]);

同步关联

你也可以使用sync方法构建多对多关联。sync方法接收一个 ID 数组以替换中间表的记录。中间表记录中,所有未在 ID 数组中的记录都将会被移除。所以该操作结束后,只有给出数组的 ID 会被保留在中间表中:

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

你也可以通过 ID 传递额外的附加数据到中间表:

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

如果你不想移除现有的 ID,可以使用syncWithoutDetaching方法:

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

切换关联

多对多关联也提供了toggle方法用于「切换」给定 ID 数组的附加状态。 如果给定的 ID 已被附加在中间表中,那么它将会被移除,同样,如果如果给定的 ID 已被移除,它将会被附加:

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

在中间表上保存额外的数据

当处理多对多关联时,save 方法接收一个额外的数据数组作为第二个参数:

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

更新中间表记录

如果你需要在中间表中更新一条已存在的记录,可以使用updateExistingPivot。此方法接收中间表的外键与要更新的数据数组进行更新:

$user = App\User::find(1); $user->roles()->updateExistingPivot($roleId, $attributes);

更新父级时间戳

当一个模型属belongsTo或者belongsToMany另一个模型时, 例如Comment属于Post,有时更新子模型导致更新父模型时间戳非常有用。例如,当Comment模型被更新时,您要自动「触发」父级Post模型的updated_at时间戳的更新。Eloquent 让它变得简单。只要在子模型加一个包含关联名称的touches属性即可:

belongsTo('App\Post'); } }

现在,当你更新一个Comment时,对应父级Post模型的updated_at字段同时也会被更新,使其更方便得知何时让一个Post模型的缓存失效:

$comment = App\Comment::find(1); $comment->text = 'Edit to this comment!'; $comment->save();
本文章首发在 LearnKu.com网站上。