ThinkPHP 8 列表接口性能排查实录:187 条 SQL 是怎么被压到 4 条的

2026-11-20 0 480

上周三运营在群里发了一张截图,订单列表页转圈转了四五秒才出来,底下配了一句「今天特别慢,客户在催」。我先看监控:4 台机器 CPU 都在 40% 以下,内存正常,带宽也没跑满。服务器没问题,那就是代码问题。

这个接口上线快一年了一直没出过事,最近两周订单量涨了三倍多,估计是数据量上去以后某个地方开始绷不住了。下面把排查和改造的完整过程写一遍,中间有几个坑挺隐蔽的,记下来免得下次再踩。

一、先确认慢在哪

接口路径是 /api/order/list,返回一页 20 条订单,每条订单要带下单用户昵称头像、关联商品明细、物流单号。线上开了 app_debug 但只对内部 IP 放行,我在本地复现之后打开 trace 面板,第一眼就看到 SQL 列表长得吓人——往下滚了大概十几屏才到底,右上角统计写着 187 次查询,累计耗时 1013ms。

整个接口的响应时间是 1180ms,也就是说光数据库查询就占了 85%。剩下的 160 多毫秒是 PHP 序列化和模板处理,这部分正常。

187 条 SQL 是怎么来的?一页 20 条订单,每条订单里出现了这么一串:

  • 查用户信息 1 次
  • 查商品明细 1 次(平均 3 条明细)
  • 查物流记录 1 次

20 × 3 = 60 次关联查询,再加上主查询 1 次,应该是 61 条。但实际是 187 条,多出来的那一百多次是因为控制器里对每条明细又单独查了一次商品主表拿封面图——这个写法当时是为了「代码简单」,现在成了最大的雷。

加上分页自带的 count 查询,加上几个权限判断的附加查询,187 这个数字对上了。

二、N+1 的本质

这种写法有个通用名字叫 N+1 查询:一次主查询拿到 N 条记录,然后循环里再对每条记录发起查询,总共 1 + N 次往返。数据库每次往返就算只有 1 毫秒,200 次也是 200 毫秒,更别说还有网络和连接池的抖动。

看下原来的代码大概长这样:

public function list()
{
    $page = (int) $this->request->get('page', 1);
    $pages = OrderModel::where('status', '>', 0)
        ->order('id desc')
        ->paginate(20, false, ['page' => $page]);

    $list = [];
    foreach ($pages as $order) {
        $item = [
            'order_no'  => $order->order_no,
            'amount'    => $order->amount,
            'user'      => Db::name('user')->where('id', $order->user_id)
                             ->field('id, nickname, avatar')->find(),
            'items'     => [],
            'logistics' => Db::name('logistics')->where('order_id', $order->id)
                             ->field('company, tracking_no')->find(),
        ];

        $items = Db::name('order_item')->where('order_id', $order->id)->select();
        foreach ($items as $it) {
            $goods = Db::name('goods')->where('id', $it['goods_id'])
                       ->field('cover, title')->find();
            $item['items'][] = [
                'title'  => $goods['title'],
                'cover'  => $goods['cover'],
                'num'    => $it['num'],
                'price'  => $it['price'],
            ];
        }
        $list[] = $item;
    }

    return json(['code' => 0, 'data' => $list]);
}

这段代码逻辑没错,问题是它把三次关联查询全都写在了循环体里。数据量小的时候看不出来,20 条订单跑个 60 次查询也就 50 毫秒,一页数据量一大就原形毕露。

三、用 Db::listen 抓慢 SQL,而不是靠猜

光看 trace 面板知道「慢」,但具体哪一条慢,面板只显示前几十条,后面被截断了。我在全局事件里加了一个慢查询日志,超过 100 毫秒就记下来:

<?php
// app/event.php 或者 app/common.php
use thinkfacadeDb;
use thinkfacadeLog;

Db::listen(function ($sql, $time, $explain) {
    if ($time > 0.1) {
        Log::warning(sprintf('slow sql %.3fs | %s', $time, $sql), 'sql');
    }
});

