Käsitlejad ja vahendusprogrammid¶

Guzzle'i kliendid kasutavad HTTP-päringute saatmiseks käitleja ja vahendussüsteemi.

Käsitlejad¶

Käsitlusfunktsioon võtab vastu Psr\Http\Message\RequestInterface ja massiiviga taotlusvalikutest ja tagastab GuzzleHttp\Promise\PromiseInterface, mis on täidetud Psr\Http\Message\ResponseInterface või tagasi lükatud Psr\Http\Message\ResponseInterface või tagasi lükatud erandiga.

Saate kliendile anda kohandatud käsitseja, kasutades käsitseja valikuga kliendi konstruktoriga. Oluline on mõista, et mitmed päringu valikud, mida Guzzle kasutab, nõuavad, et konkreetsed vaheprogrammid pakendavad kasutatud käsitsitajat kliendi poolt. Saate tagada, et kliendile pakutav käsitseja kasutab vaikimisi kesktarkvara, mähkides käsitseja sisse GuzzleHttp\HandlerStack::create(callable $handler = null) staatiline meetod.

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

Meetod create lisab HandlerStack'ile vaikimisi käsitsejad. Kui HandlerStack on lahendatud, käivitatakse käsitsejad järgmises järjekorras:

Taotluse saatmine:

http_errors - Taotluse saatmisel puudub op. Vastuse staatuse kood kontrollitakse vastuse töötlemisel, kui tagastatakse vastuse lubadus üles virna ülespoole.

allow_redirects - No op taotluse saatmisel. Järgmised ümbersuunamised toimub siis, kui vastuse lubadus tagastatakse virna ülespoole.

cookies - Lisab päringutele küpsised.

prepare_body - HTTP päringu keha valmistatakse ette (nt, lisatakse vaikimisi päised nagu Content-Length, Content-Type jne).

<Saada taotlus koos käitlejaga>

Töötlemisvastus:

prepare_body - no op on response processing.

cookies - ekstraheerib vastuseküpsised küpsiste purki.

allow_redirects - Järgib ümbersuunamisi.

http_errors - viskab erandeid, kui vastuse staatuse kood >= 400.

Kui $handler argumenti ei esitata, GuzzleHttp\HandlerStack::create() valib kõige sobivama käitleja, mis põhineb laiendustel, mis on saadaval aadressil teie süsteemis.

Oluline

Kliendile esitatud käitleja määrab, kuidas taotluse valikuid rakendatakse. ja kasutatakse iga kliendi saadetud taotluse puhul. Näiteks kui te ei ole ole kliendiga seotud küpsiste vahendajaid, siis on küpsiste vahendaja määramine cookies taotluse valik ei mõjuta taotlust.

Middleware¶

Vahendustarkvara suurendab käitlejate funktsionaalsust, kutsudes neid esile vastuste genereerimise käigus. Vahendustarkvara on rakendatud kõrgema astme funktsioonina, mis võtab järgmise kuju.

use Psr\Http\Message\RequestInterface;

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

Vahepealsed funktsioonid tagastavad funktsiooni, mis võtab vastu järgmise käsitseri, mida kutsuda. See tagastatav funktsioon tagastab seejärel teise funktsiooni, mis toimib komponeeritud käitleja - see võtab vastu taotluse ja valikud ning tagastab lubaduse, mis on täidetakse vastusega. Teie komponeeritud vahendaja võib muuta taotlust, lisada kohandatud taotluse valikuid ja muuta järgnevalt tagastatud lubadust. töötleja.

Siin on näide päise lisamisest igale taotlusele.

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

Kui vahendusprogramm on loodud, saate selle kliendile lisada, kas pakendades kliendi poolt kasutatava käsitseja või kaunistades käsitseja virna.

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

Nüüd, kui saadate taotluse, kasutab klient teie lisatud vahendustarkvara abil koostatud käitlejat, lisades igale taotlusele päise.

Siin on näide vahendustarkvara loomisest, mis muudab allavoolu käitleja vastust. See näide lisab vastusele päise.

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

Taotlust muutva vahendusprogrammi loomine on palju lihtsam, kui kasutada funktsiooni GuzzleHttp\Middleware::mapRequest() middleware. See vahendusprogramm võtab vastu funktsiooni, mis võtab taotluse argumendi ja tagastab saadetava taotluse.

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

Vastuse muutmine on ka palju lihtsam, kasutades GuzzleHttp\Middleware::mapResponse() vahevara.

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¶

Käsitleja virn kujutab endast baaskäsitleja suhtes kohaldatava vaheprogrammi virna funktsiooni. Saate virnasse lükata vaheprogramme, et lisada need virna tippu, ja vahevara virnale tagasi lükata, et lisada virna põhja. Kui virna lahendatakse, lükatakse käitleja virna peale. Iga väärtus on seejärel virnast välja, mähendades eelmist väärtust, mis on virnast välja võetud virna.

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

Saate anda kesktarkvarale nime, mis võimaldab teil lisada kesktarkvara enne teiste nimeliste kesktarkvarade ees, teiste nimeliste kesktarkvarade järel või eemaldada kesktarkvara. nime järgi.

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

Käsitleja loomine¶

Nagu varem öeldud, on käsitsusfunktsioon, mis võtab vastu Psr\Http\Message\RequestInterface ja päringuvalikute massiivi ning tagastab selle. GuzzleHttp\Promise\PromiseInterface, mis on täidetud koos Psr\Http\Message\ResponseInterface või lükatakse tagasi erandiga.

Käsitleja vastutab järgmiste Request Options rakenduste eest. Need taotluse valikud on taotluse valikute alamhulk, mida nimetatakse "ülekandevõimalused".

Sisukord

Käsitlejad ja vahendusprogrammid¶

Käsitlejad¶

Middleware¶

HandlerStack¶

Käsitleja loomine¶