PHP异步编程不再是难题：如何利用Composer和GuzzlePromises优雅地处理并发操作

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

<code class="php">use GuzzleHttp\Promise\Promise;

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

// 注册成功和失败的回调
$promise->then(
    function ($value) {
        echo "Promise成功了，值是: " . $value . "\n";
    },
    function ($reason) {
        echo "Promise失败了，原因是: " . $reason . "\n";
    }
);

// 模拟一个异步操作，比如几秒后返回结果
// 实际应用中，这里可能是发起一个HTTP请求、数据库查询等
echo "异步操作开始...\n";
// 在某个时刻，我们手动解析这个Promise
// 假设这是异步操作完成后调用的
$promise->resolve('这是异步操作的结果');
echo "Promise已解析，但回调可能稍后执行。\n";

// 注意：在没有事件循环的情况下，需要手动等待或运行任务队列来触发回调
// Guzzle Promises 会在wait()时自动运行内部任务队列
// 如果在事件循环中使用，则需要将队列集成到循环中
// GuzzleHttp\Promise\Utils::queue()->run();</code>

<code class="php">use GuzzleHttp\Promise\Promise;

$promise = new Promise();

$promise
    ->then(function ($value) {
        echo "第一步：接收到值 - " . $value . "\n";
        // 返回一个新的值，它将传递给下一个then
        return $value . '，经过第一步处理';
    })
    ->then(function ($value) {
        echo "第二步：接收到值 - " . $value . "\n";
        // 也可以返回一个新的Promise，后续的then会等待这个新Promise解析
        $nextPromise = new Promise();
        // 模拟一个更耗时的操作
        // sleep(1); // 实际中这里是异步I/O
        $nextPromise->resolve($value . '，再经过第二步处理');
        return $nextPromise;
    })
    ->then(function ($value) {
        echo "第三步：最终结果 - " . $value . "\n";
    })
    ->otherwise(function ($reason) { // 捕获链中任何环节的错误
        echo "操作失败： " . $reason . "\n";
    });

// 启动Promise链
$promise->resolve('原始数据');

// 同步等待所有Promise完成（在没有事件循环时非常有用）
// 否则，脚本可能在Promise解析前结束
$promise->wait(); // 会阻塞直到所有链式Promise完成</code>

<code class="php">use GuzzleHttp\Promise\Promise;
use GuzzleHttp\Promise\Utils;

// 模拟异步API请求函数
function fetchApiData(string $apiName, int $delayMs): Promise
{
    return new Promise(function ($resolve, $reject) use ($apiName, $delayMs) {
        // 实际中这里会发起HTTP请求
        // 这里用一个异步任务模拟，实际可能结合GuzzleHttp\Client的异步请求
        // 比如 GuzzleHttp\Client->getAsync()
        echo "开始请求 {$apiName}...\n";
        // 在真实异步场景下，这里不会阻塞，而是注册一个回调
        // 为了演示，我们假设它最终会resolve
        // 模拟异步延迟
        Utils::queue()->add(function() use ($resolve, $apiName, $delayMs) {
            usleep($delayMs * 1000); // 模拟延迟
            $resolve("{$apiName} 的数据");
            echo "完成请求 {$apiName}。\n";
        });
    });
}

// 同时发起三个API请求
$apiPromises = [
    'user' => fetchApiData('用户API', 500),
    'orders' => fetchApiData('订单API', 700),
    'products' => fetchApiData('商品API', 600),
];

echo "所有API请求并发启动...\n";

// 使用 Utils::all() 等待所有Promise完成
$resultsPromise = Utils::all($apiPromises);

// 同步等待所有结果（在Web请求中，这会阻塞直到所有Promise完成）
try {
    $allResults = $resultsPromise->wait();
    echo "\n所有API数据已获取：\n";
    print_r($allResults);
} catch (\Exception $e) {
    echo "\n某个API请求失败： " . $e->getMessage() . "\n";
}

// 在一个真正的事件循环驱动的应用中，你还需要确保事件循环在运行，例如：
// $loop = React\EventLoop\Factory::create();
// $loop->addPeriodicTimer(0, [Utils::queue(), 'run']);
// $loop->run();</code>

<code class="php">use GuzzleHttp\Promise\Promise;
use GuzzleHttp\Promise\RejectedPromise;

$promise = new Promise();

$promise
    ->then(function ($value) {
        echo "成功处理：" . $value . "\n";
        // 模拟一个后续操作中发生的错误
        throw new \Exception("处理过程中发生了意外！");
        return $value . "已处理";
    })
    ->otherwise(function (\Exception $e) { // 捕获上一个then中抛出的异常
        echo "捕获到错误： " . $e->getMessage() . "\n";
        // 你可以选择返回一个值来恢复链条，或者继续抛出RejectedPromise来向下传递错误
        return new RejectedPromise("错误已处理，但仍然是失败状态");
    })
    ->then(null, function ($reason) { // 第二个then的拒绝回调，捕获otherwise返回的RejectedPromise
        echo "链条末端捕获到拒绝： " . $reason . "\n";
    });

// 启动Promise
$promise->resolve('初始数据');
$promise->wait(false); // 不抛出异常，只确保Promise完成</code>