Laravel队列调用外部API：保险类网站开发难题求助

嘿，这个场景我太熟了——处理多外部API调用时，既要防单点失败拖垮整个流程，又得让用户别等到天荒地老，确实是个典型的痛点。我来给你几个实用的方案，结合Laravel的生态来解决：

如果你的外部API响应时间都不算太长（比如几秒钟以内），这个方案最直接。核心思路是用Guzzle的异步并发请求，同时发起所有API调用，而不是串行等待，而且每个请求单独捕获异常，一个API失败不会影响其他请求的结果。

示例代码：

use GuzzleHttp\Client;
use GuzzleHttp\Promise;

// 初始化Guzzle客户端
$client = new Client();

// 定义所有要调用的API请求（可以根据用户输入动态生成）
$promises = [
    'insurance_a' => $client->postAsync('https://api.insurance-a.com/quote', [
        'json' => $userInputData // 你的用户输入数据
    ]),
    'insurance_b' => $client->postAsync('https://api.insurance-b.com/calculate', [
        'json' => $userInputData
    ]),
    // 继续添加更多API...
];

// 等待所有请求完成（不管成功失败，用settle而不是all）
$results = Promise\settle($promises)->wait();

// 整理最终响应给前端
$finalResponses = [];
foreach ($results as $apiName => $result) {
    if ($result['state'] === 'fulfilled') {
        // 成功的情况，解析响应内容
        $finalResponses[$apiName] = [
            'status' => 'success',
            'data' => json_decode($result['value']->getBody()->getContents(), true)
        ];
    } else {
        // 失败的情况，记录错误信息
        $finalResponses[$apiName] = [
            'status' => 'failed',
            'message' => $result['reason']->getMessage()
        ];
    }
}

// 返回整理后的结果到页面
return view('results', ['responses' => $finalResponses]);

优点：实现简单，不需要配置队列，用户等待时间等于最慢的那个API响应时间（而非所有API时间总和）；缺点：如果某个API响应特别慢，用户还是得等，且并发请求会占用当前Web进程，高流量下可能影响性能。

你之前提到用Laravel Queue但不知道怎么获取响应，核心问题是队列任务是异步的，无法直接同步返回结果，所以需要一个中间存储来跟踪每个任务的状态和响应数据。

步骤1：创建状态跟踪模型 #

先建一个模型（比如ApiRequestLog）来记录每个API请求的状态：

# 生成模型和迁移文件
php artisan make:model ApiRequestLog -m

在迁移文件里添加字段：

Schema::create('api_request_logs', function (Blueprint $table) {
    $table->id();
    $table->foreignId('user_id')->constrained(); // 关联提交请求的用户
    $table->string('api_name'); // API标识，比如insurance_a
    $table->string('job_id')->nullable(); // 队列任务ID
    $table->enum('status', ['pending', 'success', 'failed'])->default('pending');
    $table->text('response_data')->nullable(); // 存储API响应
    $table->text('error_message')->nullable(); // 存储错误信息
    $table->timestamps();
});

步骤2：创建队列任务类 #

每个API调用对应一个独立的任务，避免单个任务失败影响其他：

namespace App\Jobs;

use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\Dispatchable;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Queue\SerializesModels;
use GuzzleHttp\Client;
use App\Models\ApiRequestLog;

class CallInsuranceApi implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;

    protected $userInput;
    protected $apiLog;

    public function __construct(array $userInput, ApiRequestLog $apiLog)
    {
        $this->userInput = $userInput;
        $this->apiLog = $apiLog;
    }

    public function handle()
    {
        try {
            $client = new Client();
            $response = $client->post($this->apiLog->api_name, [ // 替换为实际API地址
                'json' => $this->userInput
            ]);

            // 更新日志为成功状态，存储响应
            $this->apiLog->update([
                'status' => 'success',
                'response_data' => $response->getBody()->getContents(),
                'job_id' => $this->job->getJobId()
            ]);
        } catch (\Exception $e) {
            // 更新日志为失败状态，存储错误
            $this->apiLog->update([
                'status' => 'failed',
                'error_message' => $e->getMessage(),
                'job_id' => $this->job->getJobId()
            ]);
        }
    }
}

步骤3：控制器触发任务并返回跟踪标识 #

用户提交数据后，初始化日志并分发任务，然后让前端轮询获取结果：

use App\Models\ApiRequestLog;
use App\Jobs\CallInsuranceApi;

public function submit(Request $request)
{
    $userInput = $request->validate([
        // 你的表单验证规则
    ]);

    // 定义需要调用的API列表
    $apis = [
        'insurance_a' => 'https://api.insurance-a.com/quote',
        'insurance_b' => 'https://api.insurance-b.com/calculate',
    ];

    // 初始化所有API日志，分发队列任务
    $logIds = [];
    foreach ($apis as $name => $url) {
        $log = ApiRequestLog::create([
            'user_id' => auth()->id(),
            'api_name' => $url // 这里存实际API地址，或者存标识再映射
        ]);
        $logIds[] = $log->id;
        CallInsuranceApi::dispatch($userInput, $log);
    }

    // 返回日志ID给前端，用于轮询
    return view('processing', ['logIds' => $logIds]);
}

步骤4：前端轮询获取结果 #

写一个接口让前端查询日志状态：

public function checkResults(Request $request)
{
    $logs = ApiRequestLog::whereIn('id', $request->log_ids)->get();
    
    return response()->json([
        'results' => $logs->map(function ($log) {
            return [
                'api' => $log->api_name,
                'status' => $log->status,
                'data' => $log->response_data ? json_decode($log->response_data, true) : null,
                'error' => $log->error_message
            ];
        }),
        'allCompleted' => $logs->every(fn($log) => $log->status !== 'pending')
    ]);
}

优点：不占用Web进程，适合长耗时API，单个任务失败不影响其他；缺点：需要前端做轮询，用户体验不如实时推送。

如果想让用户不用一直刷新页面，实时看到每个API的响应结果，可以结合Laravel的广播系统，当队列任务完成时，主动推送事件到前端。

核心思路 #

1. 配置广播驱动（比如Redis或Pusher）；
2. 队列任务完成时，广播一个ApiRequestCompleted事件；
3. 前端监听用户专属的私有频道，实时接收事件并更新页面。

示例事件类：

namespace App\Events;

use Illuminate\Broadcasting\PrivateChannel;
use Illuminate\Contracts\Broadcasting\ShouldBroadcast;
use Illuminate\Foundation\Events\Dispatchable;
use Illuminate\Queue\SerializesModels;
use App\Models\ApiRequestLog;

class ApiRequestCompleted implements ShouldBroadcast
{
    use Dispatchable, SerializesModels;

    public $log;

    public function __construct(ApiRequestLog $log)
    {
        $this->log = $log;
    }

    public function broadcastOn()
    {
        return new PrivateChannel('user.'.$this->log->user_id);
    }
}

然后在队列任务的handle方法末尾添加：

event(new ApiRequestCompleted($this->apiLog));

前端通过Laravel Echo监听频道，实时更新页面即可。

优点：用户体验好，实时看到结果；缺点：需要配置广播服务，稍微复杂一点。

内容的提问来源于stack exchange，提问作者romi