Început rapid¶

Efectuarea unei cereri¶

Puteți trimite cereri cu Guzzle folosind un obiect GuzzleHttp\ClientInterface.

use GuzzleHttp\Client;

$client = new Client([
    // Base URI is used with relative requests
    'base_uri' => 'http://httpbin.org',
    // You can set any number of default request options.
    'timeout'  => 2.0,
]);

$response = $client->get('http://httpbin.org/get');
$response = $client->delete('http://httpbin.org/delete');
$response = $client->head('http://httpbin.org/get');
$response = $client->options('http://httpbin.org/get');
$response = $client->patch('http://httpbin.org/patch');
$response = $client->post('http://httpbin.org/post');
$response = $client->put('http://httpbin.org/put');

use GuzzleHttp\Psr7\Request;

$request = new Request('PUT', 'http://httpbin.org/put');
$response = $client->send($request, ['timeout' => 2]);

$promise = $client->getAsync('http://httpbin.org/get');
$promise = $client->deleteAsync('http://httpbin.org/delete');
$promise = $client->headAsync('http://httpbin.org/get');
$promise = $client->optionsAsync('http://httpbin.org/get');
$promise = $client->patchAsync('http://httpbin.org/patch');
$promise = $client->postAsync('http://httpbin.org/post');
$promise = $client->putAsync('http://httpbin.org/put');

use GuzzleHttp\Psr7\Request;

// Create a PSR-7 request object to send
$headers = ['X-Foo' => 'Bar'];
$body = 'Hello!';
$request = new Request('HEAD', 'http://httpbin.org/head', $headers, $body);
$promise = $client->sendAsync($request);

// Or, if you don't need to pass in a request instance:
$promise = $client->requestAsync('GET', 'http://httpbin.org/get');

use Psr\Http\Message\ResponseInterface;
use GuzzleHttp\Exception\RequestException;

$promise = $client->requestAsync('GET', 'http://httpbin.org/get');
$promise->then(
    function (ResponseInterface $res) {
        echo $res->getStatusCode() . "\n";
    },
    function (RequestException $e) {
        echo $e->getMessage() . "\n";
        echo $e->getRequest()->getMethod();
    }
);

use GuzzleHttp\Client;
use GuzzleHttp\Promise;

$client = new Client(['base_uri' => 'http://httpbin.org/']);

// Initiate each request but do not block
$promises = [
    'image' => $client->getAsync('/image'),
    'png'   => $client->getAsync('/image/png'),
    'jpeg'  => $client->getAsync('/image/jpeg'),
    'webp'  => $client->getAsync('/image/webp')
];

// Wait for the requests to complete; throws a ConnectException
// if any of the requests fail
$responses = Promise\Utils::unwrap($promises);

// You can access each response using the key of the promise
echo $responses['image']->getHeader('Content-Length')[0];
echo $responses['png']->getHeader('Content-Length')[0];

// Wait for the requests to complete, even if some of them fail
$responses = Promise\Utils::settle($promises)->wait();

// Values returned above are wrapped in an array with 2 keys: "state" (either fulfilled or rejected) and "value" (contains the response)
echo $responses['image']['state']; // returns "fulfilled"
echo $responses['image']['value']->getHeader('Content-Length')[0];
echo $responses['png']['value']->getHeader('Content-Length')[0];

use GuzzleHttp\Client;
use GuzzleHttp\Exception\RequestException;
use GuzzleHttp\Pool;
use GuzzleHttp\Psr7\Request;
use GuzzleHttp\Psr7\Response;

$client = new Client();

$requests = function ($total) {
    $uri = 'http://127.0.0.1:8126/guzzle-server/perf';
    for ($i = 0; $i < $total; $i++) {
        yield new Request('GET', $uri);
    }
};

$pool = new Pool($client, $requests(100), [
    'concurrency' => 5,
    'fulfilled' => function (Response $response, $index) {
        // this is delivered each successful response
    },
    'rejected' => function (RequestException $reason, $index) {
        // this is delivered each failed request
    },
]);

// Initiate the transfers and create a promise
$promise = $pool->promise();

// Force the pool of requests to complete.
$promise->wait();

$client = new Client();

$requests = function ($total) use ($client) {
    $uri = 'http://127.0.0.1:8126/guzzle-server/perf';
    for ($i = 0; $i < $total; $i++) {
        yield function() use ($client, $uri) {
            return $client->getAsync($uri);
        };
    }
};

$pool = new Pool($client, $requests(100));

Utilizarea răspunsurilor¶

În exemplele anterioare, am recuperat o variabilă $response sau am fost livrat un răspuns de la o promisiune. Obiectul răspuns implementează un PSR-7 răspuns, Psr\Http\Message\ResponseInterface, și conține multe elemente de informații utile.

Puteți obține codul de stare și fraza de motivare a răspunsului:

$code = $response->getStatusCode(); // 200
$reason = $response->getReasonPhrase(); // OK

Puteți prelua antetele din răspuns:

