告别回调地狱与阻塞等待：如何用GuzzlePromises优雅处理PHP异步操作

<code class="php">// 伪代码：一个简化的回调地狱
getUser(function($user) {
    getOrders($user->id, function($orders) {
        foreach ($orders as $order) {
            getProducts($order->items, function($products) use ($order) {
                // 处理订单和商品信息
                processOrderData($order, $products, function($result) {
                    // ... 更多嵌套
                });
            });
        }
    });
});</code>

<code class="bash">composer require guzzlehttp/promises</code>

<code class="php"><?php

require 'vendor/autoload.php';

use GuzzleHttp\Promise\Promise;

// 模拟一个异步获取用户信息的函数
function getUserInfoAsync(int $userId): Promise
{
    $promise = new Promise();

    // 假设这是一个耗时的API调用，我们用sleep模拟
    // 实际项目中，这里会是 GuzzleHttp\Client->getAsync() 等
    go(function () use ($promise, $userId) { // 假设有协程或异步IO支持
        echo "开始获取用户 {$userId} 信息...\n";
        sleep(2); // 模拟网络延迟
        if ($userId === 123) {
            $promise->resolve(['id' => 123, 'name' => '张三', 'email' => 'zhangsan@example.com']);
        } else {
            $promise->reject(new \Exception("用户 {$userId} 未找到。"));
        }
        echo "用户 {$userId} 信息获取完毕。\n";
    });

    return $promise;
}

// 模拟一个异步获取订单列表的函数
function getOrdersAsync(int $userId): Promise
{
    $promise = new Promise();
    go(function () use ($promise, $userId) {
        echo "开始获取用户 {$userId} 的订单...\n";
        sleep(1); // 模拟网络延迟
        if ($userId === 123) {
            $promise->resolve([
                ['order_id' => 'A001', 'items' => ['prod_X', 'prod_Y']],
                ['order_id' => 'A002', 'items' => ['prod_Z']],
            ]);
        } else {
            $promise->reject(new \Exception("用户 {$userId} 没有订单。"));
        }
        echo "用户 {$userId} 订单获取完毕。\n";
    });
    return $promise;
}

// 模拟一个异步获取商品详情的函数
function getProductDetailsAsync(array $productIds): Promise
{
    $promise = new Promise();
    go(function () use ($promise, $productIds) {
        echo "开始获取商品 " . implode(', ', $productIds) . " 详情...\n";
        sleep(0.5); // 模拟网络延迟
        $details = [];
        foreach ($productIds as $id) {
            $details[$id] = ['name' => "商品 {$id} 名称", 'price' => rand(10, 100)];
        }
        $promise->resolve($details);
        echo "商品 " . implode(', ', $productIds) . " 详情获取完毕。\n";
    });
    return $promise;
}</code>

<code class="php">use GuzzleHttp\Promise\Utils; // 用于运行Promise队列

// 假设我们想获取用户123的完整信息和订单及商品详情
getUserInfoAsync(123)
    ->then(function ($user) {
        echo "用户数据: " . json_encode($user) . "\n";
        // 成功获取用户后，继续获取订单
        return getOrdersAsync($user['id']);
    })
    ->then(function ($orders) {
        echo "订单数据: " . json_encode($orders) . "\n";
        $allProductIds = [];
        foreach ($orders as $order) {
            $allProductIds = array_merge($allProductIds, $order['items']);
        }
        // 获取所有商品的详情
        return getProductDetailsAsync(array_unique($allProductIds));
    })
    ->then(function ($productDetails) {
        echo "商品详情: " . json_encode($productDetails) . "\n";
        echo "所有数据获取并处理完毕！\n";
    })
    ->otherwise(function (\Exception $reason) {
        // 任何一个环节出现错误，都会在这里被捕获
        echo "操作过程中发生错误: " . $reason->getMessage() . "\n";
    });

// 重要的步骤：运行Promise任务队列
// 在没有事件循环的传统PHP脚本中，你需要手动运行队列来驱动Promise的解决
// 如果你在一个事件循环环境（如ReactPHP, Swoole）中，通常不需要手动调用
Utils::queue()->run();

echo "脚本继续执行，不等待异步操作完成（除非使用wait()）。\n";</code>

<code class="php">// 假设你只需要最终结果，并愿意阻塞等待
$finalResultPromise = getUserInfoAsync(123)
    ->then(function ($user) {
        return getOrdersAsync($user['id']);
    })
    ->then(function ($orders) {
        $allProductIds = [];
        foreach ($orders as $order) {
            $allProductIds = array_merge($allProductIds, $order['items']);
        }
        return getProductDetailsAsync(array_unique($allProductIds));
    });

try {
    $data = $finalResultPromise->wait(); // 阻塞直到Promise完成
    echo "同步等待获取到的最终数据: " . json_encode($data) . "\n";
} catch (\Exception $e) {
    echo "同步等待时发生错误: " . $e->getMessage() . "\n";
}</code>