不同版本的 think-orm 回调参数略有差异,有的版本第三个参数是 explain 结果数组,有的是空的,具体以实际安装的版本为准。我这里只用了前两个,够用。

跑了一次列表页,日志里出现最多的一条是:

SELECT `cover`,`title` FROM `goods` WHERE `id` = 38412 LIMIT 1

单条 0.8ms,看着不多,但它执行了 137 次。累计 100 多毫秒。而且这条 SQL 完全可以用主查询一次性拿回来,不需要每条明细都查一遍。确认了问题所在,开始动手。

四、第一次改造:预载入

ThinkPHP 的模型关联支持预载入,用 with() 把关联数据一次性查出来,之后访问属性就是内存操作,不再触发 SQL。

先定义好模型关联:

<?php
namespace appmodel;

use thinkModel;

class Order extends Model
{
    public function user()
    {
        return $this->belongsTo(User::class, 'user_id', 'id');
    }

    public function items()
    {
        return $this->hasMany(OrderItem::class, 'order_id', 'id');
    }

    public function logistics()
    {
        return $this->hasOne(Logistics::class, 'order_id', 'id');
    }
}

控制器改写成这样:

$pages = OrderModel::with([
    'user' => function ($query) {
        $query->field('id, nickname, avatar');
    },
    'items' => function ($query) {
        $query->field('id, order_id, goods_id, num, price');
    },
    'items.goods' => function ($query) {
        $query->field('id, title, cover');
    },
    'logistics' => function ($query) {
        $query->field('id, order_id, company, tracking_no');
    },
])->where('status', '>', 0)
  ->order('id desc')
  ->paginate(20, false, ['page' => $page]);

然后在模板或者序列化里直接访问 $order->user->nickname、$order->items,模型会自动使用预载入的数据,不会再走数据库。

这次改完,SQL 从 187 条降到了 6 条,接口响应从 1180ms 降到 640ms。看起来有效,但还不够,离我的目标 150ms 还有距离。

五、坑一:field 里漏了外键,关联直接失效

改完之后我在测试环境翻了一条数据,发现用户的昵称是空的。检查了一下 user 关联的 field 列表:'id, nickname, avatar',没问题啊。

问题出在 items 那层。items.goods 的预载入依赖 items 里返回的 goods_id,如果 items 那层的 field 把 goods_id 裁掉了,嵌套预载入就找不到关联键,goods 数据整片是空的,而且不会报错。

这就是 with 的 field 写法必须遵守的规则:本级对外暴露的主键要被父层用、本级关联到子层要用的外键、以及所有你要展示的字段,三者必须都写进 field。

我在 items 那层写了 id, order_id, goods_id, num, price,五个字段一个不能少。order_id 是让父层 order 能匹配上的,goods_id 是让 items.goods 这层能关联上的,id 是模型自身需要的。

漏写这个坑很隐蔽,因为不报错,数据缺了你可能都发现不了,只有前端反馈「商品图片是空的」才开始查。

六、坑二:paginate 的 count 查询才是大头

SQL 只剩 6 条之后,我逐条看了耗时,发现主查询 40ms,四个 with 查询加起来 60ms,但还有一条 SELECT COUNT(*) FROM order WHERE status > 0 占了 380ms。

订单表已经是两千万级的数据,虽然 status 上有索引,但这个 count 需要回表判断,扫描的行数非常多,没法走覆盖索引。每次翻页都要算一次总数,这就是拖慢的原因。

分页总数这个信息有几种处理方式,看业务能不能接受:

第一种,paginate(20, true),第二个参数传 true 就是简洁模式,不再执行 count 查询。但这样一来 getTotal() 就没数字了,前端也不知道总共有多少页,只能无限翻。我们后台的运营恰好需要跳转到某页,所以这条路走不通。

第二种,把总数缓存起来,比如缓存 5 分钟。后台订单数据实时性要求没那么高,5 分钟的总数误差是可以接受的。缓存 key 要带上筛选条件,不然不同条件下的总数会串:

