laravel学习教程之关联模型

2024-03-14 23:48:02 220

Eloquent:关联模型

简介

数据库中的表经常性的关联其它的表。比如，一个博客文章可以有很多的评论，或者一个订单会关联一个用户。Eloquent使管理和协作这些关系变的非常的容易，并且支持多种不同类型的关联：

一对一

一对多

多对多

远程一对多

多态关联

多态多对多关联

定义关联

Eloquent关联可以像定义方法一样在Eloquent模型类中进行定义。同时，它就像Eloquent模型自身一样也提供了强大的查询生成器。这允许关联模型可以链式的执行查询能力。比如：

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

但是，在更深入的使用关联之前，让我们先来学习一下如何定义各种类型的关联。

一对一

一对一的关联是最基础的关联。比如，一个User模型可能关联一个Phone。我们需要在User模型上放置一个phone方法来定义这种关联。phone方法应该返回一个基类Eloquent模型上hasOne方法的结果：

<?php

namespaceApp;

useIlluminate\Database\Eloquent\Model;

classUserextendsModel
{
/**
*Getthephonerecordassociatedwiththeuser.
*/
publicfunctionphone()
{
return$this->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模型上定义一个关联，让我们可以从Phone模型中访问其所属的User。我们使用belongsTo方法来定义hasOne相对的关联：

<?php

namespaceApp;

useIlluminate\Database\Eloquent\Model;

classPhoneextendsModel
{
/**
*Gettheuserthatownsthephone.
*/
publicfunctionuser()
{
return$this->belongsTo('App\User');
}
}

在上面的例子中，Eloquent将会尝试从Phone模型中的user_id字段中匹配查找id相同的User。Eloquent会依据所关联的模型的蛇形命名和_id来假定默认的外键名。事实上，如果在Phone模型上的外键不是user_id，那么你可以传递自定义的外键名到belongsTo方法的第二个参数：

/**
*Gettheuserthatownsthephone.
*/
publicfunctionuser()
{
return$this->belongsTo('App\User','foreign_key');
}

如果你的上级模型并没有使用id作为主键名，或者你希望下级模型关联一个不同的列。你可以传递第三个参数到belongsTo方法来指定上级模型表中的自定义键：

/**
*Gettheuserthatownsthephone.
*/
publicfunctionuser()
{
return$this->belongsTo('App\User','foreign_key','other_key');
}

一对多

一个一对多的关联常常用来定义一个模型拥有其他任意数目的模型。比如，一个博客文章可以拥有很多条评论。就像其他的Eloquent关联一样，一对多关联在Eloquent模型中通过方法来进行定义：

<?php

namespaceApp;

useIlluminate\Database\Eloquent\Model;

classPostextendsModel
{
/**
*Getthecommentsfortheblogpost.
*/
publicfunctioncomments()
{
return$this->hasMany('App\Comment');
}
}

记住，Eloquent会自动的根据Comment模型来判断合适的外键。依据惯例，Eloquent会使用自身模型的蛇形命名和_id来作为外键。所以，在这个例子中，Eloquent会假定Comment模型的外键是post_id。

一旦关联定义完成之后，我们可以通过comments属性来访问所有关联的评论的集合。记住，由于Eloquent提供了动态属性，我们可以对关联函数进行访问，就像他们是在模型中定义的属性一样：

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

foreach($commentsas$comment){
//
}

当然，由于所有的关联都提供了查询生成器的功能，所以你可以在调用comments方法时继续的添加一些限制条件，你可以通过链式的调用进行查询条件的添加：

$comments=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方法：

<?php

namespaceApp;

useIlluminate\Database\Eloquent\Model;

classCommentextendsModel
{
/**
*Getthepostthatownsthecomment.
*/
publicfunctionpost()
{
return$this->belongsTo('App\Post');
}
}

一旦关联被定义完成，我们就可以通过Comment模型的post动态属性来检索到其对应的Post模型：

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

echo$comment->post->title;

在上面的例子中，Eloquent会尝试从Comment模型中的post_id字段检索与其相对应id的Post模型。Eloquent会使用关联模型的蛇形命名和_id来作为默认的外键。如果Comment模型的外键不是post_id，你可以传递一个自定义的键名到belongsTo方法的第二个参数：

/**
*Getthepostthatownsthecomment.
*/
publicfunctionpost()
{
return$this->belongsTo('App\Post','foreign_key');
}

如果上层模型并没有使用id作为主键，或者你想在下层模型中关联其他的列，你可以传递第三个参数到belongsTo方法中：

/**
*Getthepostthatownsthecomment.
*/
publicfunctionpost()
{
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

namespaceApp;

useIlluminate\Database\Eloquent\Model;

classUserextendsModel
{
/**
*Therolesthatbelongtotheuser.
*/
publicfunctionroles()
{
return$this->belongsToMany('App\Role');
}
}

一旦关联被定义，你可以通过roles动态属性来访问用户的角色：

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

foreach($user->rolesas$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方法：

<?php

namespaceApp;

useIlluminate\Database\Eloquent\Model;

classRoleextendsModel
{
/**
*Theusersthatbelongstotherole.
*/
publicfunctionusers()
{
return$this->belongsToMany('App\User');
}
}

就如你所看到的，这个关联的定义与用户的关联定义完全相同。因为我们重复的使用了belongsToMany方法，当定义相对于多对多的关联时，所有常用的自定义数据表和键的选项都是可用的。

检索中间表字段

正如你已经了解到的。定义多对多的关联需要引入一个中间表。Eloquent提供了几种非常有帮助的方式来与这个表进行交互。比如，让我们假定我们的User对象关联到了很多Role对象。在访问这些关联对象时，我们可以通过在模型上使用pivot属性来访问中间表：

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

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

注意我们取出的每个Role对象，都会被自动的分配pivot属性。这个属性包含了一个代表中间表的模型，并且可以像其他Eloquent模型一样被使用。

默认的，只有模型的键会被pivot对象提供，如果你的中间表包含了额外的属性，你必须在定义关联时指定它们：

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

如果你想要中间表自动维护created_at和updated_at时间戳，你可以在定义关联时使用withTimestamps方法：

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

通过中间表字段过滤关系

你可以通过在定义关联时使用wherePrivot和wherePivotIn方法来在返回的结果中进行过滤：

return$this->belongsToMany('App\Role')->wherePivot('approved',1);

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

远程一对多

远程一对多关联提供了简短便捷的方法通过中间关联件来访问远端的关联。比如，一个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会通过中间表users的country_id来检索posts表中用户ID相匹配的记录。

现在我们已经明确了关联表的结构，那么让我们来在Country模型上定义关联：

<?php

namespaceApp;

useIlluminate\Database\Eloquent\Model;

classCountryextendsModel
{
/**
*Getallofthepostsforthecountry.
*/
publicfunctionposts()
{
return$this->hasManyThrough('App\Post','App\User');
}
}

传递到hasManyThrough方法的第一个参数是我们最终想要访问到的模型，而第二个参数则是中间层的模型名称。

当使用关联查询时，通常Eloquent会遵循外键约定。如果你希望对关联的键进行自定义，你可以传递第三和第四个参数到hasManyThrough方法。第三个参数是中间层模型的外键名称，第四个参数是最终想要获取的模型中的所对应的中间层的外键,而第五个参数则是当前模型的主键：

classCountryextendsModel
{
publicfunctionposts()
{
return$this->hasManyThrough(
'App\Post','App\User',
'country_id','user_id','id'
);
}
}

多态关联

表结构

多态关联允许一个模型在单个关联中从属一个或多个其它模型。比如，想象一下应用中的用户可以喜欢文章及其评论。如果使用多态关联，那么你就可以使用一个单独的likes表来关联这两个场景。首先，让我们确定定义这种关联所需要的表结构：

posts
id-integer
title-string
body-text

comments
id-integer
post_id-integer
body-text

likes
id-integer
likeable_id-integer
likeable_type-string

你需要注意到的两个在likes表中重要的字段likeable_id和likeable_type。likeable_id字段会包含文章或者评论的ID值，而likeable_type字段会包含其所属的模型的类名。likeable_type就是当访问likeable关联时ORM用来判断所属的模型是哪个类型。

模型结构

接着，让我们检查一下这个关联所需要的模型定义：

<?php

namespaceApp;

useIlluminate\Database\Eloquent\Model;

classlikeextendsModel
{
/**
*Getalloftheowninglikeablemodels.
*/
publicfunctionlikeable()
{
return$this->morphTo();
}
}

classPostextendsModel
{
/**
*Getallofthepost'slikes.
*/
publicfunctionlikes()
{
return$this->morphMany('App\Like','likeable');
}
}

classCommentextendsModel
{
/**
*Getallofthecomment'slikes.
*/
publicfunctionlikes()
{
return$this->morphMany('App\Like','likeable');
}
}

获取多态关联

一旦数据库表和模型都定义完成，你就可以在你的模型中访问这些关联。比如，你可以使用likes动态属性来访问文章中所有关联的likes模型:

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

foreach($post->likesas$like){
//
}

你也可以通过在模型上调用提供morphTo的方法来获取多态模型其关系所有者。在上面的例子中，指的就是Like模型中的likeable方法。所以，我们可以像使用动态属性一样使用方法来进行访问：

$like=App\Like::find(1);

$likeable=$like->likeable;

Like模型的likeable关联将会返回一个Post或者Comment实例，这取决于其所属者的类型。

自定义多态类型

默认的，Laravel会使用包完全限定类名来存储所关联模型的类型。比如，上面的例子中Like可以属于Post或者Comment。默认的likeable_type应该是App\Post或者App\Comment。事实上，你可能希望从你的应用程序的内部结构分离数据库。在这个例子中，你可以定义一个关联的多态映射来指导Eloquent使用模型关联的表名称来替代类名：

useIlluminate\Database\Eloquent\Relations\Relation;

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

或者，你可以指定一个自定的字符串与每个模型进行关联：

useIlluminate\Database\Eloquent\Relations\Relation;

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

你可以在你的AppServiceProvider或者一个分离的服务提供者的boot方法中注册你的morphMap。

多态多对多关联

表结构

除了传统的多态关联，你也可以定义多对多的多态关联。比如，一个博客的Post和Video模型应该可以共享一个多态关联的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

模型结构

接着，我们来定义模型中的关联。Post和Video模型将都会包含调用基础Eloquent类的morphToMany方法的tags方法：

<?php

namespaceApp;

useIlluminate\Database\Eloquent\Model;

classPostextendsModel
{
/**
*Getallofthetagsforthepost.
*/
publicfunctiontags()
{
return$this->morphToMany('App\Tag','taggable');
}
}

定义相对的关联

接着，在Tag模型中，你应该为所有关联模型定义相应的方法。所以，在这个例子中，我们将定义posts方法和videos方法：

<?php

namespaceApp;

useIlluminate\Database\Eloquent\Model;

classTagextendsModel
{
/**
*Getallofthepoststhatareassignedthistag.
*/
publicfunctionposts()
{
return$this->morphedByMany('App\Post','taggable');
}

/**
*Getallofthevideosthatareassignedthistag.
*/
publicfunctionvideos()
{
return$this->morphedByMany('App\Video','taggable');
}
}

获取关联

当定义完成数据表和模型之后，你就可以通过模型来访问其关联。比如，你可以简单的使用tags动态属性来访问文章的所有标签模型：

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

foreach($post->tagsas$tag){
//
}

你也可以通过访问模型中提供执行morphedByMany方法的方法来获取关联模型的所属模型。在上面的例子中，就是Tag模型上的posts或者videos方法。所以，你可以像动态属性一样访问这些方法：

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

foreach($tag->videosas$video){
//
}

关联查询

由于所有的Eloquent关联类型都是通过方法定义的，所以你可以调用这些方法来获取所关联的模型的实例而无需实际的执行关联查询。另外，所有的Eloquent关联也都提供了查询生成器服务，这允许你可以继续的链式执行查询操作。

比如，想象一下博客系统中User模型拥有很多Post关联的模型：

<?ph

namespaceApp;

useIlluminate\Database\Eloquent\Model;

classUserextendsModel
{
/**
*Getallofthepostsfortheuser.
*/
publicfunctionposts()
{
return$this->hasMany('App\Post');
}
}

你可以查询posts关联的同时添加一些额外的查询约束：

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

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

你应该注意到了，你可以在关联中使用任何的查询生成器的方法。

关联方法Vs.动态属性

如果你不需要在进行Eloquent关联查询时添加额外的约束，你可以简单的像它的属性一样进行访问。比如，我们继续使用User和Post示例模型。我们可以像这样来访问用户的所有文章：

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

foreach($user->postsas$post){
//
}

动态属性是惰性加载的，这意味着在你实际访问他们之前，其关联数据是不会加载的。正因为如此，开发的时候通常使用预加载来进行加载一些即将用到的关联模型。预加载要求必须加载一个模型的关系，这有效的减少了查询的次数。

查询关联是否存在

当访问一个模型的记录时，你可能会希望基于关联的记录是否存在来对结果进行限制。比如，想象一下你希望获取最少有一条评论的博客文章。你可以传递关联的名称到has方法来做这些：

//Retrieveallpoststhathaveatleastonecomment...
$posts=App\Post::has('comments')->get();

你也可以指定操作符，和数量来进一步定制查询：

//Retrieveallpoststhathavethreeormorecomments...
$posts=Post::has('comments','>=',3)->get();

你也可以使用.语法来构造嵌套的has语句。比如，你可以获取所有包含至少一条评论和投票的文章：

//Retrieveallpoststhathavaatleastonecommentwithvotes...
$posts=Post::has('comments.votes')->get();

如果你需要更高的控制，你可以使用whereHas和orWhereHas方法来在has查询中插入where子句。这些方法允许你为关联进行自定义的约束查询。比如检查评论的内容：

//Retrieveallpostswithatleastonecommentcontainingwordslikefoo%
$posts=Post::whereHas('comments',function($query){
$query->where('content','like','foo%');
})->get();

统计关联结果

如果你希望统计关联的结果而不实际的加载它们，你可以使用withCount方法，这将在你的结果模型中添加{relation}_count列。比如：

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

foreach($postsas$post){
echo$post->comments_count;
}

你也可以同时检索多个关联的统计，以及添加查询约束：

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

echo$posts[0]->votes_count;
echo$posts[0]->comments_count;

预加载

当通过属性访问Eloquent关联时，该关联的数据会被延迟加载。这意味着该关联数据只有在你真实的访问属性时才会进行加载。事实上，Eloquent可以在上层模型中一次性预加载的。预加载有效避免了N+1的查找问题。要说明N+1查找问题，我们可以来看一个Author关联Book的示例：

<?php

namespaceApp;

useIlluminate\Database\Eloquent\Model;

classBookextendsModel
{
/**
*Gettheauthorthatwrotethebook.
*/
publicfunctionauthor()
{
return$this->belongsTo('App\Author');
}
}

现在，让我们检索所有的书籍和他们的作者：

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

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

这个循环会执行一次查找回所有的书籍，接着每本书会运行一次查找作者的操作。所以，如果我们拥有25本书，那么循环将会进行26次查询：1次查询所有的书籍，25次查询相关书籍的作者。

非常幸运的，我们可以使用预加载来将查询有效的控制在2次。当查询时，使用with方法来指定关联的预加载：

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

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

对于这个操作，只会执行两个查询：

select*frombooks

select*fromauthorswhereidin(1,2,3,4,5,...)

预加载多个关联

有时候你可能需要在一个操作中预加载多个关联，你只需要传递额外的参数到with方法中就可以：

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

嵌套的预加载

你可以使用.语法来加载嵌套的关联。比如，让我们在一个Eloquent语句中一次加载所有书籍的作者以及作者的死人通讯簿：

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

预加载约束

有时候你可能希望预加载一些关联，但是也需要对预加载查询指定额外的约束，这里有个示例：

$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();

延迟预加载

有时候你可能需要在上层模型被获取后才预加载其关联。当你需要来动态决定是否加载关联模型时尤其有用:

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

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

如果你需要对预加载做一些查询约束，你可以传递Closure到load方法：

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

插入关系模型

Save方法

Eloquent提供了方便的方法来为模型添加一个关联。比如，也许你需要为Post模型新增一个Comment。除了手动的设置Comment的post_id属性，你也可以直接在关联模型中调用save方法来插入Comment:

$comment=newApp\Comment(['message'=>'Anewcomment.']);

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

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

注意上面我们并没有使用关联模型的动态属性的方式来访问comments，而是使用comments方法的形式来获取关联模型的实例。save方法会自动的添加相应的post_id值到新的Comment模型上。

如果你需要一次添加多个关联模型，你需要使用saveMany方法：

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

$post->comments()->saveMany([
newApp\Comment(['message'=>'Anewcomment.']),
newApp\Comment(['message'=>'Anothercomment.']),
]);

Save&多对多关联

当与多对多关联互动时，save方法接收一个中间层表属性的额外参数数组作为第二个参数：

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

Create方法

除了save和saveMany方法之外，你也可以使用create方法，它可以接收属性组成的数组，创建一个模型并且将其存储到数据库。这一次，save和create方法的区别是save接收一个完整的Eloquent模型实例，而create接收的是一个原生的PHParray:

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

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

在使用create方法之前，你应该确保已经阅读了属性的批量赋值文档。

更新从属关联模型

当更新一个belongsTo关联时，你应该使用associate方法。这个方法会在下层模型中设置外键：

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

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

$user->save();

当删除belongsTo关联时，你应该使用dissociate方法，该方法会重置下层模型所关联的外键：

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

$user->save();

多对多关联

附加/抽离

当使用多对多关联时，Eloquent提供了一些额外的帮助方法来更方便的管理关联模型。比如，让我们想象一下用户可以有很多角色并且角色可以有很多用户。你可以使用attach方法来附加一个角色到用户并且在中间表中加入这条记录：

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

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

当附加关联到模型时，你也可以传递一个含有额外数据的数组来将其添加到中间表中：

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

当然，有时候你可能需要从用户中删除一个角色。你可以使用detach方法来删除多对多关联的记录。datech方法将从中间表中删除相应的记录。但是，除了中间表，其它两个模型的记录都还会被保留：

//Detachasinglerolefromtheuser...
$user->roles()->detach($roleId);

//Detachallrolesfromtheuser...
$user->roles()->detach();

为了更加的便捷，attach和detach也可以接收IDs所组成的数组作为输入：

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

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

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

更新中间表的记录

如果你需要更新中间表中存在的行，你可以使用updateExistingPivot方法：

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

$user->roles()->updateExistingPivot($roleId,$attributes);

便利的同步

你也可以使用sync方法来构建多对多的关联。sync方法接收放置中间表IDs所组成的数组。任意IDs如果没有在所给定的数组中，那么其将会从中间表中进行删除。所以，在操作完成之后，只有存在于给定数组里的IDs才会存在于中间表中：

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

你也可以同时传递额外的中间表的键值对：

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

联动上层模型时间戳

当一个模型belongsTo或者belongsToMany另外一个模型时，比如Comment从属于Post，这对下层模型更新时同时要求更新上层模型的时间戳时很有帮助。比如，当Comment模型更新了，你想要自动的更新其所属的Post模型的updated_at时间戳。Eloquent使之变的非常容易。你只需要在下层模型中添加一个touches属性来包含关联的名称就可以了：

<?php

namespaceApp;

useIlluminate\Database\Eloquent\Model;

classCommentextendsModel
{
/**
*Alloftherelationshipstobetouched.
*
*@vararray
*/
protected$touches=['post'];

/**
*Getthepostthatthecommentbelongsto.
*/
publicfunctionpost()
{
return$this->belongsTo('App\Post');
}
}

现在，当你更新Comment时，其所属的Post将会同时更新updated_at列：

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

$comment->text='Edittothiscomment!';

$comment->save();

以上就是laravel学习教程之关联模型的全部内容，希望对大家学习php有所帮助。

laravel学习教程之关联模型

热门推荐

随机推荐