Guzzle utilise PSR-7 comme interface de message HTTP. Cela permet à Guzzle de fonctionner avec toute autre bibliothèque qui utilise les interfaces de messages PSR-7.
Guzzle est un client HTTP qui envoie des demandes HTTP à un serveur et reçoit des réponses HTTP. Les demandes et les réponses sont appelées des messages.
Guzzle s'appuie sur le paquet guzzlehttp/psr7 Composer pour son implémentation de messages PSR-7.
Vous pouvez créer une requête en utilisant la classe GuzzleHttp\Psr7\Request :
use GuzzleHttp\Psr7\Request;
$request = new Request('GET', 'http://httpbin.org/get');
// You can provide other optional constructor arguments.
$headers = ['X-Foo' => 'Bar'];
$body = 'hello!';
$request = new Request('PUT', 'http://httpbin.org/put', $headers, $body);
Vous pouvez créer une réponse en utilisant la classe GuzzleHttp\Psr7\Response :
use GuzzleHttp\Psr7\Response;
// The constructor requires no arguments.
$response = new Response();
echo $response->getStatusCode(); // 200
echo $response->getProtocolVersion(); // 1.1
// You can supply any number of optional arguments.
$status = 200;
$headers = ['X-Foo' => 'Bar'];
$body = 'hello!';
$protocol = '1.1';
$response = new Response($status, $headers, $body, $protocol);
Les messages de demande et de réponse contiennent tous deux des en-têtes HTTP.
Vous pouvez vérifier si une demande ou une réponse possède un en-tête spécifique en utilisant la méthode hasHeader().
use GuzzleHttp\Psr7;
$request = new Psr7\Request('GET', '/', ['X-Foo' => 'bar']);
if ($request->hasHeader('X-Foo')) {
echo 'It is there';
}
Vous pouvez récupérer toutes les valeurs d'en-tête sous forme de tableau de chaînes en utilisant getHeader().
$request->getHeader('X-Foo'); // ['bar']
// Retrieving a missing header returns an empty array.
$request->getHeader('X-Bar'); // []
Vous pouvez itérer sur les en-têtes d'un message en utilisant la méthode getHeaders().
foreach ($request->getHeaders() as $name => $values) {
echo $name . ': ' . implode(', ', $values) . "\r\n";
}
Certains en-têtes contiennent des informations supplémentaires sur les paires clé-valeur. Par exemple, les en-têtes Link contiennent un lien et plusieurs paires clé-valeur :
<http://foo.com>; rel="thing"; type="image/jpeg"
Guzzle fournit une fonction de commodité qui peut être utilisée pour analyser ces types d'en-têtes :
use GuzzleHttp\Psr7;
$request = new Psr7\Request('GET', '/', [
'Link' => '<http:/.../front.jpeg>; rel="front"; type="image/jpeg"'
]);
$parsed = Psr7\Header::parse($request->getHeader('Link'));
var_export($parsed);
La sortie est prévue :
array (
0 =>
array (
0 => '<http:/.../front.jpeg>',
'rel' => 'front',
'type' => 'image/jpeg',
),
)
Le résultat contient un hachage de paires clé-valeur. Les valeurs d'en-tête qui n'ont pas de clé (c'est-à-dire le lien) sont indexées numériquement, tandis que les parties d'en-tête qui forment une paire clé-valeur sont ajoutées comme une paire clé-valeur. sont ajoutées comme une paire clé-valeur.
Les messages de demande et de réponse peuvent tous deux contenir un corps.
Vous pouvez récupérer le corps d'un message à l'aide de la méthode getBody() :
$response = GuzzleHttp\get('http://httpbin.org/get');
echo $response->getBody();
// JSON string: { ... }
Le corps utilisé dans les objets de demande et de réponse est une
Psr\Http\Message\StreamInterface. Ce flux est utilisé à la fois pour
l'envoi et le téléchargement de données. Guzzle stocke, par défaut, le corps d'un message
message dans un flux qui utilise les flux temporaires de PHP. Lorsque la taille du corps du message
dépasse 2 Mo, le flux bascule automatiquement vers un stockage des données sur le disque
plutôt qu'en mémoire (ce qui protège votre application de l'épuisement de la mémoire).
La façon la plus simple de créer un corps pour un message est d'utiliser la méthode streamFor
de la classe GuzzleHttp\Psr7\Utils --
Utils::streamFor. Cette méthode accepte les chaînes de caractères, les ressources
callables, itérateurs, autres streamables, et renvoie une instance de
Psr\Http\Message\StreamInterface.
Le corps d'une demande ou d'une réponse peut être converti en une chaîne de caractères ou vous pouvez lire et écrire des octets à partir du flux selon vos besoins.
use GuzzleHttp\Stream\Stream;
$response = $client->request('GET', 'http://httpbin.org/get');
echo $response->getBody()->read(4);
echo $response->getBody()->read(4);
echo $response->getBody()->read(1024);
var_export($response->eof());
Les requêtes sont envoyées par un client à un serveur. Les requêtes comprennent la méthode à méthode à appliquer à une ressource, l'identifiant de la ressource et la version du à utiliser.
Lorsque vous créez une requête, vous devez fournir la méthode HTTP que vous souhaitez à exécuter. Vous pouvez spécifier la méthode de votre choix, y compris une méthode personnalisée qui pourrait ne pas faire partie de la RFC 7231 (comme "MOVE").
// Create a request using a completely custom HTTP method
$request = new \GuzzleHttp\Psr7\Request('MOVE', 'http://httpbin.org/move');
echo $request->getMethod();
// MOVE
Vous pouvez créer et envoyer une demande en utilisant des méthodes sur un client qui correspondent à la méthode HTTP que vous souhaitez utiliser.
$client->get('http://httpbin.org/get', [/** options **/])$client->post('http://httpbin.org/post', [/** options **/])$client->head('http://httpbin.org/get', [/** options **/])$client->put('http://httpbin.org/put', [/** options **/])$client->delete('http://httpbin.org/delete', [/** options **/])$client->options('http://httpbin.org/get', [/** options **/])$client->patch('http://httpbin.org/put', [/** options **/])Par exemple :
$response = $client->patch('http://httpbin.org/patch', ['body' => 'content']);
L'URI de la requête est représenté par un objet Psr\Http\Message\UriInterface.
Guzzle fournit une implémentation de cette interface à l'aide de l'objet
Classe GuzzleHttp\Psr7\Uri.
Lors de la création d'une requête, vous pouvez fournir l'URI sous la forme d'une chaîne ou d'une instance de Psr\Http\Message\UriInterface.
$response = $client->request('GET', 'http://httpbin.org/get?q=foo');
Le schéma d'une demande spécifie le protocole à utiliser pour envoyer la demande. Lorsque vous utilisez Guzzle, le schéma peut être défini sur "http" ou "https".
$request = new Request('GET', 'http://httpbin.org');
echo $request->getUri()->getScheme(); // http
echo $request->getUri(); // http://httpbin.org
L'hôte est accessible en utilisant l'URI appartenant à la requête ou en accédant à l'en-tête Host.
$request = new Request('GET', 'http://httpbin.org');
echo $request->getUri()->getHost(); // httpbin.org
echo $request->getHeader('Host'); // httpbin.org
Aucun port n'est nécessaire lorsque vous utilisez les schémas "http" ou "https".
$request = new Request('GET', 'http://httpbin.org:8080');
echo $request->getUri()->getPort(); // 8080
echo $request->getUri(); // http://httpbin.org:8080
Le chemin d'une requête est accessible via l'objet URI.
$request = new Request('GET', 'http://httpbin.org/get');
echo $request->getUri()->getPath(); // /get
Le contenu du chemin d'accès sera automatiquement filtré afin de s'assurer que seuls les caractères autorisés sont présents dans le chemin. Tous les caractères qui ne sont pas autorisés dans le chemin d'accès sera codé en pourcentage conformément aux règles suivantes RFC 3986 section 3.3
La chaîne de requête d'une demande est accessible en utilisant la fonction getQuery() de l'objet URI appartenant à la demande.
$request = new Request('GET', 'http://httpbin.org/?foo=bar');
echo $request->getUri()->getQuery(); // foo=bar
Le contenu de la chaîne d'interrogation sera automatiquement filtré pour garantir que seuls les caractères autorisés sont présents dans la chaîne de requête. Tous les caractères qui qui n'est pas autorisé dans la chaîne de requête sera codé en pourcentage conformément à RFC 3986 section 3.4
Les réponses sont les messages HTTP qu'un client reçoit d'un serveur après avoir envoyé un message de demande HTTP.
La ligne de début d'une réponse contient le protocole et la version du protocole, le code d'état et la phrase de raison.
$client = new \GuzzleHttp\Client();
$response = $client->request('GET', 'http://httpbin.org/get');
echo $response->getStatusCode(); // 200
echo $response->getReasonPhrase(); // OK
echo $response->getProtocolVersion(); // 1.1
Comme décrit précédemment, vous pouvez obtenir le corps d'une réponse à l'aide de la méthode getBody().
$body = $response->getBody();
echo $body;
// Cast to a string: { ... }
$body->seek(0);
// Rewind the body
$body->read(1024);
// Read bytes of the body
Guzzle utilise les objets de flux PSR-7 pour représenter les corps des messages de demande et de réponse. de messages de demande et de réponse. Ces objets de flux vous permettent de travailler avec différents types de données en utilisant en utilisant une interface commune.
Les messages HTTP se composent d'une ligne de départ, d'en-têtes et d'un corps. Le corps d'un message HTTP peut être très petit ou extrêmement grand. Si l'on tente de représenter le corps d'un message sous la forme d'une chaîne de caractères peut facilement consommer plus de mémoire que prévu, car le corps doit être entièrement stocké en mémoire. le corps doit être stocké entièrement en mémoire. Tenter de stocker le corps d'une demande ou d'une réponse en mémoire empêcherait l'utilisation de cette mise en œuvre de de travailler avec des corps de messages volumineux. L'interface StreamInterface est utilisée pour afin de masquer les détails de mise en œuvre de l'endroit où un flux de données est lu à partir de ou écrit.
Le PSR-7 Psr\Http\Message\StreamInterface expose plusieurs méthodes qui permettent de lire, d'écrire et de traverser efficacement les flux.
Les flux exposent leurs capacités à l'aide de trois méthodes : isReadable(),
isWritable(), et isSeekable(). Ces méthodes peuvent être utilisées par les collaborateurs
pour déterminer si un flux est capable de répondre à leurs exigences.
Chaque instance de flux a différentes capacités : elles peuvent être en lecture seule, en écriture seule, en lecture-écriture, permettre un accès aléatoire arbitraire (recherche en avant ou en n'importe quel endroit), ou n'autoriser qu'un accès séquentiel (par exemple dans le cas d'une cas d'une socket ou d'un pipe).
Guzzle utilise le paquet guzzlehttp/psr7 pour fournir le support des flux. Plus d'informations sur
informations sur l'utilisation des flux, la création de flux, la conversion de flux en ressource de flux PHP
et les décorateurs de flux peuvent être trouvés dans le document
Documentation Guzzle PSR-7.
La meilleure façon de créer un flux est d'utiliser la GuzzleHttp\Psr7\Utils::streamFor
méthode. Cette méthode accepte les chaînes de caractères, les ressources retournées par fopen(),
un objet qui implémente __toString(), des itérateurs, des appelables et des instances de __toString().
de Psr\Http\Message\StreamInterface.
use GuzzleHttp\Psr7;
$stream = Psr7\Utils::streamFor('string data');
echo $stream;
// string data
echo $stream->read(3);
// str
echo $stream->getContents();
// ing data
var_export($stream->eof());
// true
var_export($stream->tell());
// 11
Vous pouvez créer des flux à partir d'itérateurs. L'itérateur peut produire un nombre quelconque de d'octets par itération. Tous les octets excédentaires retournés par l'itérateur qui n'ont pas été demandé par un consommateur de flux sera mis en mémoire tampon jusqu'à une lecture ultérieure.
use GuzzleHttp\Psr7;
$generator = function ($bytes) {
for ($i = 0; $i < $bytes; $i++) {
yield '.';
}
};
$iter = $generator(1024);
$stream = Psr7\Utils::streamFor($iter);
echo $stream->read(3); // ...
Les flux exposent les métadonnées des flux par le biais de la méthode getMetadata(). Cette méthode
méthode fournit les données que vous récupéreriez en appelant la méthode PHP
fonction stream_get_meta_data(),
et peut éventuellement exposer d'autres données personnalisées.
use GuzzleHttp\Psr7;
$resource = Psr7\Utils::tryFopen('/path/to/file', 'r');
$stream = Psr7\Utils::streamFor($resource);
echo $stream->getMetadata('uri');
// /path/to/file
var_export($stream->isReadable());
// true
var_export($stream->isWritable());
// false
var_export($stream->isSeekable());
// true
L'ajout de fonctionnalités personnalisées aux flux est très simple grâce aux décorateurs de flux. Guzzle fournit plusieurs décorateurs intégrés qui apportent des fonctionnalités supplémentaires aux flux. supplémentaires.