一次大促前的扩容,运维把 FPM 的 pm.max_children 从 20 调到 80,又加了两台队列机器,每台起了 8 个 worker。流量上来后,应用开始大面积报 SQLSTATE[HY000] [1040] Too many connections。数据库的 max_connections 还是默认的 151,而同时可能占用的连接已经是 80 乘 2 台,再加 16 个 worker,还没算迁移脚本和监控账号。
同一周,订单列表页被反馈「越翻越慢」。页面只展示 20 条订单,每条显示客户名。代码里在循环里取 $order->customer->name,于是 1 条查订单的 SQL 加上 20 条查客户的 SQL,一次请求 21 条;如果还要显示商品数,再乘一层。这就是 N+1 查询:一个主查询带出 N 条记录,每条记录又触发一次关联查询。
这两个问题都不在业务代码的「逻辑」里,而在数据访问的边界上。这篇讲四件事:连接怎么算、三种查询写法怎么选、迁移怎么在不锁表的前提下改结构、事务边界划在哪里。数据库本身的 SQL 语法和索引原理在 SQL 组里讲,这里只讲 Laravel 这一层怎么用。
连接数是一道算术题
先建立一个基本事实:在 PHP-FPM 模式下,一个请求占一条数据库连接,请求结束、进程回收时连接关闭(除非显式开了持久连接)。所以并发连接数的上限,约等于同时处理请求的进程数,加上常驻的队列 worker 数,再加上迁移、定时任务、监控、人工登录这些零散连接。
pm.max_children 个进程,每个进程在处理请求时最多持有一条连接。两台机器就是两倍。queue:work 进程常驻一条连接,处理任务时可能再开事务。8 个 worker 就是 8 条常驻。算一遍就清楚了:两台 80 进程的机器是 160,队列 16,预留 20,总共 196,已经超过 151。要么把 max_connections 调到 250 以上,要么把 FPM 进程数降下来。但调数据库参数不是免费的,每条连接在 MySQL 侧都要占线程和内存,连接数开到几百,上下文切换和内存占用会明显上升。更稳的做法是先把进程数按「内存除以单进程峰值」定下来,再给数据库留出余量,而不是反过来。
还有一个放大因素:长事务。一个请求如果在事务里调了外部 HTTP 接口,连接会被占住几百毫秒甚至几秒,并发一高,连接池瞬间见底。这类问题在连接数统计上表现为「连接不多但一直满」,排查时看 SHOW PROCESSLIST 里那些 Sleep 之外、状态为 Locked 或长时间 Query 的会话。
Laravel 怎么拿连接
Laravel 的数据库层叫 DatabaseManager,配置在 config/database.php。每个连接名对应一组参数,默认连接由 DB_CONNECTION 决定。应用启动时不会立刻连数据库,第一次执行查询时才建立连接,这叫懒连接。
'mysql' => [
'driver' => 'mysql',
'host' => env('DB_HOST', '127.0.0.1'),
'port' => env('DB_PORT', '3306'),
'database' => env('DB_DATABASE', 'cms'),
'username' => env('DB_USERNAME', 'cms'),
'password' => env('DB_PASSWORD', ''),
'charset' => 'utf8mb4',
'collation' => 'utf8mb4_unicode_ci',
'strict' => true,
'options' => extension_loaded('pdo_mysql') ? array_filter([
PDO::MYSQL_ATTR_SSL_CA => env('MYSQL_ATTR_SSL_CA'),
]) : [],
],
默认情况下每个请求结束时连接会被释放。如果想复用,可以在 options 里加 PDO::ATTR_PERSISTENT => true,让 FPM 子进程保留连接。它省掉了建连的握手开销,但代价是连接的生命周期和进程绑在一起:进程里残留的会话状态(比如未提交事务、临时表、SET 过的变量)可能被下一个请求继承。没有明确的性能证据时,不要默认打开它。
读写分离是另一个常见需求。配置里可以写 read 和 write 两组主机,框架会把 SELECT 发到读库、写操作发到主库。但要注意复制延迟:刚写完立刻读,读库可能还没有这条数据。Laravel 提供 sticky 选项,在一次请求内写完之后强制走主库,代价是这段时间读压力都落在主库。业务上「写完立刻要读」的场景不少,这个开关要按接口开,不要全局长期打开。
项目需要连第二个数据库时,在 config/database.php 里加一个新的连接名,用 DB::connection('report') 显式指定;模型则设置 protected $connection = 'report'。DB::transaction 默认只作用于默认连接,跨库事务要靠业务补偿,不要假设一个事务能同时覆盖两个库。
排查连接从哪来时,先看进程模型再看配置。SHOW PROCESSLIST 能列出每个连接的来源地址、用户、状态和执行的 SQL;配合 SHOW VARIABLES LIKE 'max_connections' 看上限。如果来源 IP 全是应用机器,那就是进程数问题;如果出现陌生 IP,先查安全组和账号权限。
Eloquent、查询构造器与原生 SQL
Laravel 提供三层写法,从抽象到具体依次是:Eloquent 模型、查询构造器(Query Builder)、原生 SQL。三层都能完成同一件事,差别在可读性、开销和控制力。
| 写法 | 写法示例 | 开销 | 适合 |
|---|---|---|---|
| Eloquent | Order::with('customer')->paginate(20) | 每条记录实例化模型,自带关联、修改器、事件 | 业务主体,需要关联和模型行为 |
| 查询构造器 | DB::table('orders')->paginate(20) | 返回数组对象,不实例化模型 | 列表、报表、只读聚合 |
| 原生 SQL | DB::select('select ...', [$id]) | 最少封装,需要自己处理绑定和结果 | 复杂查询、数据库特有语法 |
Eloquent 的便利来自模型:关联、访问器、类型转换、软删除、事件钩子都挂在模型上。代价是每条记录都要实例化一个对象,字段越多、记录越多,内存和 CPU 开销越大。列表页一次返回 20 条,差别可以忽略;导出一次 10 万条,Eloquent 可能直接把内存打爆,这种场景应该用查询构造器分批读。
原生 SQL 不是「低级写法」,复杂报表、窗口函数、数据库特有的优化提示,用原生 SQL 往往更清楚。但它必须用参数绑定,不能把用户输入拼进字符串。DB::select('select * from orders where id = ?', [$id]) 是安全的;DB::select("select * from orders where id = $id") 是注入。
选择的原则可以简化成一句:写操作和单条业务对象用 Eloquent,批量读取和聚合用查询构造器,数据库特有的复杂查询用原生 SQL。同一个项目里混用是正常的,不需要为了「统一」把复杂查询硬塞进模型。
N+1:问题不在循环,在循环里的查询
N+1 的典型形态是这样:
$orders = Order::query()->latest()->limit(20)->get();
foreach ($orders as $order) {
echo $order->customer->name; // 每条记录再查一次
}
第一行 1 条 SQL,循环里每条订单 1 条,共 21 条。如果模板里还访问 $order->items->count(),再乘 20。数据量到几百条时,接口响应会从几十毫秒涨到几秒,而且数据库 CPU 会被这些小查询打满。
解决办法是预加载(eager loading):用 with() 在第一次查询时就把关联数据一起取回来,框架会用 whereIn 批量查,总共 2 条 SQL,而不是 21 条。
$orders = Order::query()
->with('customer:id,name')
->withCount('items')
->latest()
->paginate(20);
with('customer:id,name') 里的字段列表不是可有可无的优化:不写的话会把客户表所有字段都查出来;写了要注意必须包含主键和外键,否则关联对不上。关联关系在模型里用 belongsTo、hasMany 定义,这是 Eloquent 的约定,改关联名会影响所有使用处。
怎么发现 N+1?开发阶段最直接的办法是打开查询日志,看一次请求到底发了几条 SQL。在 AppServiceProvider 的 boot 里挂一个监听,只在本地环境生效:
DB::listen(function ($query) {
logger()->debug($query->sql, [
'bindings' => $query->bindings,
'time_ms' => $query->time,
]);
});
生产环境不要长期打开,日志量会很大。更稳的做法是在测试里断言查询条数,比如列表接口固定只允许 2 到 3 条 SQL,超过就失败,这样 N+1 在合并前就会暴露。
数据量大到一次取不完时,不要用 get() 全量加载,用 chunkById 分批。它按主键翻页,避免 offset 越翻越慢,也不会因为中途有新增数据而漏读或重读。cursor() 更省内存,但它在一个长连接上逐条读,期间不能复用同一连接做别的查询。
迁移:先加列,再回填,最后加约束
迁移(migration)是用代码描述表结构变更的机制,文件放在 database/migrations/,执行 php artisan migrate 按时间顺序应用。它解决的是「多环境结构一致」的问题,但解决不了「改结构时线上正在读写」的问题。
大表上直接加一个非空、无默认值的列,或者改列类型,可能触发表重建和长时间锁表。请求排队的表现是接口超时、连接池被打满,看起来像数据库挂了。零停机的做法是把一次变更拆成三步,跨多次发布完成:
第一步,只加一个可空列,不动已有数据。MySQL 8.0 对「在表末尾加可空列」有 instant 优化,通常很快;但如果指定了位置、或者列上带复杂默认值,可能会退化成重建表,发布前要用测试库上的实际耗时确认。
Schema::table('orders', function (Blueprint $table) {
$table->string('channel', 32)->nullable();
});
第二步,发布同时写新旧字段的代码,让新数据两个字段都有值。第三步,用一个独立命令分批回填历史数据,每批几百条,批间 sleep 一下,避免把数据库打满:
Order::query()->whereNull('channel')->chunkById(500, function ($orders) {
foreach ($orders as $order) {
$order->channel = 'legacy';
$order->save();
}
usleep(50000);
});
第四步,等回填完成、确认没有空值之后,再加索引和约束。加索引本身也可能锁表,普通索引在 MySQL 8.0 上通常支持在线创建,但仍建议低峰执行,并先在小表上验证耗时。第五步,代码全部切到新字段;第六步再删旧字段。任何一步都要能独立回滚,不要在一个发布里同时做三件事。
migrate:fresh 或 migrate:rollback 处理生产环境的结构问题。migrate:fresh 会删掉所有表重建,数据直接清零。生产上的回滚应该是「再写一个反向迁移」,并且确认它不会丢数据。事务:边界、锁与重试
事务(transaction)把多条写操作包成一个整体,要么全部成功,要么全部回滚。Laravel 里最常用的写法是 DB::transaction,它接收一个闭包,闭包里抛异常就自动回滚:
$order = DB::transaction(function () use ($data) {
$order = Order::create([
'customer_id' => $data['customer_id'],
'status' => 'pending',
'channel' => 'web',
]);
foreach ($data['items'] as $item) {
$order->items()->create($item);
}
return $order;
}, 3);
第二个参数是重试次数,遇到死锁(deadlock)时框架会自动重试整个闭包。死锁不是 bug,是两个事务以不同顺序锁同一批行时的正常现象,数据库会杀掉其中一个。重试的前提是闭包必须幂等:里面不能发消息、不能调外部接口、不能做「只能执行一次」的事,否则重试会重复执行。本机 Laravel 12.71.0 + MariaDB 11.4.5 实测:在 DB::transaction 里创建订单后抛 RuntimeException,输出「异常: 模拟下游失败 / 事务前: 138 / 事务后: 138」,记录数没有增加,回滚生效。
需要「先读再改」时,用 lockForUpdate 给读到的行加排他锁,防止两个请求同时读到同一个库存值再各自扣减:
DB::transaction(function () use ($sku) {
$stock = Stock::query()->where('sku', $sku)->lockForUpdate()->firstOrFail();
if ($stock->available < 1) {
throw new OutOfStockException('库存不足');
}
$stock->decrement('available');
});
事务边界要尽量短,尤其不要在事务里做 HTTP 请求、发邮件、写大文件。这些操作慢且可能失败,连接会被一直占着,前面说的「连接满但并发不高」多半就是这么来的。需要触发副作用的,用 afterCommit 把它们挪到事务提交之后:
ProcessOrder::dispatch($order)->afterCommit();
另一个细节是嵌套事务。Laravel 的嵌套 DB::transaction 实际用的是保存点(savepoint),内层回滚不会让外层整体失败。这看起来方便,但容易让人误以为内层失败不影响外层提交,实际业务里要明确「哪一层失败就该终止」。默认的隔离级别是「可重复读」,同一事务里两次读可能看到不同版本的数据,涉及计数、余额这类逻辑时,锁和重试都要按最坏情况设计。
现象、原因与第一步
| 现象 | 真实原因 | 第一步查什么 |
|---|---|---|
Too many connections | FPM 进程数加 worker 数超过数据库上限 | SHOW PROCESSLIST 与 max_connections 对比 |
| 列表接口随数据量变慢 | N+1 查询,循环里访问关联 | 打开查询日志,数一次请求的 SQL 条数 |
| 写完立刻读不到 | 读写分离的复制延迟,或读走了从库 | 确认 sticky 配置;看主从延迟 |
| 发布时接口大面积超时 | 迁移在大表上锁表或重建 | 看迁移耗时;查 SHOW PROCESSLIST 里的等待 |
| 偶发死锁 | 两个事务锁行顺序不一致 | 看数据库死锁日志,统一加锁顺序并加重试 |
| 事务里连接被占满 | 事务中调用了外部接口或慢查询 | 把外部调用挪到 afterCommit 之后 |
| 导出任务内存溢出 | 用 get() 一次性加载大量模型 | 改用 chunkById 或 cursor |
| 加索引后写入变慢 | 索引过多,每次写入都要维护 | SHOW INDEX 看冗余索引;按查询删减 |
完整链路:订单列表与下单
把上面几件事串成一个可运行的片段。依赖只有 Laravel 12 自带的数据库组件,不需要额外安装包;数据库用 MySQL 8.0,先在 .env 里配好连接。创建迁移和模型:
php artisan make:migration create_orders_table
php artisan make:model Order
迁移里至少要有主键、外键索引和时间戳。列表查询按「预加载加计数」写,下单按「事务加锁」写:
// routes/api.php
Route::get('/v1/orders', [OrderController::class, 'index']);
Route::post('/v1/orders', [OrderController::class, 'store']);
// 列表
public function index()
{
return Order::query()
->with('customer:id,name')
->withCount('items')
->latest()
->paginate(20);
}
启动并调用(本机 artisan serve 起不来,用等价的 php -S):
php -S 127.0.0.1:8030 -t public
curl -i "http://127.0.0.1:8030/api/v1/orders?page=1"
本机实测返回 200,data 里 20 条,meta 里带分页信息,结构如下:
{
"data": [
{
"id": 137,
"customer_id": 3,
"status": "paid",
"customer": { "id": 3, "name": "王五" },
"items_count": 2
}
],
"meta": { "current_page": 1, "per_page": 20, "total": 137 }
}
本机实测这次请求产生 3 条 SQL:分页计数 1 条、订单分页 1 条(items_count 用子查询一并算出)、客户预加载 1 条。打开查询日志数得 3,不是 4;只有把 withCount 拆成一次额外查询才会变成 4。
边界与代价
Eloquent 让业务代码短,但它不保证 SQL 高效。写起来最顺的写法(循环里访问关联、all() 再过滤、在 PHP 里做聚合)往往是最慢的写法。团队需要一条规矩:列表和报表接口必须看查询条数和执行计划,不能只看返回对不对。
连接数的天花板是这套架构的硬边界。垂直扩容(加 FPM 进程)受内存和数据库连接数限制,水平扩容(加机器)会把连接数成倍放大。真正到万级并发时,通常要引入连接代理(如 ProxySQL)、把读流量分到多个从库,或者把热点读放到 Redis。每加一层,故障点也多一个。
数据库选型换掉的代价更高。Eloquent 的关联、迁移、事务都绑定在 SQL 语义上,改成文档数据库意味着重新设计数据模型和查询方式,业务代码要重写一大半。反过来,如果业务确实需要灵活的结构,硬用 MySQL 加 JSON 列,也会在查询和索引上付出代价。选型要在数据模型还没铺开时定。
事务的边界也不是越包越好。事务越大,锁持有时间越长,冲突和死锁概率越高,回滚成本也越大。一个经验规则是:事务里只做数据库写操作,且尽量控制在几十毫秒内;任何可能超时的外部依赖都挪到事务外,用补偿或重试处理不一致。
当天能自己验证的练习
- 执行
SHOW VARIABLES LIKE 'max_connections'和SHOW PROCESSLIST,把自己环境的 FPM 进程数、worker 数、预留数加起来,看离上限还有多少。 - 在
AppServiceProvider里挂DB::listen,请求一个列表接口,数日志里的 SQL 条数;再改成with(),对比条数变化。 - 用
php artisan make:migration建一个给大表加可空列的迁移,在测试库上执行并记录耗时,再试一次带->after()的版本,对比差异。 - 写一个事务闭包,故意在中间抛异常,观察数据是否全部回滚;再把异常去掉,确认提交。
- 用两个并发请求各扣一次库存,先不加
lockForUpdate跑一遍,再加上跑一遍,对比最终库存值。
小结
三句话:连接数等于 FPM 进程加 worker 加预留,扩容前先算这道题;列表和导出必须盯查询条数,with() 和 chunkById 是两个基本手段;改表结构拆成「加可空列、双写、回填、加约束、切换、删除」多步,事务里只留数据库操作。
下一篇讲鉴权与会话。数据访问解决的是「谁能读写哪些数据」,但前提是系统知道「现在是谁」。登录状态存在文件、Redis 还是数据库,决定了多机部署会不会掉登录;令牌放在 Cookie 还是 localStorage,决定了 XSS 之后损失有多大。下一篇从一个刷新就掉登录的故障开始。