PHP `ORM` 延迟加载与预加载的性能权衡

各位观众老爷，晚上好！今天咱们聊聊PHP ORM里那点儿“延迟加载”和“预加载”的恩怨情仇，以及如何在性能这块儿精打细算。

ORM是个啥？先简单过一遍

ORM，全称Object-Relational Mapping，对象关系映射。简单来说，就是让你用面向对象的方式操作数据库，不用直接写那些SQL语句。想想，不用天天 SELECT * FROM ... WHERE ...，而是 User::find(1)，是不是感觉世界都美好了？

但是，ORM也不是万能的，用不好一样会掉坑里。今天咱们重点聊的就是性能坑里常见的两种“姿势”：延迟加载和预加载。

延迟加载：用时再抱佛脚

延迟加载(Lazy Loading)，顾名思义，就是用到的时候再加载。就像你点外卖，饿了才开始下单，现做现送。

举个栗子：

假设咱们有两个表：users 和 posts，一个用户可以有很多帖子。

// User模型
class User extends Model {
    protected $table = 'users';

    public function posts() {
        return $this->hasMany(Post::class, 'user_id'); // 一个用户有很多帖子
    }
}

// Post模型
class Post extends Model {
    protected $table = 'posts';

    public function user() {
        return $this->belongsTo(User::class, 'user_id'); // 一个帖子属于一个用户
    }
}

延迟加载的代码：

$user = User::find(1); // 先查用户

echo $user->name; // 显示用户名，没问题，用户信息已经加载

foreach ($user->posts as $post) { // 访问用户的帖子，这里会触发N+1查询
    echo $post->title;
}

延迟加载的“坑”：N+1 查询问题

上面这段代码看起来很优雅，但暗藏杀机。当你访问 $user->posts 的时候，ORM会帮你去查数据库，把这个用户的所有帖子查出来。

问题就出在那个 foreach 循环里。每循环一次，都要查一次数据库！先查出用户的信息，然后再为每个帖子都查一次数据库获取帖子标题。这相当于：

1. 查用户信息：SELECT * FROM users WHERE id = 1
2. 循环N次：SELECT * FROM posts WHERE id = post_id (每个帖子ID查询一次)

这就是传说中的 N+1 查询问题：1次查询用户 + N次查询帖子。 如果用户有100个帖子，就要查101次数据库！性能可想而知。

延迟加载的优点：

• 按需加载： 只有真正用到关联数据的时候才加载，节省资源。
• 代码简洁： 代码看起来很直观，易于理解。

延迟加载的缺点：

• N+1 查询问题： 在循环遍历关联数据时，容易出现性能问题。
• 数据库连接开销： 多次数据库查询会增加连接开销。

预加载：一次性打包带走

预加载(Eager Loading)，就是提前把需要的数据都加载好，就像你一次性把一周的外卖都订好，省的饿了再点。

预加载的代码：

$user = User::with('posts')->find(1); // 预加载用户的帖子

echo $user->name; // 显示用户名，没问题，用户信息已经加载

foreach ($user->posts as $post) { // 直接访问帖子的标题，不需要额外查询
    echo $post->title;
}

预加载的原理：

User::with('posts') 告诉ORM，在查询用户的时候，把用户的帖子也一起查出来。ORM会用一条SQL语句搞定：

SELECT * FROM users WHERE id = 1;
SELECT * FROM posts WHERE user_id IN (1); // 根据用户的id，查出所有帖子

或者，某些ORM框架会使用JOIN操作来完成，效率更高。

预加载的优点：

• 避免N+1 查询： 只需要一次或少数几次数据库查询，提高性能。
• 减少数据库连接开销： 减少了数据库连接的次数。

预加载的缺点：

• 过度加载： 可能会加载一些实际上不需要的数据，浪费资源。
• 代码稍复杂： 需要提前声明需要加载的关联数据。

性能对比：数据说话

为了更直观地了解延迟加载和预加载的性能差异，咱们用一个简单的表格来对比一下：

特性	延迟加载 (Lazy Loading)	预加载 (Eager Loading)
查询次数	1 + N	1 或 2
连接开销	高	低
资源利用	按需加载，可能浪费少	可能过度加载，浪费多
代码复杂度	低	稍高
适用场景	关联数据访问频率低	关联数据访问频率高

模拟测试代码

<?php

require_once 'vendor/autoload.php';

use IlluminateDatabaseCapsuleManager as Capsule;
use IlluminateDatabaseEloquentModel;

// Eloquent ORM 配置
$capsule = new Capsule;
$capsule->addConnection([
    'driver'    => 'mysql',
    'host'      => 'localhost',
    'database'  => 'test',
    'username'  => 'root',
    'password'  => '',
    'charset'   => 'utf8',
    'collation' => 'utf8_unicode_ci',
    'prefix'    => '',
]);

// Make this Capsule instance available globally via static methods... (optional)
$capsule->setAsGlobal();

// Setup the Eloquent ORM... (optional; unless you use eloquent models)
$capsule->bootEloquent();

