告别“回调地狱”：如何使用Composer和GuzzlePromises优雅处理PHP异步操作

composer require guzzlehttp/promises

<?php

require 'vendor/autoload.php';

use GuzzleHttp\Promise\Promise;
use GuzzleHttp\Promise\RejectedPromise;

echo "--- 异步操作开始 ---\n";

// 1. 模拟异步获取用户数据
// 这是一个Promise，代表了未来会得到用户数据
$fetchUserPromise = new Promise();

// 模拟异步操作的完成，比如这是一个HTTP客户端的响应回调
// 假设用户数据获取成功
// 实际应用中，这会在真正的异步操作（如HTTP请求）完成后被调用
// 这里我们为了演示，在下方手动 resolve
// $fetchUserPromise->resolve(['id' => 1, 'name' => '张三']);
// 或者失败
// $fetchUserPromise->reject('用户服务不可用');

// 2. 链式调用：当用户数据获取成功后，接着去获取订单数据
$fetchOrderPromise = $fetchUserPromise->then(
    function ($userData) {
        echo "✅ 第一步：用户数据获取成功，用户ID: " . $userData['id'] . ", 姓名: " . $userData['name'] . "\n";
        // 返回一个新的Promise，代表了获取订单的异步操作
        $newOrderPromise = new Promise();
        // 模拟异步获取订单数据
        // 实际中，这可能是另一个HTTP请求，其结果会 resolve $newOrderPromise
        // 为了演示，我们稍后手动 resolve 这个 Promise
        // $newOrderPromise->resolve(['orderId' => 'ORD-001', 'amount' => 120.50]);
        return $newOrderPromise;
    },
    function ($reason) {
        echo "❌ 第一步：用户数据获取失败，原因: " . $reason . "\n";
        // 如果用户数据获取失败，我们返回一个 RejectedPromise，将错误传递下去
        return new RejectedPromise("无法获取订单，因为: " . $reason);
    }
);

// 3. 链式调用：当订单数据获取成功后，处理最终结果
$fetchOrderPromise->then(
    function ($orderData) {
        echo "✅ 第二步：订单数据获取成功，订单ID: " . $orderData['orderId'] . ", 金额: " . $orderData['amount'] . "\n";
        return "所有数据已成功获取并处理完成！";
    },
    function ($reason) {
        echo "❌ 第二步：订单数据获取失败，原因: " . $reason . "\n";
        return "操作失败，请稍后再试。";
    }
);

// --- 模拟异步操作的实际触发 ---

// 模拟用户数据异步获取成功
echo "--- 模拟异步获取用户数据中... ---\n";
// 在实际的异步回调中，你会调用 resolve 或 reject
$fetchUserPromise->resolve(['id' => 1, 'name' => '张三']);

// 模拟订单数据异步获取成功
// 注意：这个 resolve 必须在 $fetchUserPromise 内部返回的 $newOrderPromise 上调用
// 由于上面的示例中 $newOrderPromise 是一个局部变量，我们无法直接访问
// 为了演示效果，我们可以在链式回调中直接 resolve 一个值，或者将 Promise 暴露出来
// 简化演示：直接在 then 内部 resolve，或者用一个已解决的 Promise
// 让我们修改一下链式回调，让它更直接地返回一个已解决的 Promise，以简化演示
// 或者，我们使用 wait() 来强制执行，但请记住在真实异步环境中通常不这样做

// 为了让上面的链式调用能正常触发并输出，我们需要在某个地方运行 Promise 队列
// 或者，在演示中，我们可以强制同步等待最终结果，但这会失去异步的优势
// Guzzle promises 内部使用一个任务队列来处理回调。
// 在非事件循环环境中，如果你需要强制执行队列并获取结果，可以使用 wait()
// 但在Web请求中，通常在请求结束前，所有 Promise 都会通过事件循环（或框架机制）自动处理。

// 为了看到效果，我们可以手动触发链式中的第二个 Promise 的 resolve
// 但这需要对 Promise 的内部结构有更深的理解，或者将 Promise 实例传递下去
// 最简单的演示方式是直接在 then 中返回一个已解决的 Promise 或一个值

// 让我们重新简化示例，更贴近 input 中的 Promise Chaining 概念
echo "\n--- 简化链式演示 ---\n";
$firstPromise = new Promise();

$firstPromise
    ->then(function ($value) {
        echo "步骤1：处理初始值 - " . $value . "\n";
        // 返回一个新值，这个值会作为下一个 then 的输入
        return "Hello, " . $value;
    })
    ->then(function ($value) {
        echo "步骤2：接收上一步结果 - " . $value . "\n";
        // 返回一个新的 Promise，表示一个异步操作
        $asyncOperationPromise = new Promise();
        // 模拟这个异步操作在某个时候完成
        // 实际中可能是数据库查询、文件写入等
        echo "步骤2：模拟异步操作中...\n";
        // 假设异步操作成功，并返回一个新值
        // 这里的 resolve 会将值传递给下一个 then
        $asyncOperationPromise->resolve("Async Result for: " . $value);
        return $asyncOperationPromise; // 将这个 Promise 转发下去
    })
    ->then(function ($value) {
        echo "步骤3：接收异步操作结果 - " . $value . "\n";
        return "最终处理完成！";
    }, function ($reason) {
        echo "步骤3：链条中断，错误原因 - " . $reason . "\n";
        return "处理过程中发生错误。";
    });

// 触发第一个 Promise 的解决，开始链条
$firstPromise->resolve('World');

// 在实际的异步环境中，你不需要调用 wait()，但为了在脚本结束前看到所有输出
// 我们可以使用 wait() 来强制执行所有挂起的 Promise
// 注意：在Web应用中，通常会集成到框架的事件循环中，避免阻塞主线程
try {
    // 这里的 wait(false) 只是确保 Promise 链条被处理，但不抛出异常
    // 如果你期望获取最终返回值，可以 $finalResult = $firstPromise->wait();
    // 但在复杂的链条中，通常是最后一个 then 的回调负责最终处理
    // 假设我们关心的是链条的执行过程，而不是最终返回值
    // 如果有未被捕获的拒绝，wait() 会抛出异常
    echo "\n--- 强制等待所有 Promise 完成 (仅为演示) ---\n";
    // 强制等待，以便看到所有输出
    $firstPromise->wait(false); // 等待，但不抛出异常
} catch (\Exception $e) {
    echo "捕获到未处理的 Promise 异常: " . $e->getMessage() . "\n";
}

echo "--- 异步操作结束 (但内部回调可能还在执行) ---\n";