如何在PHP中优雅处理异步操作？GuzzlePromises助你告别“回调地狱”！

<pre class="brush:php;toolbar:false;">// 伪代码，展示回调地狱
callApi1(function($userId) {
    callApi2($userId, function($orderList) {
        callApi3($orderList, function($totalAmount) {
            // 终于拿到总金额了，但代码已经深陷其中...
            echo "总金额: " . $totalAmount;
        }, function($error3) { /* 错误处理3 */ });
    }, function($error2) { /* 错误处理2 */ });
}, function($error1) { /* 错误处理1 */ });

<pre class="brush:php;toolbar:false;">composer require guzzlehttp/promises

guzzlehttp/promises

vendor/autoload.php

guzzlehttp/promises

then()

<pre class="brush:php;toolbar:false;">use GuzzleHttp\Promise\Promise;

// 创建一个 Promise 实例
$promise = new Promise();

// 注册成功和失败的回调
$promise->then(
    // $onFulfilled: 当 Promise 成功时执行
    function ($value) {
        echo 'Promise 已成功兑现，值为: ' . $value . "\n";
    },
    // $onRejected: 当 Promise 失败时执行
    function ($reason) {
        echo 'Promise 被拒绝，原因为: ' . $reason . "\n";
    }
);

// 模拟异步操作成功，兑现 Promise
$promise->resolve('Hello, Guzzle Promises!');
// 输出：Promise 已成功兑现，值为: Hello, Guzzle Promises!

// 模拟异步操作失败，拒绝 Promise
// $promise->reject('网络请求失败');
// 输出：Promise 被拒绝，原因为: 网络请求失败

then()

then()

then()

<pre class="brush:php;toolbar:false;">use GuzzleHttp\Promise\Promise;

$dataPromise = new Promise();

$dataPromise
    ->then(function ($initialValue) {
        echo "步骤1：接收到初始值 - " . $initialValue . "\n";
        // 返回一个新值，传递给下一个 then
        return $initialValue . " + 处理A";
    })
    ->then(function ($valueFromStep1) {
        echo "步骤2：接收到步骤1的值 - " . $valueFromStep1 . "\n";
        // 再次返回一个新值
        return $valueFromStep1 . " + 处理B";
    })
    ->then(function ($finalValue) {
        echo "步骤3：接收到最终值 - " . $finalValue . "\n";
        // 最终输出
    });

// 解决初始 Promise，触发链式调用
$dataPromise->resolve('原始数据');

/* 预期输出：
步骤1：接收到初始值 - 原始数据
步骤2：接收到步骤1的值 - 原始数据 + 处理A
步骤3：接收到最终值 - 原始数据 + 处理A + 处理B
*/

then

then

<pre class="brush:php;toolbar:false;">use GuzzleHttp\Promise\Promise;

$apiCall1 = new Promise();
$apiCall2 = new Promise(); // 模拟第二个异步API调用

$apiCall1
    ->then(function ($userId) use ($apiCall2) {
        echo "API 1 完成，获取到用户ID: " . $userId . "\n";
        // 在这里发起第二个 API 调用，并返回其 Promise
        return $apiCall2;
    })
    ->then(function ($orderList) {
        echo "API 2 完成，获取到订单列表: " . json_encode($orderList) . "\n";
        // 继续处理订单列表...
    });

// 模拟第一个API完成
$apiCall1->resolve('user_123');
// 此时，第二个 then 不会立即执行，它在等待 $apiCall2 解决

// 模拟第二个API完成
$apiCall2->resolve(['order_A', 'order_B']);

/* 预期输出：
API 1 完成，获取到用户ID: user_123
API 2 完成，获取到订单列表: ["order_A","order_B"]
*/

onFulfilled

onRejected

onRejected

RejectedPromise

<pre class="brush:php;toolbar:false;">use GuzzleHttp\Promise\Promise;
use GuzzleHttp\Promise\RejectedPromise;

$dataPromise = new Promise();

$dataPromise
    ->then(function ($value) {
        // 模拟一个成功的回调中抛出异常
        throw new \Exception("处理数据时发生意外！");
        return $value . " processed";
    })
    ->then(null, function ($reason) { // 第一个错误处理回调
        echo "捕获到错误: " . $reason->getMessage() . "\n";
        // 可以选择在这里返回一个 RejectedPromise 继续向下传递错误
        return new RejectedPromise("更深层次的错误：" . $reason->getMessage());
        // 也可以选择返回一个普通值来“恢复”链条，让后续的 onFulfilled 回调执行
        // return "错误已处理，返回默认值";
    })
    ->then(function ($value) { // 这个 onFulfilled 只有在上面错误被“恢复”时才执行
        echo "链条已恢复，继续处理: " . $value . "\n";
    }, function ($reason) { // 第二个错误处理回调，捕获转发的错误
        echo "最终错误处理: " . $reason . "\n";
    });

$dataPromise->resolve('初始数据');

/* 预期输出（取决于是否返回 RejectedPromise）：
捕获到错误: 处理数据时发生意外！
最终错误处理: 更深层次的错误：处理数据时发生意外！
*/

wait()

<pre class="brush:php;toolbar:false;">use GuzzleHttp\Promise\Promise;

$promise = new Promise(function () use (&$promise) {
    // 模拟一个耗时2秒的异步操作
    sleep(2);
    $promise->resolve('异步操作已完成！');
});

echo "开始等待异步操作...\n";
$result = $promise->wait(); // 阻塞当前脚本，直到 Promise 解决
echo "异步操作结果: " . $result . "\n";
echo "脚本继续执行。\n";

/* 预期输出：
开始等待异步操作...
（等待2秒）
异步操作结果: 异步操作已完成！
脚本继续执行。
*/

cancel()

<pre class="brush:php;toolbar:false;">use GuzzleHttp\Promise\Promise;

$promise = new Promise(
    function () use (&$promise) {
        // 模拟一个需要长时间运行的计算
        // 实际应用中，这里会有一些可以被中断的逻辑
        for ($i = 0; $i < 100000000; $i++) {
            if ($promise->getState() === 'rejected') { // 检查是否被取消
                echo "计算被取消！\n";
                return;
            }
        }
        $promise->resolve('长时间计算完成');
    },
    function () { // 取消回调
        echo "Promise 正在被取消...\n";
        // 在这里执行实际的取消逻辑，例如关闭文件句柄、中断网络请求等
    }
);

// 模拟一段时间后取消 Promise
// 注意：实际取消效果取决于 waitFn 和 cancelFn 的实现
\GuzzleHttp\Promise\Utils::queue()->add(function () use ($promise) {
    $promise->cancel();
}, 100); // 100毫秒后尝试取消

try {
    echo $promise->wait(); // 尝试等待结果
} catch (\GuzzleHttp\Promise\CancellationException $e) {
    echo "Promise 确实被取消了: " . $e->getMessage() . "\n";
}