// 定义模型
class User extends Model
{
    protected $table = 'users';
    public $timestamps = false;

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

class Post extends Model
{
    protected $table = 'posts';
    public $timestamps = false;

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

// 数据库初始化（创建表和数据）
function initDatabase()
{
    Capsule::schema()->dropIfExists('posts');
    Capsule::schema()->dropIfExists('users');

    Capsule::schema()->create('users', function ($table) {
        $table->increments('id');
        $table->string('name');
    });

    Capsule::schema()->create('posts', function ($table) {
        $table->increments('id');
        $table->integer('user_id')->unsigned();
        $table->string('title');
        $table->foreign('user_id')->references('id')->on('users');
    });

    // 创建用户和帖子
    for ($i = 1; $i <= 100; $i++) {
        $user = User::create(['name' => 'User ' . $i]);
        for ($j = 1; $j <= 10; $j++) {
            Post::create(['user_id' => $user->id, 'title' => 'Post ' . $j . ' by User ' . $i]);
        }
    }
}

// 延迟加载测试
function lazyLoadingTest()
{
    $startTime = microtime(true);
    $users = User::all();
    foreach ($users as $user) {
        foreach ($user->posts as $post) {
            $post->title; // 访问帖子标题
        }
    }
    $endTime = microtime(true);
    return $endTime - $startTime;
}

// 预加载测试
function eagerLoadingTest()
{
    $startTime = microtime(true);
    $users = User::with('posts')->get();
    foreach ($users as $user) {
        foreach ($user->posts as $post) {
            $post->title; // 访问帖子标题
        }
    }
    $endTime = microtime(true);
    return $endTime - $startTime;
}

// 初始化数据库
initDatabase();

// 运行测试
$lazyTime = lazyLoadingTest();
$eagerTime = eagerLoadingTest();

echo "Lazy Loading Time: " . $lazyTime . " secondsn";
echo "Eager Loading Time: " . $eagerTime . " secondsn";

代码解释:

1. 环境搭建:
   • 使用 illuminate/database 组件, 模拟Eloquent ORM.
   • 定义了 User 和 Post 模型, 建立了 一对多 的关系.
2. 数据库初始化 (initDatabase 函数):
   • 创建了 users 和 posts 表.
   • 插入了 100 个用户, 每个用户 10 个帖子.
3. 延迟加载测试 (lazyLoadingTest 函数):
   • 获取所有用户 (User::all()).
   • 循环遍历每个用户的帖子 ($user->posts). 这里会触发 N+1 查询!
4. 预加载测试 (eagerLoadingTest 函数):
   • 使用 User::with('posts')->get() 预加载用户的帖子. 避免了 N+1 查询!
5. 性能测试:
   • 使用 microtime(true) 记录每个测试的开始和结束时间.
   • 计算并输出执行时间.

注意: 运行这个代码需要先安装 illuminate/database: composer require illuminate/database

运行结果会告诉你，在大量数据的情况下，预加载通常比延迟加载快很多。

如何选择？看场景！

说了这么多，到底该用延迟加载还是预加载呢？答案是：看场景！

• 关联数据访问频率低： 如果你的代码里很少访问关联数据，或者只在特定情况下才访问，那么延迟加载可能更合适。因为它可以避免不必要的资源浪费。
• 关联数据访问频率高： 如果你的代码里经常需要访问关联数据，特别是在循环遍历的时候，那么一定要用预加载。否则，N+1 查询会让你欲哭无泪。
• 数据量大小：如果关联表数据量巨大，全部预加载可能会导致内存溢出。这时需要考虑分页预加载或使用更高级的查询技巧。

更高级的预加载技巧：

• 条件预加载： 只加载满足特定条件的关联数据。例如：User::with(['posts' => function ($query) { $query->where('is_published', true); }])->find(1);
• 多层预加载： 同时预加载多个关联关系。例如：User::with('posts.comments')->find(1);
• 延迟预加载（Lazy Eager Loading）： 在已经获取的模型集合上，动态地添加预加载。例如：

  $users = User::all();
  $users->load('posts'); // 对已存在的用户集合进行预加载

ORM之外：原生SQL的威力

虽然ORM很方便，但在某些极端情况下，性能仍然可能不如原生SQL。如果你对性能有极致的追求，可以考虑以下方法：

• 使用JOIN查询： 用一条SQL语句把需要的数据都查出来，避免多次数据库查询。
• 使用索引： 确保你的查询条件都用到了索引，提高查询效率。
• 优化SQL语句： 使用 EXPLAIN 命令分析SQL语句，找出性能瓶颈并进行优化。

温馨提示： 使用原生SQL需要你自己处理数据映射，比较繁琐。

总结：没有银弹，只有权衡

延迟加载和预加载各有优缺点，没有绝对的好坏。关键在于理解它们的原理，并根据实际场景做出选择。

记住，性能优化是一个持续的过程，需要不断地测试、分析和调整。不要盲目追求某种“最佳实践”，要找到最适合你项目的方案。

希望今天的分享对大家有所帮助！下次有机会再和大家聊聊其他ORM相关的性能优化技巧。 祝大家编程愉快，少踩坑！