Laravel远程关联？远程一对多如何实现？-Laravel-PHP中文网

Laravel的远程一对多关联通过hasManyThrough实现，允许模型A经由模型B访问模型C。其底层基于JOIN查询，需注意键名自定义、预加载避免N+1问题及仅支持两跳关联的限制。

laravel远程关联？远程一对多如何实现？

Laravel中的“远程关联”或“远程一对多”（Remote Has Many）通常指的是

hasManyThrough

登录后复制

这类关联，它允许你通过一个中间模型来访问一个不直接关联的模型。简单来说，就是模型A想获取模型C的数据，但A和C之间没有直接的键，它们都通过模型B建立了联系。这种关联机制在处理多层级数据结构时非常有用，能让我们的代码更简洁，也更符合ORM的设计哲学。

解决方案

实现Laravel的远程一对多关联，最常用的就是

hasManyThrough

登录后复制

方法。这个方法的核心思想是，你有一个模型（比如

Country

登录后复制

），想获取另一个不直接关联的模型（比如

Post

登录后复制

）的集合，而这两个模型之间通过第三个模型（比如

User

登录后复制

）建立联系。

我们来看一个具体的例子：假设我们有国家（Country）、用户（User）和文章（Post）三个模型。一个国家有多个用户，一个用户有多篇文章。现在，我们想直接获取某个国家下的所有文章。

数据库结构示例：

立即进入“豆包AI人工智官网入口”；

立即学习“豆包AI人工智能在线问答入口”；

```
countries
```
登录后复制
表:
```
id
```
登录后复制
,
```
name
```
登录后复制
```
users
```
登录后复制
表:
```
id
```
登录后复制
,
```
name
```
登录后复制
,
```
country_id
```
登录后复制
```
posts
```
登录后复制
表:
```
id
```
登录后复制
,
```
title
```
登录后复制
,
```
user_id
```
登录后复制

模型定义：

首先，确保你的模型之间已经建立了直接的关联：

// app/Models/Country.php
namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Country extends Model
{
    // 一个国家有多个用户
    public function users()
    {
        return $this->hasMany(User::class);
    }

    // 接下来我们要添加远程一对多关联
    public function posts()
    {
        // 第一个参数是最终要关联的模型 (Post)
        // 第二个参数是中间模型 (User)
        return $this->hasManyThrough(Post::class, User::class);
    }
}

登录后复制

// app/Models/User.php
namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;

class User extends Model
{
    use HasFactory;

    // 一个用户属于一个国家
    public function country()
    {
        return $this->belongsTo(Country::class);
    }

    // 一个用户有多篇文章
    public function posts()
    {
        return $this->hasMany(Post::class);
    }
}

登录后复制

// app/Models/Post.php
namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;

class Post extends Model
{
    use HasFactory;

    // 一篇文章属于一个用户
    public function user()
    {
        return $this->belongsTo(User::class);
    }
}

登录后复制

如何使用：

现在，你就可以像访问普通关联一样，获取一个国家下的所有文章了：

$country = Country::find(1);
$posts = $country->posts; // 获取该国家所有用户的文章集合

登录后复制

Laravel在底层会执行一个JOIN查询，将

countries

登录后复制

表、

users

登录后复制

表和

posts

登录后复制

表连接起来，从而高效地获取数据。这种方式，在我看来，确实大大提升了开发效率，避免了手动编写复杂的SQL JOIN语句，也让业务逻辑在模型层面更加清晰。

Laravel hasManyThrough关联的底层原理是什么？它与传统关联有何不同？

hasManyThrough

登录后复制

关联的底层原理，其实就是数据库的

JOIN

登录后复制

操作。当你在模型中定义了

hasManyThrough

登录后复制

关系并尝试访问它时，Laravel的Eloquent ORM会在幕后构建一个SQL查询，通常会包含两个

INNER JOIN

登录后复制

语句。

以我们上面的

Country

登录后复制

通过

User

登录后复制

获取

Post

登录后复制

的例子来说，Laravel会生成类似于这样的SQL查询：

SELECT
    posts.*
FROM
    posts
INNER JOIN
    users ON users.id = posts.user_id
INNER JOIN
    countries ON countries.id = users.country_id
WHERE
    countries.id = ?; -- 这里的问号就是你查询的Country的ID

登录后复制

它首先将

posts

登录后复制

表与

users

登录后复制

表连接（通过

posts.user_id = users.id

登录后复制

），然后将结果与

countries

登录后复制

表连接（通过

users.country_id = countries.id

登录后复制

）。这样，通过两次连接，就从

