Handlers and Middleware¶

Handlers¶

Apstrādes funkcija pieņem Psr\Http\Message\RequestInterface un masīvu no pieprasījuma opcijas un atgriež GuzzzzleHttp\Promise\PromiseInterface, kas ir izpildīts ar Psr\Http\Message\ResponseInterface vai noraidīts ar izņēmumu.

Klientam var izveidot pielāgotu apstrādātāju, izmantojot apstrādātājs opciju. klienta konstruktoru. Ir svarīgi saprast, ka vairāki pieprasījumi Guzzle izmantotās opcijas pieprasa, lai īpašas starpprogrammas iesaiņotu izmantoto apstrādātāju. klienta apstrādātājs. Jūs varat nodrošināt, ka apstrādātājs, ko sniedzat klientam, izmanto noklusējuma starpprogrammas, iesaiņojot apstrādātāju GuzzleHttp\HandlerStack::create(callable $handler = null) statisko metodi.

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 metode pievieno noklusējuma apstrādātājus HandlerStack. Kad HandlerStack ir atrisināts, apstrādātāji tiks izpildīti šādā secībā:

1. Pieprasījuma nosūtīšana:

1. http_errors - Pieprasījuma nosūtīšanas laikā nav op. Atbildes statusa kods tiek pārbaudīts atbildes apstrādē, kad tiek atgriezts atbildes solījums līdz kaudzē.
2. allow_redirects - Pieprasījuma nosūtīšanas laikā nav op. Tālāk norādītās pāradresācijas notiek, kad atbildes solījums tiek atgriezts augšup pa kaudzi.
3. cookies - Pieprasījumiem pievieno sīkfailus.
4. prepare_body - HTTP pieprasījuma ķermenis tiks sagatavots (piem., pievienos noklusējuma galvenes, piemēram, Content-Length, Content-Type utt.).
5. <nosūtīt pieprasījumu ar apstrādātāju>

2. Apstrādes atbilde:

1. prepare_body - nav atbildes apstrādes op.
2. sīkfaili - izraksta atbildes sīkfailus uz sīkfailu burku.
3. allow_redirects - Seko novirzēm.
4. http_errors - met izņēmumus, ja atbildes statusa kods >= 400.

Ja nav norādīts $handler arguments, GuzzleHttp\HandlerStack::create() izvēlēsies vispiemērotāko apstrādātāju, pamatojoties uz paplašinājumiem, kas pieejami jūsu sistēmā.

Starpprogrammatūra¶

Starpprogrammatūra paplašina apstrādātāju funkcionalitāti, izsaucot tos, izmantojot atbilžu ģenerēšanas procesā. Starpprogrammatūra tiek īstenota kā augstākas kārtas funkcija, kas ir šādā formā.

use Psr\Http\Message\RequestInterface;

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

Starpprogrammatūras funkcijas atgriež funkciju, kas pieņem nākamo izsaucamo apstrādātāju. Pēc tam šī atdotā funkcija atgriež citu funkciju, kas darbojas kā salikta funkcija. apstrādātājs - tā pieņem pieprasījumu un opcijas un atgriež solījumu, kas ir tiek izpildīts ar atbildi. Jūsu saliktā starpprogrammatūra var mainīt pieprasījumu, pievienot pielāgotas pieprasījuma opcijas un modificēt solījumu, ko atgriež pakārtotā izpildītāja. apstrādātājs.

Šeit ir piemērs, kā pievienot galveni katram pieprasījumam.

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

Kad starpprogrammatūra ir izveidota, to var pievienot klientam, iesaiņojot klienta izmantoto apstrādātāju vai dekorējot apstrādātāju kaudzi.

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

Tagad, nosūtot pieprasījumu, klients izmantos apstrādātāju, kas izveidots, izmantojot jūsu pievienoto starpprogrammatūru, un katram pieprasījumam pievienos galveni.

Šeit ir piemērs, kā izveidot starpprogrammatūru, kas modificē pakārtotā apstrādātāja atbildi. Šajā piemērā atbildei tiek pievienota galvene.

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

Starpprogrammatūras, kas modificē pieprasījumu, izveide ir daudz vienkāršāka, izmantojot GuzzleHttp\Middleware::mapRequest() starpprogrammatūru. Šī starpprogrammatūra pieņem funkciju, kas pieņem pieprasījuma argumentu un atgriež nosūtāmo pieprasījumu.

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

Atbildes modificēšana ir arī daudz vienkāršāka, izmantojot GuzzleHttp\Middleware::mapResponse() starpprogrammu.

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¶

Apkalpotāja kaudze ir starpprogrammatūras kaudze, kas jāpiemēro bāzes apkalpotājam. funkcija. Stāvam var pievienot starpprogrammatūru, lai to pievienotu skursteņa augšdaļai, un noņemt starpprogrammatūru no kaudzes, lai to pievienotu kaudzes apakšai. Kad kaudze ir atrisināta, apstrādātājs tiek ievietots kaudzē. Katra vērtība ir pēc tam no kaudzes tiek izspiesta, iesaiņojot iepriekšējo vērtību, kas izspiesta no kaudzes. kaudzes.

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

Jūs varat piešķirt starpprogrammatūrai nosaukumu, kas ļauj jums pievienot starpprogrammatūru pirms citu nosauktu starpprogrammatūru, aiz citas nosauktas starpprogrammatūras vai dzēst starpprogrammatūru. pēc nosaukuma.

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

Apstrādātāja izveide¶

Kā minēts iepriekš, apstrādātājs ir funkcija, kas pieņem Psr\Http\Message\RequestInterface un pieprasījuma iespēju masīvu un atgriež GuzzzzleHttp\Promise\PromiseInterface, kas tiek izpildīts ar Psr\Http\Message\ResponseInterface vai noraidīts ar izņēmumu.

Apstrādātājs ir atbildīgs par šādu Pieprasījuma opcijas. Šīs pieprasījuma opcijas ir pieprasījuma opciju apakškopa, ko sauc par "pārsūtīšanas opcijas".

• cert
• connect_timeout
• debug
• delay
• decode_content
• sagaidīt
• proxy
• izlietne
• timeout
• ssl_key
• straume
• pārbaudīt