Kezelők és Middleware¶

Kezelők¶

A kezelő függvény elfogad egy Psr\Http\Message\RequestInterface és egy tömbnyi kérési opciókból, és visszaad egy GuzzleHttp\Promise\PromiseInterface, amely a következő teljesül egy Psr\Http\Message\ResponseInterface vagy elutasít egy exception.

Egyéni kezelőt adhatsz az ügyfélnek a handler opcióval. kliens konstruktorban. Fontos megérteni, hogy több kérés a Guzzle által használt opciók megkövetelik, hogy bizonyos köztes szoftverek csomagolják a használt kezelőt. az ügyfél által használt kezelőt. Biztosíthatja, hogy az ügyfél számára biztosított kezelő használja a alapértelmezett middlewares-t használja, ha a kezelőt a GuzzleHttp\HandlerStack::create(callable $handler = null) statikus módszerrel.

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

A create módszer alapértelmezett kezelőket ad hozzá a HandlerStack-hez. Amikor a HandlerStack feloldódik, a kezelők a következő sorrendben fognak végrehajtódni:

1. Kérés küldése:

1. http_errors - Nincs op a kérés küldésekor. A válasz állapotkódja a válasz feldolgozásakor a válasz ígéret visszaküldésekor kerül ellenőrzésre. a veremre.
2. allow_redirects - Nincs op a kérés küldésekor. Következő átirányítások akkor következik be, amikor egy válaszígéret kerül vissza a veremre.
3. cookies - Cookie-kat ad a kérésekhez.
4. prepare_body - A HTTP-kérés teste előkészítésre kerül (pl., alapértelmezett fejlécek hozzáadása, mint például Content-Length, Content-Type stb.).
5. <send request with handler>

2. Feldolgozási válasz:

1. prepare_body - no op on response processing.
2. cookies - kivonja a válasz sütiket a sütisdobozba.
3. allow_redirects - Követi az átirányításokat.
4. http_errors - kivételeket dob, ha a válasz állapotkódja >= 400.

Ha nincs $handler argumentum megadva, GuzzleHttp\HandlerStack::create() a legmegfelelőbb kezelőt fogja kiválasztani a rendelkezésre álló kiterjesztések alapján. rendszeredben rendelkezésre álló bővítmények alapján.

Middleware¶

A middleware a kezelők funkcionalitását úgy bővíti ki, hogy a kezelőket a válaszok generálásának folyamatában. A middleware magasabb rendű függvényként valósul meg, amely a következő formát ölti.

use Psr\Http\Message\RequestInterface;

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

A middleware függvények egy olyan függvényt adnak vissza, amely elfogadja a következő meghívandó kezelőt. Ez a visszaadott függvény ezután egy másik függvényt ad vissza, amely egy összeállított kezelőként működik - elfogad egy kérést és opciókat, és egy ígéretet ad vissza, amely teljesül egy válasszal. A komponált middleware módosíthatja a kérést, egyéni kérési opciókat adhat hozzá, és módosíthatja a következő lépcsőfok által visszaadott ígéretet. kezelő által visszaadott eredményt.

Íme egy példa a fejléc hozzáadására minden egyes kéréshez.

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

Miután létrehoztunk egy middleware-t, hozzáadhatjuk azt egy ügyfélhez az ügyfél által használt kezelő csomagolásával vagy egy kezelő stack díszítésével.

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

Most, amikor kérést küldesz, az ügyfél a hozzáadott middleware-rel összeállított kezelőt fogja használni, és minden egyes kéréshez hozzáad egy fejlécet.

Íme egy példa egy olyan middleware létrehozására, amely módosítja a downstream kezelő válaszát. Ez a példa egy fejlécet ad a válaszhoz.

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

A kérést módosító middleware létrehozása sokkal egyszerűbbé válik a GuzzleHttp\Middleware::mapRequest() middleware. Ez a middleware elfogadja egy függvényt, amely elfogadja a kérés argumentumát és visszaadja a küldendő kérést.

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

A válasz módosítása is sokkal egyszerűbb a GuzzleHttp\Middleware::mapResponse() middleware segítségével.

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¶

A kezelő stack egy alap kezelőre alkalmazandó middleware stacket jelent. funkciót. A veremre tolhatsz middleware-t, hogy a verem tetejére kerüljön, és visszatolhatsz middleware-t a veremre, hogy a verem aljához adj hozzá. Amikor a a verem feloldásra kerül, a kezelőt a veremre toljuk. Minden érték Ezután minden értéket leemel a veremről, az előző értéket a veremről leemelt értékre csomagolva. veremre.

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

A middleware-nek nevet adhat, ami lehetővé teszi a middleware hozzáadását a más megnevezett middleware-ek előtt, más megnevezett middleware-ek után, vagy eltávolíthat middleware-eket. név alapján.

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

Kezelő létrehozása¶

Mint korábban említettük, a kezelő egy függvény, amely elfogad egy Psr\Http\Message\RequestInterface és a kérési opciók tömbjét, és visszaadja a következőt egy GuzzleHttp\Promise\PromiseInterface, amely egy GuzzleHttp\Promise\PromiseInterface Psr\Http\Message\ResponseInterface vagy egy kivétellel elutasítják.

A kezelő felelős a következő Request Options műveletek alkalmazásáért. Ezek a kérési opciók a kérési opciók egy részhalmaza, az úgynevezett "átviteli opciók".

• cert
• connect_timeout
• debug
• delay
• decode_content
• expect
• proxy
• mosogató
• timeout
• ssl_key
• stream
• ellenőrizze