Quickstart¶

Złożenie wnioskuś

Zapytania do Guzzle'a można wysyłać za pomocą obiektu GuzzleHttpClientInterface.

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

Korzystanie z odpowiedzi¶

W poprzednich przykładach, pobieraliśmy zmienną $response lub byliśmy dostarczono nam odpowiedź z obietnicy. Obiekt response implementuje PSR-7 odpowiedź, Psr\Message\ResponseInterface, i zawiera wiele pomocnych informacji.

Możesz uzyskać kod statusu i uzasadnienie odpowiedzi:

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

Możesz pobrać nagłówki z odpowiedzi:

// 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";
}

Ciało odpowiedzi może zostać pobrane za pomocą metody getBody. Ciało może być użyte jako ciąg znaków, rzutowane na ciąg znaków lub użyte jako obiekt podobny do strumienia.

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

Query String Parameters¶

Możesz dostarczyć parametry łańcucha zapytania wraz z żądaniem na kilka sposobów.

Możesz ustawić parametry łańcucha zapytania w URI żądania:

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

Parametry łańcucha zapytania można określić za pomocą opcji żądania query jako tablicę.

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

Podanie opcji w postaci tablicy spowoduje użycie funkcji PHP http_build_query do sformatowania łańcucha zapytania.

I wreszcie, możesz podać opcję żądania query jako ciąg znaków.

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

Przesyłanie danych¦

Guzzle udostępnia kilka metod przesyłania danych.

Możesz wysyłać żądania, które zawierają strumień danych poprzez przekazanie łańcucha znaków, zasób zwrócony z fopen, lub instancję Psr Psr\Message\StreamInterface do opcji body żądania.

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

Łatwym sposobem na przesłanie danych JSON i ustawienie odpowiedniego nagłówka jest użycie opcji żądania 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'
            ]
        ]
    ]
]);

Ciasteczkaś

Guzzle może utrzymywać dla Ciebie sesję cookie, jeśli zostaniesz o tym poinformowany za pomocą opcji cookies opcji żądania. Podczas wysyłania żądania, opcja cookies musi być ustawiona na instancję GuzzleHttpCookieJarInterface.

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

Możesz ustawić cookies na true w konstruktorze klienta, jeśli chcesz użyć wspólnego słoika z ciasteczkami dla wszystkich żądań.

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

Istnieją różne implementacje dla GuzzleHttp\CookieJarInterface :

• Klasa GuzzleHttp\Cookie\CookieJar przechowuje ciasteczka jako tablicę.
• Klasa GuzzleHttpFileCookieJar przechowuje pliki cookie nie będące plikami sesyjnymi za pomocą pliku w formacie JSON.
• Klasa GuzzleHttp\Cookie\SessionCookieJar przechowuje ciasteczka w sesji klienta. sesji klienta.

Możesz ręcznie ustawić ciasteczka w słoiku z ciasteczkami za pomocą nazwanego konstruktora fromArray(array $cookies, $domain).

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

Możesz uzyskać plik cookie po jego nazwie za pomocą metody getCookieByName($name), która zwraca instancję GuzzleHttp\Cookie\SetCookie.

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

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

Ciasteczka mogą być również pobierane do tablicy dzięki metodzie toArray(). Interfejs GuzzleHttpCookieJarInterface rozszerza. Traversable, więc można go iterować w pętli foreach.

Przekierowania¶

Guzzle będzie automatycznie podążał za przekierowaniami, chyba że zabronisz mu tego. Możesz dostosować zachowanie przekierowań, używając opcji żądania allow_redirects.

• Ustawione na true, aby włączyć normalne przekierowania z maksymalną liczbą 5 przekierowań. Jest to ustawienie domyślne.
• Ustaw na false aby wyłączyć przekierowania.
• Podaj tablicę asocjacyjną zawierającą klucz 'max', aby określić maksymalną liczbę przekierowań oraz opcjonalnie wartość klucza 'strict', aby określić czy używać ścisłych przekierowań zgodnych z RFC (czyli przekierowywać żądania POST POST z żądaniami POST vs. robienie tego, co robi większość przeglądarek, czyli przekierowywanie żądań POST z żądaniami GET).

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

Poniższy przykład pokazuje, że przekierowania mogą być wyłączone.

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

Wyjątki¶

Widok drzewa

Poniższy widok drzewa opisuje, w jaki sposób wyjątki Guzzle'a zależą od siebie nawzajem.

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

Guzzle rzuca wyjątkami dla błędów, które wystąpią podczas transferu.

• Wyjątek GuzzleHttpConnectException jest rzucany w w przypadku wystąpienia błędu sieciowego. Wyjątek ten wywodzi się z code class="docutils literal">GuzzleHttpException.

• Wyjątek GuzzleHttp jest rzucany dla błędów poziomu 400 jeśli opcja żądania http_errors jest ustawiona na true. Ten wywodzi się z wyjątków GuzzleHttp\Exception\BadResponseException oraz GuzzleHttp\Exception. GuzzleHttp\Exception\BadResponseException extends from GuzzleHttp\Exception\RequestException.

  użyj GuzzleHttp

• Wyjątek GuzzleHttp jest rzucany dla błędów poziomu 500 błędów, jeśli opcja żądania http_errors jest ustawiona na true. Ten wywodzi się z wyjątku GuzzleHttp\Exception\BadResponseException.

• A GuzzleHttpExceptionTooManyRedirectsException jest rzucany, gdy zbyt zbyt wiele przekierowań. Wyjątek ten rozszerza się z GuzzleHttpException.

Wszystkie powyższe wyjątki pochodzą z GuzzleHttpException.

Zmienne środowiskowe¦

Guzzle udostępnia kilka zmiennych środowiskowych, które mogą być użyte do dostosowania zachowania biblioteki.

GUZZLE_CURL_SELECT_TIMEOUT

Określa czas trwania w sekundach, którego będzie używał handler curl_multi_* podczas wyboru na uchwytach curl za pomocą curl_multi_select(). Niektóre systemy mają problemy z implementacją w PHP curl_multi_select(), gdzie wywołanie tej funkcji zawsze powoduje oczekiwanie przez maksymalny czas trwania timeout.

HTTP_PROXY

Określa proxy do użycia podczas wysyłania żądań przy użyciu protokołu "http".

Uwaga: ponieważ zmienna HTTP_PROXY może zawierać arbitralne dane wejściowe użytkownika w niektórych środowiskach (CGI), zmienna ta jest używana tylko w CLI SAPI. Zobacz https://httpoxy.org po więcej informacji.

HTTPS_PROXY

Określa proxy, które ma być używane podczas wysyłania żądań za pomocą protokołu "https".

NO_PROXY

Definiuje adresy URL, dla których nie powinno być używane proxy. Zobacz proxy jak używać.