// Check if a header exists.
if ($response->hasHeader('Content-Length')) {
    echo "It exists";
}

// Get a header from the response.
echo $response->getHeader('Content-Length')[0];

// Get all of the response headers.
foreach ($response->getHeaders() as $name => $values) {
    echo $name . ': ' . implode(', ', $values) . "\r\n";
}

Corpul unui răspuns poate fi recuperat utilizând metoda getBody. Corpul poate fi utilizat ca șir de caractere, transformat într-un șir de caractere sau utilizat ca un obiect de tip stream.

$body = $response->getBody();
// Implicitly cast the body to a string and echo it
echo $body;
// Explicitly cast the body to a string
$stringBody = (string) $body;
// Read 10 bytes from the body
$tenBytes = $body->read(10);
// Read the remaining contents of the body as a string
$remainingBytes = $body->getContents();

Parametrii șirului de interogare¶

Puteți furniza parametrii șirului de interogare cu o cerere în mai multe moduri.

Puteți seta parametrii șirului de interogare în URI-ul cererii:

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

Puteți specifica parametrii șirului de interogare utilizând opțiunea de solicitare query ca o matrice.

$client->request('GET', 'http://httpbin.org', [
    'query' => ['foo' => 'bar']
]);

Furnizarea opțiunii sub formă de matrice va utiliza funcția http_build_query din PHP pentru a formata șirul de interogare.

Și, în cele din urmă, puteți furniza opțiunea de solicitare query sub forma unui șir de caractere.

$client->request('GET', 'http://httpbin.org', ['query' => 'foo=bar']);

Încărcarea datelor¶

Guzzle oferă mai multe metode de încărcare a datelor.

Puteți trimite cereri care conțin un flux de date prin transmiterea unui șir de caractere, resursă returnată de la fopen, sau o instanță a unei Psr\Http\Message\StreamInterface la opțiunea de cerere body.

use GuzzleHttp\Psr7;

// Provide the body as a string.
$r = $client->request('POST', 'http://httpbin.org/post', [
    'body' => 'raw data'
]);

// Provide an fopen resource.
$body = Psr7\Utils::tryFopen('/path/to/file', 'r');
$r = $client->request('POST', 'http://httpbin.org/post', ['body' => $body]);

// Use the Utils::streamFor method to create a PSR-7 stream.
$body = Psr7\Utils::streamFor('hello!');
$r = $client->request('POST', 'http://httpbin.org/post', ['body' => $body]);

O modalitate ușoară de a încărca date JSON și de a seta antetul corespunzător este utilizarea opțiunii de solicitare json:

$r = $client->request('PUT', 'http://httpbin.org/put', [
    'json' => ['foo' => 'bar']
]);

$response = $client->request('POST', 'http://httpbin.org/post', [
    'form_params' => [
        'field_name' => 'abc',
        'other_field' => '123',
        'nested_field' => [
            'nested' => 'hello'
        ]
    ]
]);

use GuzzleHttp\Psr7;

$response = $client->request('POST', 'http://httpbin.org/post', [
    'multipart' => [
        [
            'name'     => 'field_name',
            'contents' => 'abc'
        ],
        [
            'name'     => 'file_name',
            'contents' => Psr7\Utils::tryFopen('/path/to/file', 'r')
        ],
        [
            'name'     => 'other_file',
            'contents' => 'hello',
            'filename' => 'filename.txt',
            'headers'  => [
                'X-Foo' => 'this is an extra header to include'
            ]
        ]
    ]
]);

Cookie-uri¶

Guzzle poate menține o sesiune de cookie-uri pentru dvs. dacă vi se indică acest lucru prin intermediul comenzii cookies opțiunea de cerere. Atunci când trimiteți o cerere, opțiunea cookies trebuie să fie setată la o instanță de GuzzleHttp\Cookie\CookieJarInterface.

// Use a specific cookie jar
$jar = new \GuzzleHttp\Cookie\CookieJar;
$r = $client->request('GET', 'http://httpbin.org/cookies', [
    'cookies' => $jar
]);

Puteți seta cookies la true într-un constructor de client dacă doriți să utilizați un borcan de cookie-uri partajat pentru toate cererile.

// Use a shared client cookie jar
$client = new \GuzzleHttp\Client(['cookies' => true]);
$r = $client->request('GET', 'http://httpbin.org/cookies');

Există diferite implementări pentru GuzzleHttp\Cookie\CookieJarInterface :

• Clasa GuzzleHttp\Cookie\CookieJar stochează cookie-urile sub forma unei matrice.
• Clasa GuzzleHttp\Cookie\FileCookieJar persistă cookie-urile care nu sunt de sesiune. utilizând un fișier în format JSON.
• Clasa GuzzleHttp\Cookie\SessionCookieJar persistă cookie-urile în fișierul sesiunea clientului.

Puteți seta manual cookie-urile într-un borcan de cookie-uri cu ajutorul constructorului numit fromArray(array $cookies, $domain).

