PHP `ORM` `N+1 Query Problem` 的深层原因与解决方案

各位观众老爷们，大家好！今天咱们来聊聊 PHP ORM 里那个让人头疼的“N+1 查询问题”。这玩意儿就像鼻涕虫一样，不致命，但膈应人。咱们要做的，就是把这条鼻涕虫揪出来，然后踩死它！

第一章：什么是 N+1 查询？—— 简单粗暴的解释

想象一下，你是一个包工头（ORM），手下有一堆工人（数据库）。现在你接到一个任务：找出所有客户，并列出每个客户的最新订单。

正常情况（一次查询）： 你一声令下，工人吭哧吭哧把所有客户和他们的最新订单都给你整理好，一次性交给你。效率杠杠的。
N+1 查询： 你先让工人给你找出所有客户（一次查询），然后你一个个问：“这个客户的最新订单呢？”、“那个客户的最新订单呢？”…… 你有多少个客户，工人就要跑多少次腿（N次查询）。

这就是 N+1 查询的本质：先执行一次查询获取主对象列表，然后对列表中的每个对象再执行一次查询获取关联数据。结果就是，本来一次就能搞定的事情，硬生生变成了 N+1 次。

第二章：PHP ORM 里的 N+1 陷阱 —— 代码说话

咱们以 Laravel Eloquent ORM 为例，当然，其他 ORM 框架也差不多一个尿性。

// 模型定义 (假设我们有 Customer 模型 和 Order 模型，并且 Customer hasMany Order)

use IlluminateDatabaseEloquentModel;

class Customer extends Model
{
    public function orders()
    {
        return $this->hasMany(Order::class);
    }
}

class Order extends Model
{
    public function customer()
    {
        return $this->belongsTo(Customer::class);
    }
}

// 控制器代码
public function index()
{
    $customers = Customer::all(); // 获取所有客户 (1次查询)

    foreach ($customers as $customer) {
        $latestOrder = $customer->orders()->latest()->first(); // 对每个客户执行一次查询 (N次查询)
        echo "Customer: " . $customer->name . ", Latest Order: " . ($latestOrder ? $latestOrder->order_number : 'No Order') . "<br>";
    }
}

这段代码，表面上看起来人畜无害，但跑起来你就知道什么叫“慢如蜗牛”了。 Customer::all() 这句执行一次查询，没毛病。但是，$customer->orders()->latest()->first() 这句，在循环里被执行了 N 次！ N 等于客户的数量。如果你有 1000 个客户，就要执行 1001 次查询。这就是活生生的 N+1 查询案例。

第三章：N+1 的危害 —— 不止是慢

性能瓶颈： 数据库连接是有限的资源，频繁的查询会占用大量连接，导致其他请求响应变慢。
资源浪费： 数据库服务器要处理更多的查询请求，消耗更多的 CPU 和内存。
响应时间延长： 用户等待时间变长，用户体验下降。这点最致命。

第四章：N+1 的解决方案 —— 各显神通

既然知道了问题所在，咱们就要对症下药，把 N+1 扼杀在摇篮里。

1. 预加载（Eager Loading）：

这是最常用，也是最有效的解决方案。预加载的意思是，在获取主对象的时候，顺便把关联数据也一起取出来。这样就避免了后续的 N 次查询。

// 修改后的控制器代码
public function index()
{
    $customers = Customer::with(['orders' => function ($query) {
        $query->latest()->limit(1); // 只获取最新的订单
    }])->get();  // 一次查询，获取所有客户和他们的最新订单

    foreach ($customers as $customer) {
        $latestOrder = $customer->orders->first(); // 直接从预加载的数据中获取
        echo "Customer: " . $customer->name . ", Latest Order: " . ($latestOrder ? $latestOrder->order_number : 'No Order') . "<br>";
    }
}

Customer::with('orders') 告诉 ORM 在获取客户的时候，顺便把订单也取出来。 Laravel 内部会使用 JOIN 语句，将两个表连接起来，一次性获取所有数据。 $customer->orders 现在直接从已经加载的数据中获取，不再执行额外的查询。

更进一步：限制预加载的数量

如果订单数量很多，一次性加载所有订单可能会导致性能问题。我们可以使用闭包函数来限制预加载的数量，只加载最新的订单。$query->latest()->limit(1) 就是用来限制只加载最新的一个订单的。

2. 连接查询（JOIN）：

如果只需要部分关联数据，可以使用连接查询来手动构建 SQL 语句。

// 使用 DB facade 手动构建查询
use IlluminateSupportFacadesDB;

public function index()
{
    $customers = DB::table('customers')
        ->leftJoin('orders', 'customers.id', '=', 'orders.customer_id')
        ->select('customers.*', 'orders.order_number')
        ->get();

    foreach ($customers as $customer) {
        echo "Customer: " . $customer->name . ", Order: " . $customer->order_number . "<br>";
    }
}

这种方式比较灵活，可以根据需要选择需要的字段，但需要手动编写 SQL 语句，有一定的学习成本。而且，返回的结果是标准对象，不是模型对象，无法使用模型的方法。

3. 使用延迟加载（Lazy Loading）：

延迟加载是一种折中的方案。它在获取主对象的时候不加载关联数据，只有在访问关联数据的时候才执行查询。

