A Guzzle a PSR-7-et használja HTTP-üzenetinterfészként. Ez lehetővé teszi, hogy a Guzzle bármilyen más, PSR-7 üzenetinterfészeket használó könyvtárral együttműködjön.
A Guzzle egy HTTP-kliens, amely HTTP-kéréseket küld egy kiszolgálónak, és HTTP-válaszokat fogad. Mind a kéréseket, mind a válaszokat üzeneteknek nevezzük.
A Guzzle a guzzlehttp/psr7 Composer csomagra támaszkodik a PSR-7 üzenet implementációjához.
A GuzzleHttp\Psr7\Request osztály segítségével hozhat létre kérést:
use GuzzleHttp\Psr7\Request;
$request = new Request('GET', 'http://httpbin.org/get');
// You can provide other optional constructor arguments.
$headers = ['X-Foo' => 'Bar'];
$body = 'hello!';
$request = new Request('PUT', 'http://httpbin.org/put', $headers, $body);
A választ a GuzzleHttp\Psr7\Response osztály segítségével hozhatja létre:
use GuzzleHttp\Psr7\Response;
// The constructor requires no arguments.
$response = new Response();
echo $response->getStatusCode(); // 200
echo $response->getProtocolVersion(); // 1.1
// You can supply any number of optional arguments.
$status = 200;
$headers = ['X-Foo' => 'Bar'];
$body = 'hello!';
$protocol = '1.1';
$response = new Response($status, $headers, $body, $protocol);
Mind a kérési, mind a válaszüzenetek HTTP fejléceket tartalmaznak.
A hasHeader() módszerrel ellenőrizheti, hogy egy kérés vagy válasz rendelkezik-e egy adott fejléccel.
use GuzzleHttp\Psr7;
$request = new Psr7\Request('GET', '/', ['X-Foo' => 'bar']);
if ($request->hasHeader('X-Foo')) {
echo 'It is there';
}
A getHeader() segítségével az összes fejlécértéket karakterláncok tömbjeként kérheti le.
$request->getHeader('X-Foo'); // ['bar']
// Retrieving a missing header returns an empty array.
$request->getHeader('X-Bar'); // []
Az üzenet fejléceit a getHeaders() módszerrel tekinthetjük át.
foreach ($request->getHeaders() as $name => $values) {
echo $name . ': ' . implode(', ', $values) . "\r\n";
}
Néhány fejléc további kulcs-érték páros információkat tartalmaz. A Link fejlécek például egy linket és több kulcsértékpárt tartalmaznak:
<http://foo.com>; rel="thing"; type="image/jpeg"
A Guzzle biztosít egy kényelmi funkciót, amely az ilyen típusú fejlécek elemzésére használható:
use GuzzleHttp\Psr7;
$request = new Psr7\Request('GET', '/', [
'Link' => '<http:/.../front.jpeg>; rel="front"; type="image/jpeg"'
]);
$parsed = Psr7\Header::parse($request->getHeader('Link'));
var_export($parsed);
Kimenet:
array (
0 =>
array (
0 => '<http:/.../front.jpeg>',
'rel' => 'front',
'type' => 'image/jpeg',
),
)
Az eredmény egy kulcs-érték párokat tartalmazó hash-t tartalmaz. A kulcs nélküli fejlécértékek (azaz a link) numerikusan indexelve vannak, míg a kulcsot alkotó fejlécrészek numerikusan indexelve vannak. értékpárt alkotnak, kulcs-értékpárként adódnak össze.
Mind a kérési, mind a válaszüzenetek tartalmazhatnak testet.
Az üzenet testét a getBody() módszerrel kérheti le:
$response = GuzzleHttp\get('http://httpbin.org/get');
echo $response->getBody();
// JSON string: { ... }
A kérés és a válasz objektumokban használt test egy
Psr\Http\Message\StreamInterface. Ezt a folyamot használják mind a
adatok feltöltésére és letöltésére. A Guzzle alapértelmezés szerint a testet a
üzenetet egy olyan folyamban tárolja, amely a PHP temp streameket használja. Amikor a test mérete
meghaladja a 2 MB-ot, a folyam automatikusan áttér az adatok lemezen történő tárolására.
ahelyett, hogy a memóriában tárolná (megóvva az alkalmazást a memória kimerülésétől).
A legegyszerűbb módja az üzenet testének létrehozásának a streamFor használatával.
metódus a GuzzleHttp\Psr7\Utils osztályból származó metódus segítségével.
Utils::streamFor. Ez a módszer stringeket, erőforrásokat fogad el,
callables, iterátorokat, egyéb streamable-eket, és visszaad egy példányt a
Psr\Http\Message\StreamInterface.
A kérés vagy válasz teste egy karakterlánccá alakítható, vagy szükség szerint bájtokat olvashat és írhat a folyamból.
use GuzzleHttp\Stream\Stream;
$response = $client->request('GET', 'http://httpbin.org/get');
echo $response->getBody()->read(4);
echo $response->getBody()->read(4);
echo $response->getBody()->read(1024);
var_export($response->eof());
A kéréseket az ügyfél küldi a kiszolgálónak. A kérések tartalmazzák a következő módszert az erőforrásra alkalmazni kell, az erőforrás azonosítóját és a protokollt. verziót.
A kérelem létrehozásakor meg kell adnia a kívánt HTTP-módszert. kíván végrehajtani. Bármilyen módszert megadhat, beleértve az egyéni módszert is. amely esetleg nem része az RFC 7231-nek (például a "MOVE").
// Create a request using a completely custom HTTP method
$request = new \GuzzleHttp\Psr7\Request('MOVE', 'http://httpbin.org/move');
echo $request->getMethod();
// MOVE
Létrehozhat és elküldhet egy kérést az ügyfél olyan módszereinek használatával, amelyek megfelelnek a használni kívánt HTTP-módszernek.
$client->get('http://httpbin.org/get', [/** options **/])$client->post('http://httpbin.org/post', [/** options **/])$client->head('http://httpbin.org/get', [/** options **/])$client->put('http://httpbin.org/put', [/** options **/])$client->delete('http://httpbin.org/delete', [/** options **/])$client->options('http://httpbin.org/get', [/** options **/])$client->patch('http://httpbin.org/put', [/** options **/])Például:
$response = $client->patch('http://httpbin.org/patch', ['body' => 'content']);
A kérés URI-ját egy Psr\Http\Message\UriInterface objektum képviseli.
A Guzzle biztosítja ennek az interfésznek az implementációját a
GuzzleHttp\Psr7\Uri osztály.
A kérés létrehozásakor megadhatja az URI-t sztringként vagy a Psr\Http\Message\UriInterface egy példányaként.
$response = $client->request('GET', 'http://httpbin.org/get?q=foo');
Egy kérelem sémája meghatározza a kérés küldéséhez használandó protokollt. A Guzzle használatakor a séma "http" vagy "https" lehet.
$request = new Request('GET', 'http://httpbin.org');
echo $request->getUri()->getScheme(); // http
echo $request->getUri(); // http://httpbin.org
Az állomás a kérelemhez tartozó URI segítségével vagy a Host fejléchez való hozzáféréssel érhető el.
$request = new Request('GET', 'http://httpbin.org');
echo $request->getUri()->getHost(); // httpbin.org
echo $request->getHeader('Host'); // httpbin.org
A "http" vagy "https" sémák használata esetén nincs szükség portra.
$request = new Request('GET', 'http://httpbin.org:8080');
echo $request->getUri()->getPort(); // 8080
echo $request->getUri(); // http://httpbin.org:8080
A kérelem elérési útvonala az URI objektumon keresztül érhető el.
$request = new Request('GET', 'http://httpbin.org/get');
echo $request->getUri()->getPath(); // /get
Az elérési útvonal tartalma automatikusan szűrésre kerül, hogy csak a engedélyezett karakterek szerepeljenek az elérési útvonalban. A nem engedélyezett karakterek az elérési útvonalban nem engedélyezett karakterek százalékos kódolásra kerülnek a RFC 3986 3.3. szakasz
A kérés lekérdezési karakterlánca a kéréshez tartozó URI objektum getQuery() segítségével érhető el.
$request = new Request('GET', 'http://httpbin.org/?foo=bar');
echo $request->getUri()->getQuery(); // foo=bar
A lekérdezési karakterlánc tartalma automatikusan szűrésre kerül annak érdekében, hogy biztosítsa, hogy csak a megengedett karakterek szerepeljenek a lekérdezési karakterláncban. Minden olyan karakter, amely nem engedélyezettek a lekérdezési karakterláncban, százalékos kódolásra kerülnek a következők szerint RFC 3986 3.4. szakasz
A válaszok azok a HTTP-üzenetek, amelyeket az ügyfél a HTTP-kérelem elküldése után kap a kiszolgálótól.
A válasz kezdő sora tartalmazza a protokollt és a protokollverziót, az állapotkódot és az okot tartalmazó kifejezést.
$client = new \GuzzleHttp\Client();
$response = $client->request('GET', 'http://httpbin.org/get');
echo $response->getStatusCode(); // 200
echo $response->getReasonPhrase(); // OK
echo $response->getProtocolVersion(); // 1.1
Ahogy korábban leírtuk, a válasz testét a getBody() metódussal kaphatjuk meg.
$body = $response->getBody();
echo $body;
// Cast to a string: { ... }
$body->seek(0);
// Rewind the body
$body->read(1024);
// Read bytes of the body
A Guzzle PSR-7 stream objektumokat használ a kérési és válaszüzenetek ábrázolására. testeket. Ezek a stream objektumok lehetővé teszik, hogy különböző típusú adatokkal dolgozzunk az összes egy közös interfész segítségével.
A HTTP-üzenetek egy kezdősorból, fejlécekből és egy testből állnak. A HTTP üzenetek teste üzenet teste lehet nagyon kicsi vagy rendkívül nagy. A test ábrázolásának kísérlete egy üzenet karakterláncként való ábrázolása könnyen a tervezettnél több memóriát emészthet fel, mert a testet teljes egészében a memóriában kell tárolni. Ha megpróbáljuk tárolni a testet egy kérés vagy válasz memóriában történő tárolása kizárná az adott implementáció használatát a hogy képes legyen nagy üzenettörzsekkel dolgozni. A StreamInterface-t a hogy elrejtse a megvalósítás részleteit, hogy honnan olvassa be az adatfolyamot. vagy hova íródik.
A PSR-7 Psr\Http\Message\StreamInterface több olyan metódust is tartalmaz, amelyek lehetővé teszik a streamek hatékony olvasását, írását és átjárását.
A streamek három módszerrel tárják fel képességeiket: isReadable(),
isWritable(), és isSeekable(). Ezeket a metódusokat a stream
együttműködők arra, hogy megállapítsák, hogy egy folyam alkalmas-e a követelményeik teljesítésére.
Az egyes folyam példányok különböző képességekkel rendelkeznek: lehetnek csak olvashatóak, csak írható, írható, írható, tetszőleges véletlenszerű hozzáférést tesz lehetővé (előre vagy visszafelé bármilyen helyre), vagy csak szekvenciális hozzáférést engedélyezhet (például a socket vagy pipe esetében).
A Guzzle a guzzlehttp/psr7 csomagot használja a stream támogatás biztosítására. További
információ a streamek használatáról, a streamek létrehozásáról, a streamek PHP-ba való konvertálásáról.
stream erőforrássá alakításáról, és a stream dekorátorokról a
Guzzle PSR-7 dokumentáció.
A stream létrehozásának legjobb módja a GuzzleHttp\Psr7\Utils::streamFor használata.
módszerrel. Ez a módszer stringeket, a fopen() által visszaadott erőforrásokat fogad el,
olyan objektumot, amely a __toString(), iterátorokat, hívható és példányokat.
a Psr\Http\Message\StreamInterface.
use GuzzleHttp\Psr7;
$stream = Psr7\Utils::streamFor('string data');
echo $stream;
// string data
echo $stream->read(3);
// str
echo $stream->getContents();
// ing data
var_export($stream->eof());
// true
var_export($stream->tell());
// 11
Az iterátorokból streameket hozhat létre. Az iterátor tetszőleges számú bájtot iterációnként. Az iterátor által visszaadott minden olyan felesleges bájt, amely nem volt nem egy folyamfogyasztó kért, egy következő olvasásig pufferelve lesz.
use GuzzleHttp\Psr7;
$generator = function ($bytes) {
for ($i = 0; $i < $bytes; $i++) {
yield '.';
}
};
$iter = $generator(1024);
$stream = Psr7\Utils::streamFor($iter);
echo $stream->read(3); // ...
A streamek a metaadatokat a getMetadata() metóduson keresztül teszik közzé. Ez a
metódus biztosítja azokat az adatokat, amelyeket a PHP
stream_get_meta_data() függvényt,
és opcionálisan más egyéni adatokat is megadhat.
use GuzzleHttp\Psr7;
$resource = Psr7\Utils::tryFopen('/path/to/file', 'r');
$stream = Psr7\Utils::streamFor($resource);
echo $stream->getMetadata('uri');
// /path/to/file
var_export($stream->isReadable());
// true
var_export($stream->isWritable());
// false
var_export($stream->isSeekable());
// true
Egyéni funkciók hozzáadása a streamekhez nagyon egyszerű a stream dekorátorokkal. A Guzzle számos beépített dekorátort biztosít, amelyek további folyamokat biztosítanak funkcionalitást biztosítanak.