Käsittelijät ja väliohjelmistot¶

Käsittelijät¶

Käsittelyfunktio hyväksyy Psr\Http\Message\RequestInterface ja array of pyyntövaihtoehdoista ja palauttaa GuzzleHttp\Promise\PromiseInterface, joka on -olio, joka on täytetään Psr\Http\Message\ResponseInterface -viestillä tai hylätään vastauksella exception.

Voit antaa asiakkaalle mukautetun käsittelijän käyttämällä handler -vaihtoehtoa osoitteessa . asiakkaan konstruktorissa. On tärkeää ymmärtää, että useat pyyntöjen Guzzlen käyttämät vaihtoehdot edellyttävät, että tietyt väliohjelmat kietovat käytetyn käsittelijän sisäänsä asiakkaan käyttämän käsittelijän. Voit varmistaa, että asiakkaalle tarjoamasi käsittelijä käyttää vaihtoehtoa oletusarvoisia välitystoimintoja kietomalla käsittelijän sisäänsä GuzzleHttp\HandlerStack::create(callable $handler = null) staattisen menetelmän.

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

create -menetelmä lisää oletuskäsittelijät HandlerStack -kenttään. Kun HandlerStack ratkaistaan, käsittelijät suoritetaan seuraavassa järjestyksessä:

1. Pyynnön lähettäminen:

1. http_errors - Ei op, kun lähetetään pyyntöä. Vastauksen tilakoodi tarkistetaan vastauksen käsittelyssä, kun vastauslupaus palautetaan ylöspäin. pinoa ylöspäin.
2. allow_redirects - Ei op, kun lähetetään pyyntöä. Seuraavat uudelleenohjaukset tapahtuu, kun vastauslupaus palautetaan pinossa ylöspäin.
3. cookies - Lisää evästeet pyyntöihin.
4. prepare_body - HTTP-pyynnön runko valmistellaan (esim., lisätään oletusotsakkeet, kuten Content-Length, Content-Type jne.).
5. <lähetä pyyntö käsittelijän kanssa>

2. Käsittelyvaste:

1. prepare_body - no op on response processing.
2. cookies - poimii vastausevästeet evästeiden purkkiin.
3. allow_redirects - Seuraa uudelleenohjauksia.
4. http_errors - heittää poikkeuksia, kun vastauksen tilakoodi >= 400.

Kun $handler argumenttia ei anneta, GuzzleHttp\HandlerStack::create() valitsee sopivimman käsittelijän, joka perustuu saatavilla oleviin laajennuksiin osoitteessa järjestelmässäsi.

Middleware¶

Väliohjelmisto lisää käsittelijöiden toiminnallisuutta kutsumalla niitä esiin vastausten tuottamisprosessissa. Middleware on toteutettu korkeamman asteen funktiona, joka on seuraavassa muodossa.

use Psr\Http\Message\RequestInterface;

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

Middleware-funktiot palauttavat funktion, joka hyväksyy seuraavan käsittelijän, jota kutsutaan. Tämä palautettu funktio palauttaa sitten toisen funktion, joka toimii koostettuna käsittelijänä - se hyväksyy pyynnön ja vaihtoehdot ja palauttaa lupauksen, joka on täytetään vastauksella. Koostettu väliohjelmistosi voi muokata pyyntöä, lisätä mukautettuja pyyntövaihtoehtoja ja muuttaa jatkokäyttäjän palauttamaa lupausta. käsittelijän antaman palautteen.

Tässä on esimerkki otsikon lisäämisestä jokaiseen pyyntöön.

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

Kun väliohjelmisto on luotu, voit lisätä sen asiakkaaseen joko paketoimalla asiakkaan käyttämän käsittelijän tai koristelemalla käsittelijäpinon.

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

Nyt kun lähetät pyynnön, asiakas käyttää käsittelijää, joka on koostettu lisäämällä välitysohjelmistosi ja lisäämällä otsikon jokaiseen pyyntöön.

Seuraavassa on esimerkki väliohjelmiston luomisesta, joka muuttaa jatkokäsittelijän vastausta. Tämä esimerkki lisää vastaukseen otsikon.

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

Pyyntöä muuttavan väliohjelmiston luominen on paljon yksinkertaisempaa käyttämällä komentoa GuzzleHttp\Middleware::mapRequest() väliohjelmistoa. Tämä väliohjelmisto hyväksyy funktion, joka ottaa pyynnön argumentin ja palauttaa lähetettävän pyynnön.

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

Vastauksen muokkaaminen on myös paljon yksinkertaisempaa käyttämällä GuzzleHttp\Middleware::mapResponse() väliohjelmistoa.

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äsittelijäpino edustaa pino väliohjelmistoja, joita sovelletaan peruskäsittelijään. toiminto. Voit työntää pinoihin väliohjelmistoja lisätäksesi ne pinon yläosaan, ja poistaa väliohjelmistoja pinosta lisätäksesi ne pinon alareunaan. Kun pino ratkaistaan, käsittelijä työnnetään pinoon. Jokainen arvo on ponnahtaa sen jälkeen pinosta, kietoen edellisen arvon, joka ponnahti pinosta. pino.

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

Voit antaa väliohjelmistolle nimen, jonka avulla voit lisätä väliohjelmiston ennen kuin muita nimettyjä väliohjelmistoja, muiden nimettyjen väliohjelmistojen jälkeen tai poistaa väliohjelmistoja. nimen perusteella.

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äsittelijän luominen¶

Kuten aiemmin todettiin, käsittelijä on funktio, joka hyväksyy a Psr\Http\Message\RequestInterface ja joukon pyyntövaihtoehtoja ja palauttaa pyynnön. GuzzleHttp\Promise\PromiseInterface, joka on täytetty Psr\Http\Message\ResponseInterface tai hylätään poikkeuksen kanssa.

Käsittelijä on vastuussa seuraavien Pyyntöasetukset soveltamisesta. Nämä pyyntöasetukset ovat pyyntöasetusten osajoukko nimeltään "siirto-optiot".

• cert
• connect_timeout
• debug
• delay
• decode_content
• expect
• proxy
• pesuallas
• timeout
• ssl_key
• stream
• verify