Handlers och middleware¶

Handlers¶

En hanterarfunktion accepterar ett Psr\Http\Message\RequestInterface och en matris av och returnerar ett GuzzleHttp\Promise\PromiseInterface som är uppfylls med ett Psr\Http\Message\ResponseInterface eller avvisas med ett Psr\Http\Message\ResponseInterface. undantag.

Du kan tillhandahålla en anpassad handläggare till en klient genom att använda alternativet handler i en klientkonstruktör. Det är viktigt att förstå att flera begäran som används av Guzzle kräver att specifika mellanprogram sveper in den handläggare som används av klienten. Du kan se till att den handläggare som du tillhandahåller en klient använder alternativet genom att omsluta handläggaren i GuzzleHttp\HandlerStack::create(callable $handler = null) statisk 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]);

Metoden create lägger till standardhanterare till HandlerStack. När HandlerStack är löst kommer handläggarna att utföras i följande ordning:

1. Sänder en begäran:

1. http_errors - Ingen op när en begäran skickas. Statuskoden för svaret kontrolleras i svarsbehandlingen när ett svarslöfte returneras. stacken.
2. allow_redirects - Inget op när en begäran skickas. Följande omdirigeringar sker när ett svarslöfte returneras uppåt i stacken.
3. cookies - Lägger till cookies i begäranden.
4. prepare_body - Kroppen för en HTTP-förfrågan förbereds (t.ex., lägga till standardrubriker som Content-Length, Content-Type etc.).
5. <skicka begäran med handläggare>

2. Bearbetningssvar:

1. prepare_body - inga åtgärder för svarsbehandling.
2. cookies - hämtar svarscookies i kakburken.
3. allow_redirects - Följer omdirigeringar.
4. http_errors - kastar undantag när svarsstatuskoden >= 400.

När inget $handler argument tillhandahålls, GuzzleHttp\HandlerStack::create() kommer att välja den lämpligaste hanteraren baserat på de tillägg som finns tillgängliga på ditt system.

Middleware¶

Middleware utökar funktionaliteten hos handläggare genom att åberopa dem i den processen att generera svar. Middleware implementeras som en högre ordning funktion som har följande 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 returnerar en funktion som accepterar nästa handläggare att anropa. Den returnerade funktionen returnerar sedan en annan funktion som fungerar som en sammansatt handläggare - den tar emot en begäran och alternativ och returnerar ett löfte som är uppfylls med ett svar. Din sammansatta middleware kan ändra begäran, lägga till egna alternativ för begäran och ändra det löfte som returneras av den nedströmsbaserade handläggaren.

Här är ett exempel på att lägga till en rubrik till varje begäran.

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 en middleware har skapats kan du lägga till den i en klient genom att antingen omsluta den handläggare som används av klienten eller genom att dekorera en handläggarstack.

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 skickar en begäran kommer klienten att använda en handläggare som är sammansatt med din tillagda middleware och som lägger till en rubrik till varje begäran.

Här är ett exempel på att skapa en middleware som ändrar svaret från nedströmshanteraren. I det här exemplet läggs en rubrik till 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 är mycket enklare att skapa en middleware som ändrar en begäran med hjälp av GuzzleHttp\Middleware::mapRequest(). Denna middleware accepterar en funktion som tar emot argumentet för begäran och returnerar den begäran som ska skickas.

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 är också mycket enklare att ändra ett svar med hjälp av 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 handläggarstack representerar en stack av mellanprogram som ska tillämpas på en bashandläggare. funktion. Du kan lägga till mellanprogram i stapeln för att lägga till toppen av stapeln, och ta bort middleware från stapeln för att lägga till längst ner i stapeln. När stapeln är löst, skjuts handläggaren upp på stapeln. Varje värde är från stapeln, och det föregående värdet som tagits bort från stapeln läggs om till stacken.

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 ge middleware ett namn, vilket gör att du kan lägga till middleware innan du andra namngivna middleware, efter andra namngivna middleware eller ta bort middleware efter namn.

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

Skapa en handledare¶

Som tidigare nämnts är en handläggare en funktion som accepterar en Psr\Http\Message\RequestInterface och en matris av förfrågningsalternativ och returnerar ett GuzzleHttp\Promise\PromiseInterface som uppfylls med en Psr\Http\Message\ResponseInterface eller avvisas med ett undantag.

En handläggare ansvarar för att tillämpa följande Förfrågningsalternativ. Dessa begärselalternativ är en delmängd av de begärselalternativ som kallas "överföringsalternativ".

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