Handlers og middleware¶

Handlers¶

En handlingsfunktion accepterer en Psr\Http\Message\RequestInterface og et array af anmodningsindstillinger og returnerer en GuzzleHttp\Promise\\PromiseInterface, der er opfyldt med en Psr\Http\Message\ResponseInterface eller afvist med en Psr\Http\Message\ResponseInterface eller afvist med en undtagelse.

Du kan give en klient en brugerdefineret handler ved hjælp af handler indstillingen handler i en klientkonstruktør. Det er vigtigt at forstå, at flere anmodninger indstillinger, der bruges af Guzzle, kræver, at specifikke middlewares indpakker den anvendte handler af klienten. Du kan sikre, at den handler, du giver en klient, bruger standard middlewares ved at indpakke handleren i GuzzleHttp\HandlerStack::create(callable $handler = null) statisk metode.

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

Metoden create tilføjer standardhåndterer til HandlerStack. Når HandlerStack er opløst, vil handlerne blive udført i følgende rækkefølge:

1. Afsendelse af anmodning:

1. http_errors - No op når der sendes en anmodning. Svarstatuskoden kontrolleres i svarbehandlingen, når der returneres et svarløfte op stakken.
2. allow_redirects - No op når der sendes en anmodning. Følgende videresendelser sker, når et svarløfte returneres op ad stakken.
3. cookies - Tilføjer cookies til anmodninger.
4. prepare_body - Kroppen af en HTTP-anmodning vil blive forberedt (f.eks, tilføje standardoverskrifter som Content-Length, Content-Type osv.).
5. <send anmodning med handler>

2. Behandlingssvar:

1. prepare_body - ingen funktion på svarbehandling.
2. cookies - udtrækker svarcookies i cookieboksen.
3. allow_redirects - Følger omdirigeringer.
4. http_errors - kaster undtagelser, når svarstatuskoden >= 400.

Når der ikke er angivet noget $handler argument, vil GuzzleHttp\HandlerStack::create() vil vælge den mest passende handler baseret på de udvidelser, der er tilgængelige på dit system.

Middleware¶

Middleware udvider funktionaliteten af handlers ved at påkalde dem i den processen med at generere svar. Middleware er implementeret som en højere orden funktion, der har følgende 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);
        };
    };
}

Middleware-funktioner returnerer en funktion, der accepterer den næste handlingsfunktion, der skal påberåbes. Denne returnerede funktion returnerer derefter en anden funktion, der fungerer som en sammensat handler - den accepterer en anmodning og indstillinger og returnerer et løfte, der er opfyldes med et svar. Din sammensatte middleware kan ændre anmodningen, tilføje brugerdefinerede anmodningsindstillinger og ændre det løfte, der returneres af den efterfølgende handleren.

Her er et eksempel på tilføjelse af en header til hver anmodning.

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

Når der er oprettet en middleware, kan du tilføje den til en klient ved enten at omvikle den handler, der bruges af klienten, eller ved at dekorere en handler stack.

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år du nu sender en anmodning, vil klienten bruge en handler, der er sammensat med din tilføjede middleware, og som tilføjer en header til hver anmodning.

Her er et eksempel på oprettelse af en middleware, der ændrer svaret fra downstream-handleren. I dette eksempel tilføjes en header til svaret.

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

Det er meget nemmere at oprette en middleware, der ændrer en anmodning, ved hjælp af GuzzleHttp\Middleware::mapRequest() middleware. Denne middleware accepterer en funktion, der tager request-argumentet og returnerer den request, der skal sendes.

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

Det er også meget nemmere at ændre et svar ved hjælp af GuzzleHttp\Middleware::mapResponse() middleware.

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¶

En handlingsstakke repræsenterer en stak af middleware, der skal anvendes på en basishandler funktion. Du kan skubbe middleware til stakken for at tilføje den til toppen af stakken, og fjerne middleware fra stakken for at tilføje den nederst i stakken. Når stakken er opløst, skubbes handleren ind på stakken. Hver værdi er derefter fra stakken, idet den foregående værdi, der er blevet fraført fra stakken, omsluttes af den stakken.

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

Du kan give middleware et navn, hvilket gør det muligt at tilføje middleware, før du anden navngiven middleware, efter anden navngiven middleware eller fjerne middleware efter navn.

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

Oprettelse af en handler¶

Som tidligere nævnt er en handler en funktion, der accepterer en Psr\Http\Message\RequestInterface og et array af anmodningsindstillinger og returnerer en GuzzleHttp\Promise\PromiseInterface, der er opfyldt med en Psr\Http\Message\ResponseInterface eller afvist med en undtagelse.

En handler er ansvarlig for at anvende følgende Anmodningsindstillinger. Disse anmodningsindstillinger er en delmængde af de anmodningsindstillinger, der kaldes "overførselsindstillinger".

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