Handlers și Middleware¶

Manipulatori¶

O funcție handler acceptă o Psr\Http\Message\RequestInterface și un array de opțiuni de cerere și returnează o GuzzleHttp\Promise\PromiseInterface care este îndeplinită cu un Psr\Http\Message\ResponseInterface sau respinsă cu un Psr\Http\Message\ResponseInterface. excepție.

Puteți furniza un gestionar personalizat unui client utilizând opțiunea handler din unui constructor de client. Este important să înțelegeți că mai multe cereri opțiuni de cerere utilizate de Guzzle necesită ca anumite middleware-uri să înfășoare gestionarul utilizat de către client. Vă puteți asigura că gestionarul pe care îl furnizați unui client utilizează opțiunea middleware-uri implicite, învelind gestionarul cu ajutorul aplicației GuzzleHttp\HandlerStack::create(callable $handler = null) metodă statică.

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 adaugă gestionari impliciți la HandlerStack. Atunci când HandlerStack este rezolvat, gestionarii se vor executa în următoarea ordine:

1. Trimiterea cererii:

1. http_errors - Nici o operațiune la trimiterea unei cereri. Codul de stare al răspunsului este verificat în procesarea răspunsului atunci când se returnează o promisiune de răspuns up în stivă.
2. allow_redirects - Nici o operațiune la trimiterea unei cereri. Următoarele redirecționări apare atunci când o promisiune de răspuns este returnată în stivă.
3. cookies - Adaugă cookie-uri la cereri.
4. prepare_body - Corpul unei cereri HTTP va fi pregătit (de ex, se vor adăuga anteturi implicite, cum ar fi Content-Length, Content-Type etc.).
5. <send request with handler>

2. Răspunsul de prelucrare:

1. prepare_body - nici o operațiune privind procesarea răspunsului.
2. cookies - extrage cookie-urile de răspuns în borcanul de cookie-uri.
3. allow_redirects - Urmărește redirecționările.
4. http_errors - aruncă excepții atunci când codul de stare al răspunsului >= 400.

Atunci când nu este furnizat niciun argument $handler, GuzzleHttp\HandlerStack::create() va alege cel mai potrivit gestionar pe baza extensiilor disponibile pe sistemul dumneavoastră.

Middleware¶

Middleware sporește funcționalitatea gestionarilor prin invocarea acestora în cadrul procesul de generare a răspunsurilor. Middleware-ul este implementat ca o componentă de ordin superior care are următoarea 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);
        };
    };
}

Funcțiile middleware returnează o funcție care acceptă următorul gestionar de invocat. Această funcție returnată returnează apoi o altă funcție care acționează ca o funcție compusă. de manipulare - acceptă o cerere și opțiuni și returnează o promisiune care este îndeplinită cu un răspuns. Middleware-ul compus poate modifica cererea, să adauge opțiuni de solicitare personalizate și să modifice promisiunea returnată de către de gestionare.

Iată un exemplu de adăugare a unui antet la fiecare cerere.

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

Odată ce un middleware a fost creat, îl puteți adăuga la un client fie prin înfășurarea gestionarului utilizat de client, fie prin decorarea unei stive de gestionari.

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

Acum, atunci când trimiteți o cerere, clientul va utiliza un gestionar compus cu middleware-ul adăugat de dumneavoastră, adăugând un antet la fiecare cerere.

Iată un exemplu de creare a unui middleware care modifică răspunsul gestionarului din aval. Acest exemplu adaugă un antet la răspuns.

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

Crearea unui middleware care să modifice o cerere este mult mai simplă cu ajutorul funcției GuzzleHttp\Middleware::mapRequest() middleware. Acest middleware acceptă o funcție care primește argumentul request și returnează cererea de trimis.

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

Modificarea unui răspuns este, de asemenea, mult mai simplă folosind 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¶

O stivă de gestionari reprezintă o stivă de intermediari care se aplică unui gestionar de bază. funcție. Puteți să împingeți middleware în stivă pentru a-l adăuga în partea de sus a acesteia, și să desființați middleware-ul de pe stivă pentru a-l adăuga în partea de jos a acesteia. Atunci când stiva este rezolvată, gestionarul este împins pe stivă. Fiecare valoare este este apoi scoasă din stivă, înfășurând valoarea anterioară scoasă din stivă. din stivă.

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

Puteți da un nume middleware-ului, ceea ce vă permite să adăugați middleware înainte de alte middleware-uri denumite, după alte middleware-uri denumite, sau să eliminați middleware-ul după nume.

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

Crearea unui Handler¶

După cum s-a spus mai devreme, un handler este o funcție care acceptă un Psr\Http\Message\RequestInterface și o matrice de opțiuni de cerere și returnează un GuzzleHttp\Promise\PromiseInterface care este îndeplinit cu un Psr\Http\Message\ResponseInterface sau respinsă cu o excepție.

Un operator este responsabil pentru aplicarea următoarelor Opțiuni de cerere. Aceste opțiuni de cerere sunt un subset de opțiuni de cerere numite "opțiuni de transfer".

• cert
• connect_timeout
• debug
• întârziere
• decode_content
• expect
• proxy
• sink
• timeout
• ssl_key
• stream
• verifica