$cacheKey = 'order_total:' . md5(json_encode($where)) . ':' . $status;
$total = Cache::get($cacheKey);
if ($total === null) {
    $total = OrderModel::where($where)->where('status', '>', 0)->count();
    Cache::set($cacheKey, $total, 300);
}

这样 count 只在缓存过期后执行一次,正常的翻页请求不会触发。

第三种,前端不需要总页数的情况下,改成游标分页——按 id 倒序,带上最后一条的 id 往下查。这种方案性能最好,因为完全不用 offset,但需要分页参数从 page 改成 last_id,前端改动比较大。我们后台只在「导出」这种场景用了游标分页,普通列表还是用缓存总数。

这次用的是第二种,count 从每次请求都执行变成 5 分钟执行一次。

七、坑三:with 写在 paginate 之后不生效

这个是我自己的失误。改造的时候为了「代码看着顺」,我把 paginate 放前面,想拿到 Paginator 之后再逐个处理:

$pages = OrderModel::where('status', '>', 0)->paginate(20);
$pages->with(['user', 'items']);   // 这样写不生效

链式构造器的 with 是在生成主查询的时候用的,paginate 之后拿到的已经是分页对象,上面的 with 不会回溯影响已经执行的查询,也不会对遍历出来的模型做预载入。要在 paginate 之前就把 with 挂上去。

如果一定要对已经拿到的分页结果做预载入,可以用 load():

$pages->load(['user', 'items', 'logistics']);

load 会对当前集合里的模型批量做一次关联查询,效果和 with 接近,但不如 with 高效——它无法控制主查询的字段,也不做条件优化。能改 with 就改 with。

八、索引:explain 看一眼少走弯路

SQL 数量降下来之后,单条主查询也要优化。用 explain 分析:

EXPLAIN SELECT * FROM `order` WHERE `status` > 0 ORDER BY `id` DESC LIMIT 20;

输出里 type 是 ALL,rows 是六百多万。意味着这个查询扫了整张主表才拿到 20 条数据。status 上有索引为什么不用?因为 status > 0 的范围太大,优化器判断走索引再回表还不如直接扫全表。

调整成联合索引 (status, id):

ALTER TABLE `order` ADD INDEX `idx_status_id` (`status`, `id`);

再 explain 一次,type 变成 range,Extra 里出现 Using index condition,实际扫描行数下来了。主查询耗时从 40ms 降到 8ms。

关联表也要补索引。order_item 表的 order_id 原来没有单独索引,预载入时的 WHERE order_id IN (...) 会扫全表。加上之后预载入也快了。

还有个小细节:WITH order_item 那层预载入是一次性拿 20 个订单的所有明细,如果有的订单明细上百条,会撑爆单次查询的返回。我们碰到过一个订单有 86 条明细的情况,预载入那条 SQL 返回了三千多行数据。可以加 ->limit() 控制,但需要业务判断,这次没动。

九、完整的改造后代码

public function list()
{
    $page   = (int) $this->request->get('page', 1);
    $status = $this->request->get('status', '');

    $where = [];
    if ($status !== '') {
        $where[] = ['status', '=', (int) $status];
    }

    // 总数缓存,避免每次翻页都 count
    $cacheKey = 'order_total:' . md5(json_encode($where));
    $total = Cache::get($cacheKey);
    if ($total === null) {
        $total = OrderModel::where($where)->count();
        Cache::set($cacheKey, $total, 300);
    }

    $pages = OrderModel::with([
        'user' => fn($q) => $q->field('id, nickname, avatar'),
        'items' => fn($q) => $q->field('id, order_id, goods_id, num, price'),
        'items.goods' => fn($q) => $q->field('id, title, cover'),
        'logistics' => fn($q) => $q->field('id, order_id, company, tracking_no'),
    ])
        ->where($where)
        ->where('status', '>', 0)
        ->order('id desc')
        ->paginate(20, false, ['page' => $page]);

    // 直接序列化模型,关联属性会自动从预载入数据里取
    $list = $pages->items();

    return json([
        'code' => 0,
        'data' => [
            'total' => $total,
            'list'  => $list,
        ],
    ]);
}

