Handlery a middleware¶

Klienti Guzzle používajú na odosielanie požiadaviek HTTP systém obsluhy a middleware.

Handlers¶

Funkcia obsluhy prijíma Psr\Http\Message\RequestInterface a pole možností požiadavky a vráti Rozhranie GuzzleHttp\Promise\PromiseInterface, ktoré je splnené pomocou Psr\Http\Message\ResponseInterface alebo odmietnuté pomocou výnimkou.

Klientovi môžete poskytnúť vlastnú obsluhu pomocou handler možnosti konštruktora klienta. Je dôležité pochopiť, že niekoľko požiadaviek možností, ktoré používa Guzzle, vyžaduje, aby špecifické sprostredkovacie programy zabalili použitú obsluhu klientom. Môžete zabezpečiť, aby handler, ktorý poskytujete klientovi, používal predvolené middlewares tým, že handler zabalíte do GuzzleHttp\HandlerStack::create(callable $handler = null) statickú metódu.

use GuzzleHttp\Client;
use GuzzleHttp\HandlerStack;
use GuzzleHttp\Handler\CurlHandler;

$handler = new CurlHandler();
$stack = HandlerStack::create($handler); // Wrap w/ middleware
$client = new Client(['handler' => $stack]);

Metóda create pridá predvolené obslužné prvky do HandlerStack. Keď je HandlerStack vyriešený, obslužné programy sa vykonajú v nasledujúcom poradí:

Odoslanie žiadosti:

http_errors - Pri odosielaní požiadavky nie je op. Stavový kód odpovede sa kontroluje pri spracovaní odpovede pri vrátení prísľubu odpovede až zásobníka.

allow_redirects - Žiadne op pri odosielaní požiadavky. Nasledujúce presmerovania nastane, keď sa sľub odpovede vracia nahor po zásobníku.

cookies - Pridá cookies do požiadaviek.

prepare_body - Pripraví sa telo HTTP požiadavky (napr, pridajú sa predvolené hlavičky ako Content-Length, Content-Type atď.).

<odoslať požiadavku s obsluhou>

Spracovanie odpovede:

prepare_body - žiadny op na spracovanie odpovede.

cookies - extrahuje cookies odpovede do nádoby na cookies.

allow_redirects - Sleduje presmerovania.

http_errors - vyhodí výnimky, keď je kód stavu odpovede >= 400.

Ak nie je uvedený žiadny $handler argument, GuzzleHttp\HandlerStack::create() vyberie najvhodnejší handler na základe rozšírení dostupných na vašom systéme.

Dôležité

Spracovateľ poskytnutý klientovi určuje, ako sa použijú možnosti požiadavky a využijú pre každú požiadavku odoslanú klientom. Ak napríklad nemáte nemáte s klientom spojený middleware cookie, potom nastavenie cookies možnosť požiadavky nebude mať na požiadavku žiadny vplyv.

Middleware¶

Middleware rozširuje funkčnosť obslužných programov tým, že ich vyvoláva v v procese generovania odpovedí. Middleware je implementovaný ako vyšší rád funkcie, ktorá má nasledujúci tvar.

use Psr\Http\Message\RequestInterface;

function my_middleware()
{
    return function (callable $handler) {
        return function (RequestInterface $request, array $options) use ($handler) {
            return $handler($request, $options);
        };
    };
}

Funkcie Middleware vracajú funkciu, ktorá prijíma ďalšiu obslužnú funkciu na vyvolanie. Táto vrátená funkcia potom vráti ďalšiu funkciu, ktorá funguje ako zložená obslužnú funkciu - prijme požiadavku a možnosti a vráti prísľub, ktorý je splnený s odpoveďou. Váš zložený middleware môže modifikovať požiadavku, pridať vlastné možnosti požiadavky a upraviť prísľub vrátený následnou obsluhou. spracovateľ.

Tu je príklad pridania hlavičky ku každej požiadavke.

use Psr\Http\Message\RequestInterface;

function add_header($header, $value)
{
    return function (callable $handler) use ($header, $value) {
        return function (
            RequestInterface $request,
            array $options
        ) use ($handler, $header, $value) {
            $request = $request->withHeader($header, $value);
            return $handler($request, $options);
        };
    };
}

Po vytvorení middlewaru ho môžete pridať ku klientovi buď obalením obslužného programu používaného klientom, alebo ozdobením zásobníka obslužných programov.

use GuzzleHttp\HandlerStack;
use GuzzleHttp\Handler\CurlHandler;
use GuzzleHttp\Client;

$stack = new HandlerStack();
$stack->setHandler(new CurlHandler());
$stack->push(add_header('X-Foo', 'bar'));
$client = new Client(['handler' => $stack]);

Keď teraz odošlete požiadavku, klient použije obslužný program zložený z vášho pridaného middlewaru a ku každej požiadavke pridá hlavičku.

Tu je príklad vytvorenia middlewaru, ktorý upravuje odpoveď následnej obsluhy. Tento príklad pridáva do odpovede hlavičku.

use Psr\Http\Message\RequestInterface;
use Psr\Http\Message\ResponseInterface;
use GuzzleHttp\HandlerStack;
use GuzzleHttp\Handler\CurlHandler;
use GuzzleHttp\Client;

