Vous pouvez personnaliser les demandes créées et transférées par un client en utilisant options de demande. Les options de requête contrôlent divers aspects d'une requête notamment les en-têtes, les paramètres de la chaîne de requête, les paramètres du délai d'attente, le corps d'une d'une requête, et bien plus encore.
Tous les exemples suivants utilisent le client suivant :
$client = new GuzzleHttp\Client(['base_uri' => 'http://httpbin.org']);
Décrit le comportement de redirection d'une demande
[
max' => ; 5,
strict' => ; false,
'referer' => ; false,
'protocols' => ; [ 'http', 'https'],
'track_redirects' => ; false
]
GuzzleHttp\RequestOptions::ALLOW_REDIRECTS
Défini à false
pour désactiver les redirections.
$res = $client->request('GET', '/redirect/3', ['allow_redirects' => false]);
echo $res->getStatusCode();
// 302
Défini à true
(le paramètre par défaut) pour activer les redirections normales avec un nombre maximum de 5 redirections.
$res = $client->request('GET', '/redirect/3');
echo $res->getStatusCode();
// 200
Vous pouvez également transmettre un tableau associatif contenant les paires clé-valeur suivantes :
max : (int, default=5) nombre maximum de redirections autorisées.
strict : (bool, default=false) Définissez à true pour utiliser des redirections strictes. Les redirections strictes conformes à la RFC signifient que les demandes de redirection POST sont envoyées en tant que demandes POST au lieu de faire ce que la plupart des navigateurs font, c'est-à-dire rediriger les demandes POST avec des demandes GET. avec des demandes GET.
referer : (bool, default=false) Mettre à true pour activer l'ajout de l'en-tête Referer lors de la redirection.
protocoles : (tableau, default=[ 'http', 'https']) Spécifie les protocoles autorisés pour les requêtes de autorisés pour les demandes de redirection.
on_redirect : (appelable) Appelable PHP qui est invoqué lorsqu'une redirection est rencontrée. L'appelable est invoqué avec la requête originale et la réponse de réponse de redirection reçue. Toute valeur de retour de la fonction on_redirect est ignorée.
track_redirects : (bool) Lorsqu'il vaut true
, chaque URI et code d'état redirigé
rencontré sera suivi dans le X-Guzzle-Redirect-History
et dans le X-Guzzle-Redirect-History
.
X-Guzzle-Redirect-Status-History
respectivement. Tous les URI et
codes d'état seront stockés dans l'ordre dans lequel les redirections ont été rencontrées.
X-Guzzle-Redirect-Status-History
exclura le code d'état final.use Psr\Http\Message\RequestInterface;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\UriInterface;
$onRedirect = function(
RequestInterface $request,
ResponseInterface $response,
UriInterface $uri
) {
echo 'Redirecting! ' . $request->getUri() . ' to ' . $uri . "\n";
};
$res = $client->request('GET', '/redirect/3', [
'allow_redirects' => [
'max' => 10, // allow at most 10 redirects.
'strict' => true, // use "strict" RFC compliant redirects.
'referer' => true, // add a Referer header
'protocols' => ['https'], // only allow https URLs
'on_redirect' => $onRedirect,
'track_redirects' => true
]
]);
echo $res->getStatusCode();
// 200
echo $res->getHeaderLine('X-Guzzle-Redirect-History');
// http://first-redirect, http://second-redirect, etc...
echo $res->getHeaderLine('X-Guzzle-Redirect-Status-History');
// 301, 302, etc...
Avertissement
Cette option n'a d'effet que si votre gestionnaire possède la fonction
L'intergiciel GuzzleHttp\Middleware::redirect
. Cet intergiciel est ajouté
ajouté par défaut lorsqu'un client est créé sans gestionnaire, et il est ajouté par
par défaut lors de la création d'un gestionnaire avec GuzzleHttp\HandlerStack::create
.
Note
Cette option n'a aucun effet lorsque vous effectuez des requêtes en utilisant GuzzleHttp\Client::sendRequest()
. Afin de rester conforme à PSR-18, toute réponse de redirection est retournée telle quelle.
Passez un tableau de paramètres d'authentification HTTP à utiliser avec la
requête. Le tableau doit contenir le nom d'utilisateur dans l'index [0], le mot de passe dans l'index
l'index [1], et vous pouvez éventuellement fournir un type d'authentification intégré dans l'index
index [2]. Passez null
pour désactiver l'authentification pour une requête.
Aucun
GuzzleHttp\RequestOptions::AUTH
Les types d'authentification intégrés sont les suivants :
Authorization
(paramètre par défaut utilisé si aucun n'est
spécifié).$client->request('GET', '/get', ['auth' => ['username', 'password']]);
$client->request('GET', '/get', [
'auth' => ['username', 'password', 'digest']
]);
Note
Actuellement, ceci n'est supporté que lors de l'utilisation du gestionnaire cURL, mais mais la création d'un remplacement pouvant être utilisé avec n'importe quel gestionnaire prévue.
$client->request('GET', '/get', [
'auth' => ['username', 'password', 'ntlm']
]);
Note
Actuellement, cette fonction n'est prise en charge que lorsque vous utilisez le gestionnaire cURL.
L'option body
est utilisée pour contrôler le corps d'une entité
requête englobante (par exemple, PUT, POST, PATCH).
fopen()
ressourcePsr\Http\Message\StreamInterface
Aucun
GuzzleHttp\RequestOptions::BODY
Ce paramètre peut être réglé sur l'un des types suivants :
chaîne
>// Vous pouvez envoyer des requêtes qui utilisent une chaîne comme corps de message.
$client->request('PUT', '/put', [ 'body' => ; 'foo']) ;
ressource renvoyée par fopen()
// Vous pouvez envoyer des requêtes qui utilisent une ressource de flux comme corps.
$resource = \GuzzleHttp\Psr7\Utils::tryFopen('http://httpbin.org', 'r') ;
$client->request('PUT', '/put', [ 'body' => ; $resource]) ;
Psr\Http\Message\StreamInterface
// Vous pouvez envoyer des requêtes qui utilisent un objet de flux Guzzle comme corps
$stream = GuzzleHttp\Psr7\Utils::streamFor('contents...') ;
$client->request('POST', '/post', [ 'body' => ; $stream]) ;
Note
Cette option ne peut pas être utilisée avec form_params
, multipart
, ou json
.
Défini comme une chaîne pour spécifier le chemin d'accès à un fichier contenant un certificat côté client au format PEM côté client. Si un mot de passe est requis, définissez la valeur un tableau contenant le chemin d'accès au fichier PEM dans le premier élément du tableau suivi du mot de passe requis pour le certificat dans le deuxième élément du tableau. élément du tableau.
Aucun
GuzzleHttp\RequestOptions::CERT
$client->request('GET', '/', ['cert' => ['/path/server.pem', 'password']]);
GuzzleHttp\Cookie\CookieJarInterface
GuzzleHttp\RequestOptions::COOKIES
Vous devez spécifier l'option cookies comme GuzzleHttp\Cookie\CookieJarInterface
ou false
.
$jar = new \GuzzleHttp\Cookie\CookieJar();
$client->request('GET', '/get', ['cookies' => $jar]);
Avertissement
Cette option n'a d'effet que si votre gestionnaire dispose de l'option
L'intergiciel GuzzleHttp\Middleware::cookies
. Cet intergiciel est ajouté
ajouté par défaut lorsqu'un client est créé sans gestionnaire, et il est ajouté par
par défaut lors de la création d'un gestionnaire avec GuzzleHttp\default_handler
.
Conseil
Lorsque vous créez un client, vous pouvez définir l'option de cookie par défaut sur true
pour utiliser une session de cookie partagée associée au client.
0
pour attendre indéfiniment (le comportement par défaut).0
GuzzleHttp\RequestOptions::CONNECT_TIMEOUT
// Timeout if the client fails to connect to the server in 3.14 seconds.
$client->request('GET', '/delay/5', ['connect_timeout' => 3.14]);
Note
Ce paramètre doit être pris en charge par le gestionnaire HTTP utilisé pour envoyer une requête.
connect_timeout
n'est actuellement pris en charge que par le gestionnaire intégré cURL
intégré.
Défini à true
ou défini à un flux PHP retourné par fopen()
pour
activer la sortie de débogage avec le gestionnaire utilisé pour envoyer une requête. Par exemple,
lorsque vous utilisez cURL pour transférer des requêtes, le verbiage de cURL de CURLOPT_VERBOSE
sera émis. Lorsque vous utilisez le wrapper de flux PHP, les notifications du wrapper de flux
seront émises. S'il est défini à true, la sortie est écrite dans le fichier
STDOUT de PHP. Si un flux PHP est fourni, la sortie est écrite dans le flux.
fopen()
ressourceAucun
GuzzleHttp\RequestOptions::DEBUG
$client->request('GET', '/get', ['debug' => true]);
L'exécution de l'exemple ci-dessus produirait un résultat semblable à celui qui suit :
* About to connect() to httpbin.org port 80 (#0)
* Trying 107.21.213.98... * Connected to httpbin.org (107.21.213.98) port 80 (#0)
> GET /get HTTP/1.1
Host: httpbin.org
User-Agent: Guzzle/4.0 curl/7.21.4 PHP/5.5.7
< HTTP/1.1 200 OK
< Access-Control-Allow-Origin: *
< Content-Type: application/json
< Date: Sun, 16 Feb 2014 06:50:09 GMT
< Server: gunicorn/0.17.4
< Content-Length: 335
< Connection: keep-alive
<
* Connection #0 to host httpbin.org left intact
Spécifiez si les réponses Content-Encoding
(gzip,
deflate, etc.) sont automatiquement décodées.
true
GuzzleHttp\RequestOptions::DECODE_CONTENT
Cette option peut être utilisée pour contrôler la façon dont les corps de réponse codés en contenu sont traités.
sont traités. Par défaut, decode_content
a la valeur true, ce qui signifie que toute réponse gzippée ou déflatée sera décodée par Guzzle.
ou déflatée sera décodée par Guzzle.
Lorsqu'il est défini sur false
, le corps d'une réponse n'est jamais décodé, ce qui signifie que les octets passent par le gestionnaire sans être modifiés.
// Request gzipped data, but do not decode it while downloading
$client->request('GET', '/foo.js', [
'headers' => ['Accept-Encoding' => 'gzip'],
'decode_content' => false
]);
Lorsqu'elle est définie sur une chaîne de caractères, les octets d'une réponse sont décodés et la valeur de chaîne de caractères
fournie à l'option decode_content
est transmise comme en-tête Accept-Encoding
de la requête.
// Pass "gzip" as the Accept-Encoding header.
$client->request('GET', '/foo.js', ['decode_content' => 'gzip']);
Le nombre de millisecondes à attendre avant d'envoyer la requête.
null
GuzzleHttp\RequestOptions::DELAY
Contrôle le comportement de l'en-tête "Expect : 100-Continue".
1048576
GuzzleHttp\RequestOptions::EXPECT
Défini à true
pour activer l'en-tête "Expect : 100-Continue" pour toutes les demandes
qui envoient un corps. Défini à false
pour désactiver l'en-tête "Expect : 100-Continue".
pour toutes les demandes. Défini à un nombre de sorte que la taille de la charge utile doit être supérieure à ce nombre pour que la demande soit acceptée.
doit être supérieure à ce nombre pour que l'en-tête Expect soit envoyé. La définition d'un nombre
nombre, l'en-tête Expect sera envoyé pour toutes les requêtes pour lesquelles la taille de la charge utile ne peut pas être déterminée ou pour lesquelles l'en-tête Expect sera envoyé.
charge utile ne peut être déterminée ou dont le corps n'est pas réenroulable.
Par défaut, Guzzle ajoute l'en-tête "Expect : 100-Continue" lorsque la taille du corps d'une requête est supérieure à 1 Mo et que la requête utilise HTTP/1.1.
Note
Cette option ne prend effet que si vous utilisez HTTP/1.1. Les protocoles HTTP/1.0 et HTTP/2.0 ne prennent pas en charge l'en-tête "Expect : 100-Continue". La prise en charge de la gestion du flux de travail "Expect : 100-Continue" doit être être implémentée par les gestionnaires HTTP de Guzzle utilisés par un client.
GuzzleHttp\RequestOptions::FORCE_IP_RESOLVE
// Force ipv4 protocol
$client->request('GET', '/foo', ['force_ip_resolve' => 'v4']);
// Force ipv6 protocol
$client->request('GET', '/foo', ['force_ip_resolve' => 'v6']);
Note
Ce paramètre doit être pris en charge par le gestionnaire HTTP utilisé pour envoyer une requête.
force_ip_resolve
est actuellement pris en charge uniquement par les gestionnaires intégrés cURL
et les gestionnaires de flux intégrés.
GuzzleHttp\RequestOptions::FORM_PARAMS
Tableau associatif de noms de champs de formulaire vers des valeurs où chaque valeur est une chaîne ou un tableau de chaînes de caractères. Définit l'en-tête Content-Type à application/x-www-form-urlencoded lorsque aucun en-tête Content-Type n'est déjà présent.
$client->request('POST', '/post', [
'form_params' => [
'foo' => 'bar',
'baz' => ['hi', 'there!']
]
]);
Note
Le form_params
ne peut pas être utilisé avec l'option multipart
. Vous devez utiliser
l'une ou l'autre. Utilisez form_params
pour les demandes application/x-www-form-urlencoded
et multipart
pour les demandes multipart/form-data
.
Cette option ne peut pas être utilisée avec body
, multipart
, ou json
.
GuzzleHttp\RequestOptions::HEADERS
// Set various headers on a request
$client->request('GET', '/get', [
'headers' => [
'User-Agent' => 'testing/1.0',
'Accept' => 'application/json',
'X-Foo' => ['Bar', 'Baz']
]
]);
Les en-têtes peuvent être ajoutés comme options par défaut lors de la création d'un client. Lorsque des en-têtes
sont utilisés comme options par défaut, ils ne sont appliqués que si la requête en cours de création
ne contient pas déjà l'en-tête spécifique. Cela inclut les demandes transmises
au client par les méthodes send()
et sendAsync()
, ainsi que les demandes
créées par le client (par exemple, request()
et requestAsync()
).
$client = new GuzzleHttp\Client(['headers' => ['X-Foo' => 'Bar']]);
// Will send a request with the X-Foo header.
$client->request('GET', '/get');
// Sets the X-Foo header to "test", which prevents the default header
// from being applied.
$client->request('GET', '/get', ['headers' => ['X-Foo' => 'test']]);
// Will disable adding in default headers.
$client->request('GET', '/get', ['headers' => null]);
// Will not overwrite the X-Foo header because it is in the message.
use GuzzleHttp\Psr7\Request;
$request = new Request('GET', 'http://foo.com', ['X-Foo' => 'test']);
$client->send($request);
// Will overwrite the X-Foo header with the request option provided in the
// send method.
use GuzzleHttp\Psr7\Request;
$request = new Request('GET', 'http://foo.com', ['X-Foo' => 'test']);
$client->send($request, ['headers' => ['X-Foo' => 'overwrite']]);
false
pour désactiver l'envoi d'exceptions sur les erreurs de protocole HTTP (c'est-à-dire les réponses 4xx et 5xx).
(c'est-à-dire les réponses 4xx et 5xx). Les exceptions sont lancées par défaut lorsque
des erreurs de protocole HTTP sont rencontrées.true
GuzzleHttp\RequestOptions::HTTP_ERRORS
$client->request('GET', '/status/500');
// Throws a GuzzleHttp\Exception\ServerException
$res = $client->request('GET', '/status/500', ['http_errors' => false]);
echo $res->getStatusCode();
// 500
Avertissement
Cette option n'a d'effet que si votre gestionnaire possède l'attribut
L'intergiciel GuzzleHttp\Middleware::httpErrors
. Cet intergiciel est ajouté
ajouté par défaut lorsqu'un client est créé sans gestionnaire, et il est ajouté par
par défaut lors de la création d'un gestionnaire avec GuzzleHttp\default_handler
.
Prise en charge des noms de domaine internationalisés (IDN) (activée par défaut si
intl
extension est disponible).
true
si intl
l'extension est disponible (et la bibliothèque ICU est 4.6+ pour PHP 7.2+), false
sinon
GuzzleHttp\RequestOptions::IDN_CONVERSION
$client->request('GET', 'https://яндекс.рф');
// яндекс.рф is translated to xn--d1acpjx3f.xn--p1ai before passing it to the handler
$res = $client->request('GET', 'https://яндекс.рф', ['idn_conversion' => false]);
// The domain part (яндекс.рф) stays unmodified
Active/désactive le support IDN, peut également être utilisé pour un contrôle précis en combinant
Constantes IDNA_* (sauf IDNA_ERROR_*), voir le paramètre $options
de la fonction
idn_to_ascii()
pour plus de détails.
json
est utilisée pour télécharger facilement des données encodées en JSON dans le
corps d'une requête. Un en-tête Content-Type de application/json
sera
ajouté si aucun en-tête Content-Type n'est déjà présent dans le message.json_encode()
de PHP.GuzzleHttp\RequestOptions::JSON
$response = $client->request('PUT', '/put', ['json' => ['foo' => 'bar']]);
Voici un exemple d'utilisation de l'intergiciel tap
pour voir quelle requête est envoyée sur le fil.
use GuzzleHttp\Middleware;
// Create a middleware that echoes parts of the request.
$tapMiddleware = Middleware::tap(function ($request) {
echo $request->getHeaderLine('Content-Type');
// application/json
echo $request->getBody();
// {"foo":"bar"}
});
// The $handler variable is the handler passed in the
// options to the client constructor.
$response = $client->request('PUT', '/put', [
'json' => ['foo' => 'bar'],
'handler' => $tapMiddleware($handler)
]);
Note
Cette option de requête ne permet pas de personnaliser l'en-tête Content-Type
ni aucune des options de la fonction PHP json_encode()
de PHP. Si vous devez personnaliser ces paramètres, vous devez transmettre les données codées en format
données codées en JSON dans la requête en utilisant l'option de requête body
.
et vous devez spécifier l'en-tête Content-Type correct à l'aide de l'option
headers
.
Cette option ne peut pas être utilisée avec body
, form_params
, ou multipart
.
GuzzleHttp\RequestOptions::MULTIPART
La valeur de multipart
est un tableau de tableaux associatifs, chacun contenant les paires clé-valeur suivantes :
nom
: (string, required) le nom du champ du formulairecontenu
: (StreamInterface/resource/string, obligatoire) Les données à utiliser dans l'élément
l'élément de formulaire.en-têtes
: (array) Tableau associatif facultatif d'en-têtes personnalisés à utiliser avec
l'élément de formulaire.nom de fichier
: (string) Chaîne optionnelle à envoyer comme nom de fichier dans la pièce.use GuzzleHttp\Psr7;
$client->request('POST', '/post', [
'multipart' => [
[
'name' => 'foo',
'contents' => 'data',
'headers' => ['X-Baz' => 'bar']
],
[
'name' => 'baz',
'contents' => Psr7\Utils::tryFopen('/path/to/file', 'r')
],
[
'name' => 'qux',
'contents' => Psr7\Utils::tryFopen('/path/to/file', 'r'),
'filename' => 'custom_filename.txt'
],
]
]);
Note
Le multipart
ne peut pas être utilisé avec l'option form_params
. Vous devrez
utiliser l'une ou l'autre. Utilisez form_params
pour les demandes application/x-www-form-urlencoded
et multipart
pour les demandes multipart/form-data
.
Cette option ne peut pas être utilisée avec body
, form_params
, ou json
.
Un appelable qui est invoqué lorsque les en-têtes HTTP de la réponse ont été reçus mais que le corps n'a pas encore commencé à être téléchargé. ont été reçus mais que le corps de la réponse n'a pas encore commencé à être téléchargé
GuzzleHttp\RequestOptions::ON_HEADERS
L'appelant accepte un objet Psr\Http\Message\ResponseInterface
. Si une exception
est levée par l'appelant, alors la promesse associée à la réponse sera
réponse sera rejetée avec un objet GuzzleHttp\Exception\RequestException
qui englobe l'exception levée.
exception qui a été déclenchée.
Vous pouvez avoir besoin de savoir quels en-têtes et codes d'état ont été reçus avant que les données puissent être écrites sur le récepteur.
// Reject responses that are greater than 1024 bytes.
$client->request('GET', 'http://httpbin.org/stream/1024', [
'on_headers' => function (ResponseInterface $response) {
if ($response->getHeaderLine('Content-Length') > 1024) {
throw new \Exception('The file is too big!');
}
}
]);
Note
Lors de l'écriture de gestionnaires HTTP, la fonction on_headers
doit être invoquée
avant d'écrire des données dans le corps de la réponse.
on_stats
vous permet d'accéder aux statistiques de transfert d'une
demande et d'accéder aux détails de transfert de niveau inférieur du gestionnaire
associé à votre client. on_stats
est un callable qui est invoqué
lorsqu'un gestionnaire a fini d'envoyer une demande. La callback est invoquée
avec des statistiques de transfert sur la demande, la réponse reçue ou l'erreur rencontrée.
l'erreur rencontrée. Les données comprennent le temps total pris pour envoyer la demande.
pour envoyer la demande.
GuzzleHttp\RequestOptions::ON_STATS
L'appelant accepte un objet GuzzleHttp\TransferStats
.
use GuzzleHttp\TransferStats;
$client = new GuzzleHttp\Client();
$client->request('GET', 'http://httpbin.org/stream/1024', [
'on_stats' => function (TransferStats $stats) {
echo $stats->getEffectiveUri() . "\n";
echo $stats->getTransferTime() . "\n";
var_dump($stats->getHandlerStats());
// You must check if a response was received before using the
// response object.
if ($stats->hasResponse()) {
echo $stats->getResponse()->getStatusCode();
} else {
// Error data is handler specific. You will need to know what
// type of error data your handler uses before using this
// value.
var_dump($stats->getHandlerErrorData());
}
}
]);
Définit une fonction à invoquer lorsque le transfert progresse.
Aucun
GuzzleHttp\RequestOptions::PROGRESS
La fonction accepte les arguments positionnels suivants :
// Send a GET request to /get?foo=bar
$result = $client->request(
'GET',
'/',
[
'progress' => function(
$downloadTotal,
$downloadedBytes,
$uploadTotal,
$uploadedBytes
) {
//do something
},
]
);
Passez une chaîne pour spécifier un proxy HTTP, ou un tableau pour spécifier différents proxys pour différents protocoles
différents mandataires pour différents protocoles.Aucun
GuzzleHttp\RequestOptions::PROXY
Passez une chaîne pour spécifier un proxy pour tous les protocoles.
$client->request('GET', '/', ['proxy' => 'http://localhost:8125']);
Passez un tableau associatif pour spécifier les proxies HTTP pour des schémas URI spécifiques (c'est-à-dire "http", "https").
(par exemple, "http", "https"). Fournir une paire clé-valeur no
afin de fournir une liste de
noms d'hôtes qui ne doivent pas faire l'objet d'un proxy.
Note
Guzzle remplit automatiquement cette valeur avec la variable d'environnement suivante
variable d'environnement NO_PROXY
. Toutefois, lorsque vous fournissez une option de demande proxy
c'est à vous de fournir la valeur no
analysée à partir des éléments suivants
la variable d'environnement NO_PROXY
.
(par exemple, explode(',', getenv('NO_PROXY'))
).
$client->request('GET', '/', [
'proxy' => [
'http' => 'http://localhost:8125', // Use this proxy with "http"
'https' => 'http://localhost:9124', // Use this proxy with "https",
'no' => ['.mit.edu', 'foo.com'] // Don't use a proxy with these
]
]);
Note
Vous pouvez fournir des URL de proxy qui contiennent un schéma, un nom d'utilisateur et un mot de passe.
Par exemple, "http://username:[email protected]:10"
.
Tableau associatif de valeurs de chaîne de requête ou de chaîne de requête à ajouter à la demande
la requêteAucun
GuzzleHttp\RequestOptions::QUERY
// Send a GET request to /get?foo=bar
$client->request('GET', '/get', ['query' => ['foo' => 'bar']]);
Les chaînes de requête spécifiées dans l'option query
écraseront toutes les valeurs de chaîne de requête fournies dans l'URI d'une demande.
// Send a GET request to /get?foo=bar
$client->request('GET', '/get?abc=123', ['query' => ['foo' => 'bar']]);
default_socket_timeout
.GuzzleHttp\RequestOptions::READ_TIMEOUT
Le délai d'attente s'applique aux opérations de lecture individuelles sur un corps en continu (lorsque l'option stream
est activée).
$response = $client->request('GET', '/stream', [
'stream' => true,
'read_timeout' => 10,
]);
$body = $response->getBody();
// Returns false on timeout
$data = $body->read(1024);
// Returns false on timeout
$line = fgets($body->detach());
Indiquez où le corps d'une réponse sera enregistré.
fopen()
ressourcePsr\Http\Message\StreamInterface
Flux temporaire PHP
GuzzleHttp\RequestOptions::SINK
Passez une chaîne pour spécifier le chemin d'accès à un fichier qui stockera le contenu du corps de la réponse :
$client->request('GET', '/stream/20', ['sink' => '/path/to/file']);
Passez une ressource retournée par fopen()
pour écrire la réponse dans un flux PHP :
$resource = \GuzzleHttp\Psr7\Utils::tryFopen('/path/to/file', 'w');
$client->request('GET', '/stream/20', ['sink' => $resource]);
Passez un objet Psr\Http\Message\StreamInterface
pour transmettre le corps de la réponse à un flux PSR-7 ouvert.
$resource = \GuzzleHttp\Psr7\Utils::tryFopen('/path/to/file', 'w');
$stream = \GuzzleHttp\Psr7\Utils::streamFor($resource);
$client->request('GET', '/stream/20', ['save_to' => $stream]);
Note
L'option de requête save_to
a été dépréciée au profit de l'option de requête
sink
. La fourniture de l'option save_to
est maintenant un alias
de sink
.
Spécifiez le chemin d'accès à un fichier contenant une clé SSL privée au format PEM . Si un mot de passe est requis, il est défini comme un tableau contenant le chemin contenant le chemin d'accès à la clé SSL dans le premier élément du tableau, suivi du mot de passe requis pour le certificat dans le second élément. pour le certificat dans le deuxième élément.
Aucun
GuzzleHttp\RequestOptions::SSL_KEY
Note
ssl_key
est mis en œuvre par les gestionnaires HTTP. Actuellement, cette fonctionnalité n'est
actuellement que par le gestionnaire cURL, mais peut être pris en charge par d'autres gestionnaires
gestionnaires tiers.
true
pour diffuser une réponse en continu plutôt que de la télécharger entièrement
à l'avance.false
GuzzleHttp\RequestOptions::STREAM
$response = $client->request('GET', '/stream/20', ['stream' => true]);
// Read bytes off of the stream until the end of the stream is reached
$body = $response->getBody();
while (!$body->eof()) {
echo $body->read(1024);
}
Note
La prise en charge des réponses en continu doit être mise en œuvre par le gestionnaire HTTP utilisé par le client. un client. Cette option n'est pas forcément prise en charge par tous les gestionnaires HTTP. l'interface de l'objet de réponse reste la même, qu'elle soit ou non qu'elle soit prise en charge ou non par le gestionnaire.
GuzzleHttp\RequestOptions::SYNCHRONOUS
Décrit le comportement de la vérification du certificat SSL pour une demande.
true
pour activer la vérification des certificats SSL et utiliser le groupe d'autorités de certification par défaut fourni par le système d'exploitationfalse
pour désactiver la vérification des certificats (ce n'est pas sûr !).true
GuzzleHttp\RequestOptions::VERIFY
// Use the system's CA bundle (this is the default setting)
$client->request('GET', '/', ['verify' => true]);
// Use a custom SSL certificate on disk.
$client->request('GET', '/', ['verify' => '/path/to/cert.pem']);
// Disable validation entirely (don't do this!).
$client->request('GET', '/', ['verify' => false]);
Si vous n'avez pas besoin d'un ensemble de certificats spécifique, Mozilla fournit un ensemble d'autorités de certification couramment utilisé, qui peut être téléchargé à partir du site Web de Mozilla. paquet d'AC couramment utilisé qui peut être téléchargé ici (fourni par le responsable de cURL). Une fois que le paquet CA est disponible sur le disque disque, vous pouvez définir le paramètre PHP ini "openssl.cafile" pour qu'il indique le chemin d'accès au le fichier, ce qui vous permet d'omettre l'option de requête "verify". Beaucoup plus de détails sur les Les certificats SSL sont disponibles sur le site site Web cURL.
0
pour attendre indéfiniment (le comportement par défaut).0
GuzzleHttp\RequestOptions::TIMEOUT
// Timeout if a server does not return a response in 3.14 seconds.
$client->request('GET', '/delay/5', ['timeout' => 3.14]);
// PHP Fatal error: Uncaught exception 'GuzzleHttp\Exception\TransferException'
1.1
GuzzleHttp\RequestOptions::VERSION
// Force HTTP/1.0
$request = $client->request('GET', '/get', ['version' => 1.0]);