Handlery a middleware¶

Klienti Guzzle používají k odesílání požadavků HTTP systém obsluhy a middleware.

Handlery¶

Funkce obsluhy přijímá Psr\Http\Message\RequestInterface a pole. možností požadavku a vrací GuzzleHttp\Promise\PromiseInterface, které je splněn pomocí Psr\Http\Message\ResponseInterface nebo odmítnut pomocí Psr\Http\Message\ResponseInterface. výjimkou.

Vlastní obslužnou rutinu můžete klientovi zadat pomocí handler volby . konstruktoru klienta. Je důležité si uvědomit, že několik požadavků možností používaných nástrojem Guzzle vyžaduje, aby specifické prostředníky obalily použitou obslužnou rutinu. klientem. Můžete zajistit, aby handler, který poskytujete klientovi, používal příkaz výchozí middlewares tím, že handler zabalíte do složky GuzzleHttp\HandlerStack::create(callable $handler = null) statickou metodou.

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

Metoda create přidá výchozí manipulátory do HandlerStack. Když je HandlerStack vyřešen, provedou se obsluhy v následujícím pořadí:

Odeslání žádosti:

http_errors - Při odesílání požadavku není op. Stavový kód odpovědi je kontrolován při zpracování odpovědi při vrácení slibu odpovědi nahoru. zásobníku.

allow_redirects - Žádné op při odesílání požadavku. Následující přesměrování nastane, když se na zásobník vrací slib odpovědi.

cookies - Přidá cookies do požadavků.

prepare_body - Připraví se tělo požadavku HTTP (např., přidá výchozí hlavičky jako Content-Length, Content-Type atd.).

<odeslat požadavek s obsluhou>

Zpracování odpovědi:

prepare_body - žádný op na zpracování odpovědi.

cookies - extrahuje cookies odpovědi do cookie nádoby.

allow_redirects - Sleduje přesměrování.

http_errors - vyhodí výjimku, když je stavový kód odpovědi >= 400.

Pokud není zadán žádný $handler argument, GuzzleHttp\HandlerStack::create() vybere nejvhodnější obslužnou rutinu na základě rozšíření dostupných v systému vašem systému.

Důležité

Obslužný program poskytnutý klientovi určuje, jak se použijí možnosti požadavku. a využity pro každý požadavek odeslaný klientem. Pokud například nezadáte s klientem spojen prostředník cookie, pak nastavení parametru cookies možnost požadavku nebude mít na požadavek žádný vliv.

Middleware¶

Middleware rozšiřuje funkčnost obslužných rutin tím, že je vyvolává v rámci systému v procesu generování odpovědí. Middleware je implementován jako vyšší řád funkce, která má následující podobu.

use Psr\Http\Message\RequestInterface;

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

Funkce middlewaru vrací funkci, která přijímá další obslužnou rutinu k vyvolání. Tato vrácená funkce pak vrací další funkci, která funguje jako složená funkce. obslužnou rutinu - přijme požadavek a možnosti a vrátí slib, který je splněn spolu s odpovědí. Váš složený middleware může požadavek upravit, přidat vlastní možnosti požadavku a upravit slib vrácený následnou funkcí. obslužnou rutinu.

Zde je příklad přidání hlavičky ke každému požadavku.

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

Jakmile je middleware vytvořen, můžete jej přidat ke klientovi buď obalením obslužné rutiny používané klientem, nebo ozdobením zásobníku obslužných rutin.

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

Když nyní odešlete požadavek, klient použije obslužný program složený z vašeho přidaného middlewaru a ke každému požadavku přidá hlavičku.

Zde je příklad vytvoření middlewaru, který upravuje odpověď následné obslužné rutiny. Tento příklad přidává do odpovědi hlavičku.

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

Vytvoření middlewaru, který modifikuje požadavek, je mnohem jednodušší pomocí příkazu GuzzleHttp\Middleware::mapRequest() middleware. Tento middleware přijímá funkci, která přebírá argument požadavku a vrací požadavek k odeslá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]);

Úprava odpovědi je také mnohem jednodušší pomocí 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¶

Zásobník obslužných rutin představuje zásobník middlewaru, který se použije na základní obslužnou rutinu. funkce. Do zásobníku můžete vložit middleware, který se přidá na vrchol zásobníku, a odsunout middleware na zásobník, abyste jej přidali na konec zásobníku. Když je zásobník vyřešen, je obslužná rutina posunuta na zásobník. Každá hodnota je pak ze zásobníku vyskočí, přičemž se zabalí předchozí hodnota vyskočená ze zásobníku. zásobníku.

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

middleware můžete pojmenovat, což vám umožní přidat middleware před jiný pojmenovaný middleware, za jiný pojmenovaný middleware nebo odebrat middleware. podle názvu.

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

Vytvoření obslužného programu¶

Jak již bylo řečeno, obslužná rutina je funkce, která přijímá a Psr\Http\Message\RequestInterface a pole možností požadavku a vrací jej. GuzzleHttp\Promise\PromiseInterface, který je splněn pomocí příkazu Psr\Http\Message\ResponseInterface nebo odmítnuta s výjimkou.

Obslužný program je zodpovědný za použití následujících možností požadavku. Tyto možnosti požadavku jsou podmnožinou možností požadavku tzv. "možnosti přenosu".

Obsah

Handlery a middleware¶

Handlery¶

Middleware¶

HandlerStack¶

Vytvoření obslužného programu¶