function add_response_header($header, $value)
{
    return function (callable $handler) use ($header, $value) {
        return function (
            RequestInterface $request,
            array $options
        ) use ($handler, $header, $value) {
            $promise = $handler($request, $options);
            return $promise->then(
                function (ResponseInterface $response) use ($header, $value) {
                    return $response->withHeader($header, $value);
                }
            );
        };
    };
}

$stack = new HandlerStack();
$stack->setHandler(new CurlHandler());
$stack->push(add_response_header('X-Foo', 'bar'));
$client = new Client(['handler' => $stack]);

Vytvorenie middlewaru, ktorý modifikuje požiadavku, je oveľa jednoduchšie pomocou GuzzleHttp\Middleware::mapRequest() middleware. Tento middleware prijíma funkciu, ktorá prevezme argument požiadavky a vráti požiadavku na odoslanie.

use Psr\Http\Message\RequestInterface;
use GuzzleHttp\HandlerStack;
use GuzzleHttp\Handler\CurlHandler;
use GuzzleHttp\Client;
use GuzzleHttp\Middleware;

$stack = new HandlerStack();
$stack->setHandler(new CurlHandler());

$stack->push(Middleware::mapRequest(function (RequestInterface $request) {
    return $request->withHeader('X-Foo', 'bar');
}));

$client = new Client(['handler' => $stack]);

Úprava odpovede je tiež oveľa jednoduchšia pomocou GuzzleHttp\Middleware::mapResponse() middleware.

use Psr\Http\Message\ResponseInterface;
use GuzzleHttp\HandlerStack;
use GuzzleHttp\Handler\CurlHandler;
use GuzzleHttp\Client;
use GuzzleHttp\Middleware;

$stack = new HandlerStack();
$stack->setHandler(new CurlHandler());

$stack->push(Middleware::mapResponse(function (ResponseInterface $response) {
    return $response->withHeader('X-Foo', 'bar');
}));

$client = new Client(['handler' => $stack]);

HandlerStack¶

Zásobník obslužných programov predstavuje zásobník obslužných programov, ktorý sa použije na základný obslužný program funkcie. Do zásobníka môžete posunúť middleware, ktorý sa pridá na vrchol zásobníka, a posunúť middleware na zásobník, aby ste ho pridali na spodok zásobníka. Keď je zásobník vyriešený, obslužná funkcia sa presunie na zásobník. Každá hodnota je potom vyskočí zo zásobníka a zabalí predchádzajúcu hodnotu vyskočenú zo zásobníka. zásobníka.

use GuzzleHttp\Client;
use GuzzleHttp\HandlerStack;
use GuzzleHttp\Middleware;
use GuzzleHttp\Utils;
use Psr\Http\Message\RequestInterface;

$stack = new HandlerStack();
$stack->setHandler(Utils::chooseHandler());

$stack->push(Middleware::mapRequest(function (RequestInterface $r) {
    echo 'A';
    return $r;
}));

$stack->push(Middleware::mapRequest(function (RequestInterface $r) {
    echo 'B';
    return $r;
}));

$stack->push(Middleware::mapRequest(function (RequestInterface $r) {
    echo 'C';
    return $r;
}));

$client->request('GET', 'http://httpbin.org/');
// echoes 'ABC';

$stack->unshift(Middleware::mapRequest(function (RequestInterface $r) {
    echo '0';
    return $r;
}));

$client = new Client(['handler' => $stack]);
$client->request('GET', 'http://httpbin.org/');
// echoes '0ABC';

middleware môžete pomenovať, čo vám umožní pridať middleware pred iný pomenovaný middleware, za iný pomenovaný middleware alebo odstrániť middleware podľa názvu.

use Psr\Http\Message\RequestInterface;
use GuzzleHttp\Middleware;

// Add a middleware with a name
$stack->push(Middleware::mapRequest(function (RequestInterface $r) {
    return $r->withHeader('X-Foo', 'Bar');
}, 'add_foo'));

// Add a middleware before a named middleware (unshift before).
$stack->before('add_foo', Middleware::mapRequest(function (RequestInterface $r) {
    return $r->withHeader('X-Baz', 'Qux');
}, 'add_baz'));

// Add a middleware after a named middleware (pushed after).
$stack->after('add_baz', Middleware::mapRequest(function (RequestInterface $r) {
    return $r->withHeader('X-Lorem', 'Ipsum');
}));

// Remove a middleware by name
$stack->remove('add_foo');

Vytvorenie obslužného programu¶

Ako už bolo uvedené, obslužná funkcia je funkcia, ktorá prijíma Psr\Http\Message\RequestInterface a pole možností požiadavky a vráti Rozhranie GuzzleHttp\Promise\PromiseInterface, ktoré je splnené pomocou Psr\Http\Message\ResponseInterface alebo odmietnutý s výnimkou.

Spracovateľ je zodpovedný za použitie nasledujúcich možností požiadavky. Tieto možnosti požiadavky sú podmnožinou možností požiadavky tzv. "možnosti prenosu".

Obsah

Handlery a middleware¶

Handlers¶

Middleware¶

HandlerStack¶

Vytvorenie obslužného programu¶