posts

登录后复制

表中筛选出了属于特定国家的所有文章。

与传统关联的不同之处：

传统的

hasMany

登录后复制

或

belongsTo

登录后复制

关联，通常只涉及两个模型和它们之间直接的、通过外键建立的联系。

hasMany
登录后复制
(例如
User
登录后复制
-youjiankuohaophpcn
Post
登录后复制
):
```
User
```
登录后复制
模型直接通过
```
id
```
登录后复制
关联
```
Post
```
登录后复制
模型的
```
user_id
```
登录后复制
。只需要一次查询或一个简单的
```
WHERE
```
登录后复制
条件。
belongsTo
登录后复制
(例如
Post
登录后复制
->
User
登录后复制
):
```
Post
```
登录后复制
模型直接通过
```
user_id
```
登录后复制
关联
```
User
```
登录后复制
模型的
```
id
```
登录后复制
。同样只需要一次查询。

而

hasManyThrough

登录后复制

则引入了“中间模型”的概念。它跳过了一个层级，让两个原本没有直接外键关系的模型能够通过第三个模型间接关联起来。这种“跳跃式”的关联是它最核心的特点。在我个人的开发经验中，这种机制特别适用于那些层级分明、但又需要跨层级查询数据的场景，比如一个部门（Department）有很多项目（Project），每个项目有很多任务（Task），你想直接获取一个部门下的所有任务，

hasManyThrough

登录后复制

就能派上用场。它让代码看起来更“扁平化”，减少了手动链式调用多个关联的麻烦。

豆包AI编程

豆包推出的AI编程助手

483

查看详情

如何自定义hasManyThrough关联的键名和表名？

hasManyThrough

登录后复制

方法默认会遵循Laravel的命名约定来猜测外键和本地键，但实际项目中，表名或键名可能不按常规来。这时，我们就需要手动指定这些参数。

hasManyThrough

登录后复制

方法接受四个额外的参数来帮助你精确控制关联的键名。

方法签名大致是这样的：

hasManyThrough(
    string $related,
    string $through,
    string $firstForeignKey = null, // 中间模型（through）在当前模型（this）上的外键
    string $secondForeignKey = null, // 最终模型（related）在中间模型（through）上的外键
    string $firstLocalKey = null, // 当前模型（this）的本地键
    string $secondLocalKey = null // 中间模型（through）的本地键
)

登录后复制

我们继续使用

Country

登录后复制

、

User

登录后复制

、

Post

登录后复制

的例子，假设：

```
users
```
登录后复制
表中，关联
```
countries
```
登录后复制
的字段不是
```
country_id
```
登录后复制
，而是
```
country_ref
```
登录后复制
。
```
posts
```
登录后复制
表中，关联
```
users
```
登录后复制
的字段不是
```
user_id
```
登录后复制
，而是
```
author_id
```
登录后复制
。
```
countries
```
登录后复制
表的主键不是
```
id
```
登录后复制
，而是
```
country_uuid
```
登录后复制
。
```
users
```
登录后复制
表的主键不是
```
id
```
登录后复制
，而是
```
user_uuid
```
登录后复制
。

那么，

Country

登录后复制

模型中的

posts

登录后复制

关联就需要这样定义：

// app/Models/Country.php
namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Country extends Model
{
    protected $primaryKey = 'country_uuid'; // 假设主键是 country_uuid

    public function posts()
    {
        return $this->hasManyThrough(
            Post::class,
            User::class,
            'country_ref',    // 'users' 表中的外键，指向 'countries' 表的键 (country_uuid)
            'author_id',      // 'posts' 表中的外键，指向 'users' 表的键 (user_uuid)
            'country_uuid',   // 'countries' 表的本地键
            'user_uuid'       // 'users' 表的本地键
        );
    }
}

登录后复制

// app/Models/User.php
namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;

class User extends Model
{
    use HasFactory;

    protected $primaryKey = 'user_uuid'; // 假设主键是 user_uuid
    protected $foreignKey = 'country_ref'; // 假设关联 country 的外键是 country_ref

    public function country()
    {
        return $this->belongsTo(Country::class, 'country_ref', 'country_uuid');
    }

    public function posts()
    {
        return $this->hasMany(Post::class, 'author_id', 'user_uuid');
    }
}

登录后复制

// app/Models/Post.php
namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;

class Post extends Model
{
    use HasFactory;

    protected $foreignKey = 'author_id'; // 假设关联 user 的外键是 author_id

    public function user()
    {
        return $this->belongsTo(User::class, 'author_id', 'user_uuid');
    }
}