$jar = \GuzzleHttp\Cookie\CookieJar::fromArray(
    [
        'some_cookie' => 'foo',
        'other_cookie' => 'barbaz1234'
    ],
    'example.org'
);

Puteți obține un modul cookie după numele său cu metoda getCookieByName($name) care returnează o instanță GuzzleHttp\Cookie\SetCookie.

$cookie = $jar->getCookieByName('some_cookie');

$cookie->getValue(); // 'foo'
$cookie->getDomain(); // 'example.org'
$cookie->getExpires(); // expiration date as a Unix timestamp

Cookie-urile pot fi, de asemenea, preluate într-o matrice datorită metodei toArray(). Interfața GuzzleHttp\Cookie\CookieJarInterface extinde Traversable astfel încât poate fi iterată într-o buclă foreach.

Redirecționări¶

Guzzle va urma automat redirecționările, cu excepția cazului în care îi spuneți să nu o facă. Puteți personaliza comportamentul de redirecționare folosind opțiunea de cerere allow_redirects.

• Setați la true pentru a activa redirecționările normale cu un număr maxim de 5 redirecționări. Aceasta este setarea implicită.
• Setați la false pentru a dezactiva redirecționările.
• Treceți o matrice asociativă care conține cheia "max" pentru a specifica valoarea maximă. numărul maxim de redirecționări și, opțional, furnizează o valoare a cheii "strict" pentru a specifica dacă se utilizează sau nu redirecționări stricte conforme cu RFC (adică redirecționarea POST cu solicitări POST, în loc de a face ceea ce fac majoritatea browserelor, adică redirecționarea cererilor POST cu cereri GET).

$response = $client->request('GET', 'http://github.com');
echo $response->getStatusCode();
// 200

Următorul exemplu arată că redirecționările pot fi dezactivate.

$response = $client->request('GET', 'http://github.com', [
    'allow_redirects' => false
]);
echo $response->getStatusCode();
// 301

Excepții¶

Tree View

Următoarea vizualizare în arbore descrie modul în care excepțiile Guzzle depind unele de altele.

. \RuntimeException
└── TransferException (implements GuzzleException)
    ├── ConnectException (implements NetworkExceptionInterface)
    └── RequestException
        ├── BadResponseException
        │   ├── ServerException
        │   └── ClientException
        └── TooManyRedirectsException

Guzzle aruncă excepții pentru erorile care apar în timpul unui transfer.

• O excepție GuzzleHttp\Exception\ConnectException este aruncată în cazul unei erori de rețea. Această excepție se extinde de la GuzzleHttp\Exception\TransferException.

• O GuzzleHttp\Exception\ClientException este aruncată pentru 400 în cazul în care opțiunea de cerere http_errors este setată la true. Acest lucru excepție se extinde din GuzzleHttp\Exception\BadResponseException și GuzzleHttp\Exception\BadResponseException se extinde de la GuzzleHttp\Exception\RequestException.

  use GuzzleHttp\Psr7;
  use GuzzleHttp\Exception\ClientException;
  
  try {
      $client->request('GET', 'https://github.com/_abc_123_404');
  } catch (ClientException $e) {
      echo Psr7\Message::toString($e->getRequest());
      echo Psr7\Message::toString($e->getResponse());
  }
  

• O GuzzleHttp\Exception\ServerException este aruncată pentru nivelul 500 în cazul în care opțiunea de cerere http_errors este setată la true. Acest lucru excepție se extinde de la GuzzleHttp\Exception\BadResponseException.

• O GuzzleHttp\Exception\TooManyRedirectsException este aruncată atunci când sunt aruncate prea multe adrese de redirecționare. multe redirecționări sunt urmate. Această excepție se extinde de la GuzzleHttp\Exception\RequestException.

Toate excepțiile de mai sus se extind din GuzzleHttp\Exception\TransferException.

Variabilele de mediu¶

Guzzle expune câteva variabile de mediu care pot fi utilizate pentru a personaliza comportamentul bibliotecii.

GUZZLE_CURL_SELECT_TIMEOUT

Controlează durata în secunde pe care o va folosi un procesor curl_multi_* atunci când selectarea pe mânerele curl folosind curl_multi_select(). Unele sisteme au probleme cu implementarea de către PHP a curl_multi_select() unde apelarea acestei funcții duce întotdeauna la așteptarea duratei maxime de timeout-ului.

HTTP_PROXY

Definește proxy-ul care trebuie utilizat atunci când se trimit cereri utilizând protocolul "http"

Notă: deoarece variabila HTTP_PROXY poate conține date arbitrare ale utilizatorului în unele medii (CGI), variabila este utilizată numai în CLI SAPI. Pentru mai multe informații, consultați https://httpoxy.org

HTTPS_PROXY

Definește proxy-ul care trebuie utilizat atunci când se trimit cereri utilizând protocolul "https".

NO_PROXY

Definește adresele URL pentru care nu trebuie utilizat un proxy. Consultați proxy pentru utilizare.