Handlers and Middleware

"Guzzle" klientai, siųsdami HTTP užklausas, naudoja tvarkyklę ir tarpinės programinės įrangos sistemą.

Handlers

Tvarkyklės funkcija priima Psr\Http\Message\RequestInterface ir masyvo užklausos parinkčių ir grąžina GuzzleHttp\Promise\PromiseInterface, kuris yra įvykdomas su Psr\Http\Message\ResponseInterface arba atmetamas su išimtimi.

Klientui galite pateikti pasirinktinį tvarkytuvą naudodami tvarkytuvą parinktį kliento konstruktorių. Svarbu suprasti, kad kelios užklausos Guzzle naudojamų parinkčių reikalauja, kad tam tikros tarpinės programos supakuotų naudojamą tvarkyklę kliento naudojamą tvarkyklę. Galite užtikrinti, kad tvarkyklė, kurią pateikiate klientui, naudotų numatytąsias tarpines programas, apvilkdami tvarkyklę į GuzzleHttp\HandlerStack::create(callable $handler = null) statinį metodą.

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

Metodas create į HandlerStack prideda numatytuosius tvarkytuvus į HandlerStack. Kai HandlerStack bus išspręstas, tvarkyklės bus vykdomos tokia tvarka:

  1. Užklausos siuntimas:
  1. http_errors - Siunčiant užklausą nėra op. Atsakymo būsenos kodas tikrinamas apdorojant atsakymą, kai grąžinamas atsakymo pažadas iki į steką.
  2. allow_redirects - Nėra op siunčiant užklausą. Šie nukreipimai įvyksta, kai atsakymo pažadas grąžinamas į steką.
  3. slapukai - Prideda slapukus prie užklausų.
  4. prepare_body - Bus parengtas HTTP užklausos kūnas (pvz, pridėtos numatytoji antraštė, pavyzdžiui, Content-Length, Content-Type ir t. t.).
  5. <siųsti užklausą su tvarkytoju>
  1. Apdorojimo atsakymas:
  1. prepare_body - nėra atsakymo apdorojimo operacijų.
  2. cookies - ištraukia atsakymo slapukus į slapukų indą.
  3. allow_redirects - Laikosi nukreipimų.
  4. http_errors - išmeta išimtis, kai atsakymo būsenos kodas >= 400.

Kai nepateikiamas $handler argumentas, GuzzleHttp\HandlerStack::create() parinks tinkamiausią tvarkyklę pagal turimus plėtinius jūsų sistemoje.

Svarbu

Klientui pateiktas tvarkytuvas lemia, kaip taikomos užklausos parinktys naudojamos kiekvienai kliento siunčiamai užklausai. Pavyzdžiui, jei nepateikiate su klientu nesusijusi slapukų tarpinė programinė įranga, tuomet nustatant cookies užklausos parinktis neturės jokio poveikio užklausai.

Tarpinė programinė įranga

Tarpinė programinė įranga papildo tvarkyklių funkcijas, iškviesdama jas generuojant atsakymus. Tarpinė programinė įranga įgyvendinama kaip aukštesnės eilės funkcija, kuri yra tokios formos.

use Psr\Http\Message\RequestInterface;

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

Tarpinės įrangos funkcijos grąžina funkciją, kuri priima kitą tvarkyklę, kurią reikia iškviesti. Tada ši grąžinama funkcija grąžina kitą funkciją, kuri veikia kaip sudėtinė ji priima užklausą ir parinktis ir grąžina pažadą, kuris yra įvykdomas su atsakymu. Jūsų sudaryta tarpinė programinė įranga gali keisti užklausą, pridėti pasirinktines užklausos parinktis ir keisti pažadą, kurį grąžina tolesnė grandis. tvarkytoją.

Štai pavyzdys, kaip prie kiekvienos užklausos pridėti antraštę.

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

Sukūrę tarpinę programinę įrangą, galite ją pridėti prie kliento, apgaubdami kliento naudojamą tvarkyklę arba dekoruodami tvarkyklių steką.

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

Dabar, kai siunčiate užklausą, klientas naudos tvarkyklę, sudarytą iš jūsų pridėtos tarpinės programinės įrangos, prie kiekvienos užklausos pridėdamas antraštę.

Pateikiame pavyzdį, kaip sukurti tarpinę programinę įrangą, kuri keičia tolesnio tvarkytojo atsakymą. Šiame pavyzdyje prie atsakymo pridedama antraštė.

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

Sukurti tarpinę programinę įrangą, kuri keičia užklausą, daug paprasčiau naudojant GuzzleHttp\Middleware::mapRequest() tarpinę programinę įrangą. Ši tarpinė programinė įranga priima funkciją, kuri priima užklausos argumentą ir grąžina siunčiamą užklausą.

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

Pakeisti atsakymą taip pat daug paprasčiau naudojant GuzzleHttp\Middleware::mapResponse() tarpinę programinę įrangą.

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

Tvarkytojo stekas - tai tarpinės programinės įrangos stekas, taikomas baziniam tvarkytojui. funkcija. Į steką galite stumti tarpinę programinę įrangą, kad ji būtų pridėta prie steko viršaus, ir išstumti tarpinę programinę įrangą į steką, kad ji būtų pridėta į steko apačią. Kai stekas išsprendžiamas, tvarkyklė nustumiama į steką. Kiekviena reikšmė yra tada iš kamino iššokanti reikšmė iškeliama iš kamino, uždengiant ankstesnę reikšmę, iškeltą iš kamino. iš kamino.

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

Galite suteikti tarpinei programinei įrangai pavadinimą, kad galėtumėte pridėti tarpinę programinę įrangą prieš kitą pavadintą tarpinę programinę įrangą, po kitos pavadintos tarpinės programinės įrangos arba pašalinti tarpinę programinę įrangą pagal pavadinimą.

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

Handlerio kūrimas

Kaip minėta anksčiau, tvarkyklė yra funkcija, priimanti Psr\Http\Message\RequestInterface ir užklausos parinkčių masyvą ir grąžina GuzzleHttp\Promise\PromiseInterface, kuris įvykdomas su Psr\Http\Message\ResponseInterface arba atmetama su išimtimi.

Tvarkytojas yra atsakingas už šių Užklausos parinktys taikymą. Šios užklausos parinktys yra užklausos parinkčių poaibis, vadinamas "perdavimo parinktimis".