Guzzle și PSR-7¶

Accesarea antetului¶

Puteți verifica dacă o cerere sau un răspuns are un anumit antet folosind metoda hasHeader().

use GuzzleHttp\Psr7;

$request = new Psr7\Request('GET', '/', ['X-Foo' => 'bar']);

if ($request->hasHeader('X-Foo')) {
    echo 'It is there';
}

Puteți prelua toate valorile antetului ca o matrice de șiruri folosind getHeader().

$request->getHeader('X-Foo'); // ['bar']

// Retrieving a missing header returns an empty array.
$request->getHeader('X-Bar'); // []

Puteți itera peste anteturile unui mesaj utilizând metoda getHeaders().

foreach ($request->getHeaders() as $name => $values) {
    echo $name . ': ' . implode(', ', $values) . "\r\n";
}

Titluri complexe¶

Unele anteturi conțin informații suplimentare privind perechile cheie-valoare. De exemplu, anteturile Link conțin un link și mai multe perechi de valori cheie:

<http://foo.com>; rel="thing"; type="image/jpeg"

Guzzle oferă o funcție convenabilă care poate fi utilizată pentru a analiza aceste tipuri de anteturi:

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);

Va ieși:

array (
  0 =>
  array (
    0 => '<http:/.../front.jpeg>',
    'rel' => 'front',
    'type' => 'image/jpeg',
  ),
)

Rezultatul conține un hash de perechi cheie-valoare. Valorile antetului care nu au nicio cheie (de exemplu, legătura) sunt indexate numeric, în timp ce părțile de antet care formează o cheie pereche cheie-valoare sunt adăugate ca o pereche cheie-valoare.

Metode de solicitare¶

Atunci când creați o cerere, trebuie să furnizați metoda HTTP pe care doriți să o folosiți. să executați. Puteți specifica orice metodă pe care o doriți, inclusiv o metodă personalizată care s-ar putea să nu facă parte din RFC 7231 (cum ar fi "MOVE").

// Create a request using a completely custom HTTP method
$request = new \GuzzleHttp\Psr7\Request('MOVE', 'http://httpbin.org/move');

echo $request->getMethod();
// MOVE

Puteți să creați și să trimiteți o cerere folosind metode pe un client care corespund metodei HTTP pe care doriți să o utilizați.

GET

$client->get('http://httpbin.org/get', [/** options **/879849852657373008982)

POST

$client->post('http://httpbin.org/post', [/** options **/879849852657373008982)

HEAD

$client->head('http://httpbin.org/get', [/** options **/879849852657373008982)

PUT

$client->put('http://httpbin.org/put', [/** options **/879849852657373008982)

DELETE

$client->delete('http://httpbin.org/delete', [/** options **/879849852657373008982)

OPȚIUNI

$client->options('http://httpbin.org/get', [/** options **/])

PATCH

$client->patch('http://httpbin.org/put', [/** options **/879849852657373008982)

De exemplu:

$response = $client->patch('http://httpbin.org/patch', ['body' => 'content']);

Cerere URI¶

URI-ul de cerere este reprezentat de un obiect Psr\Http\Message\UriInterface. Guzzle oferă o implementare a acestei interfețe folosind GuzzleHttp\Psr7\Uri.

Atunci când creați o cerere, puteți furniza URI sub forma unui șir de caractere sau a unei instanțe de Psr\Http\Message\UriInterface.

$response = $client->request('GET', 'http://httpbin.org/get?q=foo');

Schema¶

schema unei cereri specifică protocolul care trebuie utilizat la trimiterea cererii. Atunci când se utilizează Guzzle, schema schema poate fi setată la "http" sau "https".

$request = new Request('GET', 'http://httpbin.org');
echo $request->getUri()->getScheme(); // http
echo $request->getUri(); // http://httpbin.org

Gazda¶

Gazda este accesibilă prin intermediul URI-ului deținut de cerere sau prin accesarea antetului Host.

$request = new Request('GET', 'http://httpbin.org');
echo $request->getUri()->getHost(); // httpbin.org
echo $request->getHeader('Host'); // httpbin.org

Port¶

Nu este necesar niciun port atunci când se utilizează schemele "http" sau "https".

$request = new Request('GET', 'http://httpbin.org:8080');
echo $request->getUri()->getPort(); // 8080
echo $request->getUri(); // http://httpbin.org:8080

Path¶

Calea de acces a unei cereri este accesibilă prin intermediul obiectului URI.

$request = new Request('GET', 'http://httpbin.org/get');
echo $request->getUri()->getPath(); // /get

Conținutul căii de acces va fi filtrat automat pentru a se asigura că numai caracterele permise sunt prezente în calea de acces. Toate caracterele care nu sunt permise în calea de acces va fi codificat în procente în conformitate cu RFC 3986 secțiunea 3.3

Șir de întrebări¶

Șirul de interogare al unei cereri poate fi accesat cu ajutorul getQuery() al obiectului URI deținut de cerere.

$request = new Request('GET', 'http://httpbin.org/?foo=bar');
echo $request->getUri()->getQuery(); // foo=bar

Conținutul șirului de interogare va fi filtrat automat pentru a se asigura că în șirul de interogare sunt prezente numai caracterele permise. Orice caracter care care nu sunt permise în șirul de interogare vor fi codificate în procente în conformitate cu RFC 3986 secțiunea 3.4

Linia de start¶

Linia de început a unui răspuns conține protocolul și versiunea protocolului, codul de stare și fraza de motiv.

$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

Corp¶

După cum s-a descris anterior, puteți obține corpul unui răspuns utilizând metoda getBody().

$body = $response->getBody();
echo $body;
// Cast to a string: { ... }
$body->seek(0);
// Rewind the body
$body->read(1024);
// Read bytes of the body

Crearea fluxurilor¶

Cel mai bun mod de a crea un flux este folosind GuzzleHttp\Psr7\Utils::streamFor metoda . Această metodă acceptă șiruri de caractere, resurse returnate din fopen(), un obiect care implementează __toString(), iteratori, callables și instanțe 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

Puteți crea fluxuri din iteratori. Iteratorul poate produce orice număr de octeți pe iterație. Orice octet în exces returnat de către iterator care nu a fost solicitați de un consumator de flux vor fi blocați în memorie tampon până la o citire ulterioară.

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); // ...

Metadate¶

Fluxurile expun metadatele fluxurilor prin metoda getMetadata(). Această metodă metodă oferă datele pe care le recuperați atunci când apelați metoda PHP stream_get_meta_data(), și, opțional, poate expune și alte date personalizate.

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

Decoratori de fluxuri¶

Adăugarea unei funcționalități personalizate la fluxuri este foarte simplă cu ajutorul decoratorilor de fluxuri. Guzzle oferă mai multe decoratoare încorporate care oferă fluxuri suplimentare funcționalitate suplimentară pentru fluxuri.

• AppendStream
• BufferStream
• CachingStream
• DroppingStream
• FnStream
• InflateStream
• LazyOpenStream
• LimitStream
• MultipartStream
• NoSeekStream
• PumpStream