//  和最开始的代码一样，但是开启了延迟加载
public function index()
{
    $customers = Customer::all(); // 获取所有客户 (1次查询)

    foreach ($customers as $customer) {
        $latestOrder = $customer->orders()->latest()->first(); // 对每个客户执行一次查询 (N次查询)
        echo "Customer: " . $customer->name . ", Latest Order: " . ($latestOrder ? $latestOrder->order_number : 'No Order') . "<br>";
    }
}

虽然看起来和最开始的代码一样，但如果 ORM 开启了延迟加载，它会在访问 $customer->orders 的时候才执行查询。理论上，延迟加载可以避免一次性加载所有关联数据带来的性能问题。但实际上，如果需要访问所有对象的关联数据，延迟加载仍然会导致 N+1 查询。因此，延迟加载只适用于那些只需要访问部分对象关联数据的场景。

4. 使用数据转换（Data Transformation）：

如果需要对关联数据进行复杂的处理，可以先获取所有主对象和关联数据，然后在 PHP 代码中进行转换。

public function index()
{
    $customers = Customer::with('orders')->get();

    $transformedCustomers = $customers->map(function ($customer) {
        $latestOrder = $customer->orders->sortByDesc('created_at')->first();
        return [
            'customer_name' => $customer->name,
            'latest_order_number' => $latestOrder ? $latestOrder->order_number : null,
        ];
    });

    foreach ($transformedCustomers as $customerData) {
        echo "Customer: " . $customerData['customer_name'] . ", Latest Order: " . $customerData['latest_order_number'] . "<br>";
    }
}

这种方式的优点是可以灵活地处理数据，但缺点是需要在 PHP 代码中进行大量的计算，可能会消耗大量的 CPU 资源。

5. 使用缓存（Caching）：

如果关联数据不经常变化，可以使用缓存来减少数据库查询次数。

use IlluminateSupportFacadesCache;

public function index()
{
    $customers = Cache::remember('customers_with_latest_orders', 60, function () {
        return Customer::with(['orders' => function ($query) {
            $query->latest()->limit(1);
        }])->get();
    });

    foreach ($customers as $customer) {
        $latestOrder = $customer->orders->first();
        echo "Customer: " . $customer->name . ", Latest Order: " . ($latestOrder ? $latestOrder->order_number : 'No Order') . "<br>";
    }
}

Cache::remember() 会将查询结果缓存 60 秒。在缓存有效期内，不会执行数据库查询，直接从缓存中获取数据。但要注意缓存的更新策略，避免缓存数据过期或者不一致。

第五章：选择哪种方案？—— 没有银弹

没有一种方案是万能的，选择哪种方案取决于具体的场景。

方案	优点	缺点	适用场景
预加载	简单易用，性能提升明显	加载所有关联数据，可能会导致性能问题	需要访问大部分对象关联数据的场景
连接查询	灵活，可以只选择需要的字段	需要手动编写 SQL 语句，学习成本高，返回的是标准对象，不是模型对象	只需要部分关联数据，并且需要对数据进行复杂的过滤和排序的场景
延迟加载	可以避免一次性加载所有关联数据带来的性能问题	如果需要访问所有对象的关联数据，仍然会导致 N+1 查询	只需要访问部分对象关联数据的场景
数据转换	灵活，可以对关联数据进行复杂的处理	需要在 PHP 代码中进行大量的计算，可能会消耗大量的 CPU 资源	需要对关联数据进行复杂的处理的场景
缓存	可以减少数据库查询次数	需要考虑缓存的更新策略，避免缓存数据过期或者不一致	关联数据不经常变化的场景

第六章：避免 N+1 的最佳实践 —— 防患于未然

代码审查： 在代码提交之前，进行代码审查，检查是否存在 N+1 查询的隐患。
性能测试： 在开发过程中，进行性能测试，及时发现和解决 N+1 查询问题。
使用 ORM 提供的工具： 一些 ORM 框架提供了工具来检测 N+1 查询。例如，Laravel Telescope 可以监控应用程序的查询情况，帮助你发现 N+1 查询。
理解 ORM 的工作原理： 深入理解 ORM 的工作原理，才能更好地避免 N+1 查询。
不要过度依赖 ORM： ORM 只是一个工具，不要过度依赖它。在某些情况下，手动编写 SQL 语句可能更高效。
养成良好的编程习惯： 写代码的时候多思考，多考虑性能问题，避免写出低效的代码。

第七章：调试 N+1 查询 —— 蛛丝马迹

如果你怀疑代码中存在 N+1 查询，可以使用以下方法进行调试：

数据库查询日志： 开启数据库查询日志，查看执行了哪些 SQL 语句。如果发现执行了大量的相似查询，很可能存在 N+1 查询。
ORM 提供的调试工具： 一些 ORM 框架提供了调试工具，可以帮助你分析查询情况。例如，Laravel Telescope 可以显示每个请求执行的 SQL 语句，以及执行时间。
使用性能分析工具： 使用性能分析工具，例如 Xdebug，可以分析代码的执行流程，找出性能瓶颈。

总结：

N+1 查询是 PHP ORM 中一个常见的性能问题，但只要掌握了正确的解决方案，就可以有效地避免它。记住，没有银弹，选择哪种方案取决于具体的场景。最重要的是，养成良好的编程习惯，防患于未然。

好了，今天的讲座就到这里。希望大家以后都能远离 N+1 查询，写出高效的代码！散会！

发表回复 取消回复

发表回复取消回复