注意返回结构里 total 用的是我们缓存的那个值,不用 $pages->total()——后者又执行一次 count 了,缓存就白做了。

十、改完之后的数据

用同一份 20 条数据的测试数据集,用 ab 压了 200 并发、1000 次请求:

  • 改造前:平均响应 1180ms,P99 2100ms,单次请求 SQL 187 条
  • 只改 with:平均响应 640ms,P99 1100ms,单次请求 SQL 6 条
  • 加 count 缓存:平均响应 280ms,P99 460ms,单次请求 SQL 5 条
  • 加索引:平均响应 120ms,P99 190ms,单次请求 SQL 5 条

SQL 数量最后是 5 条不是 4 条,因为还有一条缓存读写会触发到 Redis,不算 SQL 但算了一次往返。MySQL 层面的查询确实压到了 5 条:1 条主查询 + 4 条预载入(user、items、items.goods、logistics)。

CPU 使用率从改造前的 40% 涨到了 55%。这个有点反直觉——查询变少了,CPU 反而上来了。原因是 PHP 现在要处理的数据量变大了:以前是每次只返回一条小结果,PHP 处理的是碎片;现在一次性拿到大数组,序列化成 JSON 的耗时变多了。不过响应时间大幅下降,说明瓶颈确实转移了,这个交换是值得的。

十一、还没解决的问题

第一,items.goods 这层预载入如果商品表数据大且明细多,一次性 IN 几百个 goods_id,返回体也很大。极端情况下需要考虑分批预载入,但目前商品表不大,先这么放着。

第二,count 缓存 5 分钟的时效性,运营偶尔会反馈「总数不准」。这个误差在业务上可以忍,如果他们那边不能忍,就只能换成游标分页,直接不要总数。

第三,with 里那些 field 外键必须全写对的规则,团队里新同学还是会踩。我考虑在模型里重写 getField() 或者在 code review checklist 里加一条,还没做。

十二、写在最后

回头看这次排查,最大的收获是「别猜」。我以前遇到慢查询,习惯凭经验猜是索引问题还是缓存问题,经常猜到一半发现方向错了。这次从 trace 面板开始,到 Db::listen 抓慢 SQL,再到 explain 看执行计划,每一步都有数据支撑,反而省时间。

N+1 这个问题说到底不是技术问题,是习惯问题。写循环的时候脑子里过了「这行代码在循环里」,就已经知道要预载入了。只是项目赶进度的时候图方便,先写出能跑的,事后忘了改。这次改造完之后,我把团队里所有有 foreach 里带 Db::name() 的代码都扫了一遍,又找出四处类似的写法,目前改了俩,剩下俩留着下个迭代一起处理。

ThinkPHP 8 列表接口性能排查实录:187 条 SQL 是怎么被压到 4 条的
收藏 (0) 打赏

感谢您的支持,我会继续努力的!

打开微信/支付宝扫一扫,即可进行扫码打赏哦,分享从这里开始,精彩与您同在
点赞 (0)

版权声明:
本站资源有的来自互联网收集整理,本站纯免费分享提供学习使用,如果侵犯了您的合法权益,请发送邮件1506151422@qq.com联系,将会及时下架删除。
本站资源仅供研究、学习交流之用,免费开源项目不代表完全可商用,若商业用途请先咨询开发企业能否商用,否则产生的一切后果将由下载用户自行承担。
原创板块未经允许不得转载,否则将追究法律责任。

淘吗网 thinkphp ThinkPHP 8 列表接口性能排查实录:187 条 SQL 是怎么被压到 4 条的 https://www.taomawang.com/server/thinkphp/3031.html

常见问题

相关文章

猜你喜欢
发表评论
暂无评论
官方客服团队

为您解决烦忧 - 24小时在线 专业服务