登录后复制

这里需要注意的是参数的顺序和它们各自代表的意义：

```
Post::class
```
登录后复制
：你最终想要获取的模型。
```
User::class
```
登录后复制
：作为桥梁的中间模型。
```
'country_ref'
```
登录后复制
：
```
User
```
登录后复制
模型中指向
```
Country
```
登录后复制
模型的外键（即
```
users.country_ref
```
登录后复制
）。
```
'author_id'
```
登录后复制
：
```
Post
```
登录后复制
模型中指向
```
User
```
登录后复制
模型的外键（即
```
posts.author_id
```
登录后复制
）。
```
'country_uuid'
```
登录后复制
：
```
Country
```
登录后复制
模型本身的本地键（即
```
countries.country_uuid
```
登录后复制
）。
```
'user_uuid'
```
登录后复制
：
```
User
```
登录后复制
模型本身的本地键（即
```
users.user_uuid
```
登录后复制
）。

通过这种方式，无论你的数据库命名有多么“非主流”，你都可以灵活地配置

hasManyThrough

登录后复制

关联。这给了我们极大的自由度，在面对遗留系统或特殊命名规范的数据库时，显得尤为重要。

hasManyThrough关联有哪些常见的陷阱或性能考量？

hasManyThrough

登录后复制

关联虽然强大，但在使用时确实有一些需要注意的地方，否则可能会踩到一些“坑”，或者导致性能问题。

一个比较明显的限制是，

hasManyThrough

登录后复制

目前只支持通过一个中间模型进行关联。这意味着它只能处理“A -> B -> C”这种两跳的关联。如果你需要“A -> B -> C -> D”这种三跳或更多跳的远程关联，

hasManyThrough

登录后复制

就无能为力了。在这种情况下，你可能需要考虑手动编写查询范围（query scope）、使用原始SQL JOIN语句，或者将更复杂的逻辑封装到Repository层。这在我看来是一个设计上的取舍，Laravel可能觉得再多一层就会让ORM的抽象变得过于复杂，不如交给开发者自行处理。

性能考量方面：

N+1 查询问题： 尽管
```
hasManyThrough
```
登录后复制
本身在加载单个模型时会执行一个高效的JOIN查询，但如果你在一个集合上循环并分别访问每个模型的
```
hasManyThrough
```
登录后复制
关联，就可能导致N+1问题。例如：
```
$countries = Country::all();
foreach ($countries as $country) {
    // 这里每次循环都会触发一个 hasManyThrough 查询
    // 如果有N个国家，就会有N+1次查询（1次获取所有国家，N次获取文章）
    echo $country->posts->count();
}
```
登录后复制
解决办法是使用预加载（Eager Loading），通过
```
with()
```
登录后复制
方法来加载关联：
```
$countries = Country::with('posts')->get();
foreach ($countries as $country) {
    // posts 已经被预加载，不会再触发额外查询
    echo $country->posts->count();
}
```
登录后复制
预加载
```
hasManyThrough
```
登录后复制
关联会生成一个更复杂的SQL查询，通常会包含
```
LEFT JOIN
```
登录后复制
或
```
UNION
```
登录后复制
等，但它能显著减少数据库查询次数，提升整体性能。
复杂的JOIN操作：
```
hasManyThrough
```
登录后复制
在底层会执行至少两次
```
INNER JOIN
```
登录后复制
。如果你的表非常大，或者JOIN的字段没有建立索引，那么这些查询可能会变得非常慢。确保所有用于JOIN的键（外键和本地键）都建立了数据库索引，这是优化这类查询最基本也是最有效的方法。我个人在处理大数据量时，总是会优先检查索引情况，因为这往往是性能瓶颈的根源。
误用场景： 有时候，开发者可能会将
```
hasManyThrough
```
登录后复制
与
```
belongsToMany
```
登录后复制
混淆。如果你的“中间模型”实际上只是一个纯粹的枢纽表（pivot table），用来连接两个模型形成多对多关系，那么
```
belongsToMany
```
登录后复制
才是更合适的选择。
```
hasManyThrough
```
登录后复制
更适用于中间模型本身也包含有意义的数据，并且是单向多对多（或者说，通过中间模型进行一对多）的场景。例如，一个
```
Role
```
登录后复制
有很多
```
Permission
```
登录后复制
，通过
```
RoleUser
```
登录后复制
枢纽表，那么
```
User
```
登录后复制
和
```
Role
```
登录后复制
是
```
belongsToMany
```
登录后复制
，而不是
```
hasManyThrough
```
登录后复制
。