Je voudrais gérer les erreurs de Guzzle lorsque le serveur renvoie les codes d'état 4xx et 5xx. Je fais une demande comme celle-ci:

$client = $this->getGuzzleClient();
$request = $client->post($url, $headers, $value);
try {
    $response = $request->send();
    return $response->getBody();
} catch (\Exception $e) {
    // How can I get the response body?
}

$e->getMessagerenvoie les informations de code mais pas le corps de la réponse HTTP. Comment puis-je obtenir le corps de la réponse?

Guzzle 3.x

Selon la documentation , vous pouvez attraper le type d'exception approprié ( ClientErrorResponseExceptionpour les erreurs 4xx) et appeler sa getResponse()méthode pour obtenir l'objet de réponse, puis appeler getBody()cela:

use Guzzle\Http\Exception\ClientErrorResponseException;

...

try {
    $response = $request->send();
} catch (ClientErrorResponseException $exception) {
    $responseBody = $exception->getResponse()->getBody(true);
}

Passer trueà la getBodyfonction indique que vous souhaitez obtenir le corps de la réponse sous forme de chaîne. Sinon, vous l'obtiendrez comme instance de classe Guzzle\Http\EntityBody.

Guzzle 6.x

Selon la documentation , les types d'exceptions que vous devrez peut-être attraper sont:

• GuzzleHttp\Exception\ClientException pour les erreurs de niveau 400
• GuzzleHttp\Exception\ServerException pour les erreurs de niveau 500
• GuzzleHttp\Exception\BadResponseException pour les deux (c'est leur superclasse)

Le code pour gérer de telles erreurs ressemble donc maintenant à ceci:

$client = new GuzzleHttp\Client;
try {
    $client->get('http://google.com/nosuchpage');    
}
catch (GuzzleHttp\Exception\ClientException $e) {
    $response = $e->getResponse();
    $responseBodyAsString = $response->getBody()->getContents();
}

Bien que les réponses ci-dessus soient bonnes, elles ne détecteront pas les erreurs de réseau. Comme Mark l'a mentionné, BadResponseException n'est qu'une super classe pour ClientException et ServerException. Mais RequestException est également une super classe de BadResponseException. RequestException sera lancée non seulement pour les erreurs 400 et 500, mais aussi pour les erreurs réseau et les redirections infinies. Supposons que vous demandiez la page ci-dessous mais que votre réseau joue et que votre capture n'attend qu'une BadResponseException. Eh bien, votre application générera une erreur.

Il est préférable dans ce cas d'attendre RequestException et de rechercher une réponse.

try {
  $client->get('http://123123123.com')
} catch (RequestException $e) {

  // If there are network errors, we need to ensure the application doesn't crash.
  // if $e->hasResponse is not null we can attempt to get the message
  // Otherwise, we'll just pass a network unavailable message.
  if ($e->hasResponse()) {
    $exception = (string) $e->getResponse()->getBody();
    $exception = json_decode($exception);
    return new JsonResponse($exception, $e->getCode());
  } else {
    return new JsonResponse($e->getMessage(), 503);
  }

}

À partir de 2019, voici ce que j'ai élaboré à partir des réponses ci-dessus et de la documentation Guzzle pour gérer l'exception, obtenir le corps de la réponse, le code d'état, le message et les autres éléments de réponse parfois précieux.

try {
    /**
     * We use Guzzle to make an HTTP request somewhere in the
     * following theMethodMayThrowException().
     */
    $result = theMethodMayThrowException();
} catch (\GuzzleHttp\Exception\RequestException $e) {
    /**
     * Here we actually catch the instance of GuzzleHttp\Psr7\Response
     * (find it in ./vendor/guzzlehttp/psr7/src/Response.php) with all
     * its own and its 'Message' trait's methods. See more explanations below.
     *
     * So you can have: HTTP status code, message, headers and body.
     * Just check the exception object has the response before.
     */
    if ($e->hasResponse()) {
        $response = $e->getResponse();
        var_dump($response->getStatusCode()); // HTTP status code;
        var_dump($response->getReasonPhrase()); // Response message;
        var_dump((string) $response->getBody()); // Body, normally it is JSON;
        var_dump(json_decode((string) $response->getBody())); // Body as the decoded JSON;
        var_dump($response->getHeaders()); // Headers array;
        var_dump($response->hasHeader('Content-Type')); // Is the header presented?
        var_dump($response->getHeader('Content-Type')[0]); // Concrete header value;
    }
}
// process $result etc. ...

Voila. Vous obtenez les informations de la réponse dans des éléments séparés de manière pratique.

Notes secondaires:

Avec la catchclause, nous capturons la classe d'exception racine PHP de la chaîne d'héritage \Exceptioncar les exceptions personnalisées Guzzle l'étendent.

Cette approche peut être utile pour les cas d'utilisation où Guzzle est utilisé sous le capot, comme dans Laravel ou AWS API PHP SDK, de sorte que vous ne pouvez pas intercepter la véritable exception Guzzle.

Dans ce cas, la classe d'exception peut ne pas être celle mentionnée dans la documentation Guzzle (par exemple en GuzzleHttp\Exception\RequestExceptiontant qu'exception racine pour Guzzle).

Vous devez donc attraper à la \Exceptionplace, mais gardez à l'esprit qu'il s'agit toujours de l'instance de classe d'exception Guzzle.

Bien utiliser avec précaution. Ces wrappers peuvent rendre $e->getResponse()les méthodes authentiques des objets Guzzle non disponibles. Dans ce cas, vous devrez regarder le code source des exceptions du wrapper et découvrir comment obtenir le statut, le message, etc. au lieu d'utiliser $responseles méthodes de Guzzle .

Si vous appelez Guzzle directement vous-même, vous pouvez attraper GuzzleHttp\Exception\RequestExceptionou tout autre élément mentionné dans leurs documents d'exceptions en ce qui concerne les conditions de votre cas d'utilisation.

si elles sont mises 'http_errors' => falsedans les options de demande Guzzle, il arrêterait exception throw tout get 4xx ou 5xx erreur, comme ceci: $client->get(url, ['http_errors' => false]). alors vous analysez la réponse, peu importe que ce soit correct ou une erreur, ce serait dans la réponse pour plus d'informations