"Guzzle" klientai, siųsdami HTTP užklausas, naudoja tvarkyklę ir tarpinės programinės įrangos sistemą.
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:
http_errors
- Siunčiant užklausą nėra op. Atsakymo būsenos kodas tikrinamas apdorojant atsakymą, kai grąžinamas atsakymo pažadas iki į steką.allow_redirects
- Nėra op siunčiant užklausą. Šie nukreipimai įvyksta, kai atsakymo pažadas grąžinamas į steką.slapukai
- Prideda slapukus prie užklausų.prepare_body
- Bus parengtas HTTP užklausos kūnas (pvz, pridėtos numatytoji antraštė, pavyzdžiui, Content-Length, Content-Type ir t. t.).- <siųsti užklausą su tvarkytoju>
prepare_body
- nėra atsakymo apdorojimo operacijų.cookies
- ištraukia atsakymo slapukus į slapukų indą.allow_redirects
- Laikosi nukreipimų.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 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]);
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');
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".