Guzzle kasutab HTTP-sõnumiliidesena PSR-7. See võimaldab Guzzle'il töötada koos mis tahes muu raamatukoguga, mis kasutab PSR-7 sõnumiliidest.
Guzzle on HTTP-klient, mis saadab serverile HTTP-päringuid ja võtab vastu HTTP-vastuseid. Nii päringuid kui ka vastuseid nimetatakse sõnumiteks.
Guzzle tugineb guzzlehttp/psr7 Composer paketile PSR-7 sõnumite rakendamiseks.
Saate luua taotluse, kasutades GuzzleHttp\Psr7\Request klassi:
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);
Vastuse saate luua, kasutades GuzzleHttp\Psr7\Response klassi:
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);
Nii päringu- kui ka vastussõnumid sisaldavad HTTP-pealkirju.
Saate kontrollida, kas taotlusel või vastusel on konkreetne päis, kasutades meetodit hasHeader().
use GuzzleHttp\Psr7;
$request = new Psr7\Request('GET', '/', ['X-Foo' => 'bar']);
if ($request->hasHeader('X-Foo')) {
echo 'It is there';
}
Kõiki päise väärtusi saab saada stringide massiivi kujul, kasutades getHeader().
$request->getHeader('X-Foo'); // ['bar']
// Retrieving a missing header returns an empty array.
$request->getHeader('X-Bar'); // []
Sõnumi päiseid saab korrata, kasutades meetodit getHeaders().
foreach ($request->getHeaders() as $name => $values) {
echo $name . ': ' . implode(', ', $values) . "\r\n";
}
Mõned päised sisaldavad täiendavat teavet võtmeväärtuse paari kohta. Näiteks linkide päised sisaldavad linki ja mitut võtmeväärtuse paari:
<http://foo.com>; rel="thing"; type="image/jpeg"
Guzzle pakub mugavusfunktsiooni, mida saab kasutada seda tüüpi päiste analüüsimiseks:
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);
Väljund:
array (
0 =>
array (
0 => '<http:/.../front.jpeg>',
'rel' => 'front',
'type' => 'image/jpeg',
),
)
Tulemus sisaldab võtmeväärtuspaaride hashi. Pealkirja väärtused, millel puudub võti (st link) indekseeritakse numbriliselt, samas kui päise osad, mis moodustavad võtme väärtuse paari, lisatakse võtmeväärtuse paarina.
Nii päringu- kui ka vastussõnumid võivad sisaldada keha.
Te saate sõnumi keha kätte, kasutades meetodit getBody():
$response = GuzzleHttp\get('http://httpbin.org/get');
echo $response->getBody();
// JSON string: { ... }
Taotluse ja vastuse objektides kasutatav keha on
Psr\Http\Message\StreamInterface. Seda voogu kasutatakse nii
andmete üleslaadimiseks kui ka andmete allalaadimiseks. Guzzle salvestab vaikimisi keha
sõnumi voos, mis kasutab PHP temp streami. Kui keha suurus
ületab 2 MB, läheb voog automaatselt üle andmete salvestamisele kettale.
asemel mällu (kaitstes teie rakendust mälu ammendumise eest).
Kõige lihtsam viis sõnumi keha loomiseks on kasutada streamFor
meetodi GuzzleHttp\Psr7\Utils klassist --.
Utils::streamFor. See meetod võtab vastu stringid, ressursid,
callables, iteraatorid, muud streamables ja tagastab instantsi
Psr\Http\Message\StreamInterface.
Taotluse või vastuse keha saab teisendada stringiks või lugeda ja kirjutada baitide voogudest vastavalt vajadusele.
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());
Taotlused saadetakse kliendilt serverile. Taotlused sisaldavad meetodit mida rakendatakse ressursi suhtes, ressursi identifikaator ja protokoll. kasutatav versioon.
Taotluse loomisel oodatakse, et te annaksite soovitud HTTP-meetodi. teostada. Võite määrata mis tahes meetodi, sealhulgas kohandatud meetodi. mis ei pruugi olla osa RFC 7231-st (näiteks "MOVE").
// Create a request using a completely custom HTTP method
$request = new \GuzzleHttp\Psr7\Request('MOVE', 'http://httpbin.org/move');
echo $request->getMethod();
// MOVE
Saate luua ja saata päringu, kasutades kliendi meetodeid, mis vastavad soovitud HTTP-meetodile.
$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 **/])Näiteks:
$response = $client->patch('http://httpbin.org/patch', ['body' => 'content']);
Taotluse URI on esindatud Psr\Http\Message\UriInterface objektiga.
Guzzle pakub selle liidese implementatsiooni, mis kasutab funktsiooni
GuzzleHttp\Psr7\Uri klassi.
Taotluse loomisel saate URI esitada stringina või Psr\Http\Message\UriInterface eksemplarina.
$response = $client->request('GET', 'http://httpbin.org/get?q=foo');
Taotluse skeem skeem kohta määrab ära protokolli, mida kasutada päringu saatmisel. Guzzle'i kasutamisel on skeemiks "http" või "https".
$request = new Request('GET', 'http://httpbin.org');
echo $request->getUri()->getScheme(); // http
echo $request->getUri(); // http://httpbin.org
Hostile pääseb ligi, kasutades taotlusele kuuluvat URI-d või juurdepääsu Host-pealkirjale.
$request = new Request('GET', 'http://httpbin.org');
echo $request->getUri()->getHost(); // httpbin.org
echo $request->getHeader('Host'); // httpbin.org
Skeemide "http" või "https" kasutamisel ei ole port vajalik.
$request = new Request('GET', 'http://httpbin.org:8080');
echo $request->getUri()->getPort(); // 8080
echo $request->getUri(); // http://httpbin.org:8080
Taotluse tee on kättesaadav URI-objekti kaudu.
$request = new Request('GET', 'http://httpbin.org/get');
echo $request->getUri()->getPath(); // /get
Teekonna sisu filtreeritakse automaatselt, et tagada, et ainult lubatud tähemärgid on tee sees. Kõik sümbolid, mis ei ole lubatud tees ei tohi sisalduda, kodeeritakse protsentuaalselt vastavalt RFC 3986 jagu 3.3
Päringu päringustringile pääseb ligi, kasutades getQuery() URI-objekti, mis kuulub päringule.
$request = new Request('GET', 'http://httpbin.org/?foo=bar');
echo $request->getUri()->getQuery(); // foo=bar
Päringustringi sisu filtreeritakse automaatselt, et tagada, et et päringustringis oleksid ainult lubatud tähemärgid. Kõik tähemärgid, mis ei ole päringustringis lubatud, kodeeritakse protsentuaalselt vastavalt RFC 3986 punkt 3.4
Vastused on HTTP-sõnumid, mida klient saab serverilt pärast HTTP-päringusõnumi saatmist.
Vastuse algusrida sisaldab protokolli ja protokolli versiooni, staatuse koodi ja põhjuse fraasi.
$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
Nagu varem kirjeldatud, saate vastuse keha saada getBody() meetodi abil.
$body = $response->getBody();
echo $body;
// Cast to a string: { ... }
$body->seek(0);
// Rewind the body
$body->read(1024);
// Read bytes of the body
Guzzle kasutab PSR-7 voogobjekte päringu- ja vastussõnumi esitamiseks. kehad. Need voogobjektid võimaldavad teil töötada erinevate andmetüüpidega kõik kasutades ühist liidest.
HTTP-sõnumid koosnevad algusest, päistest ja kehast. HTTP-sõnumi keha sõnum võib olla väga väike või väga suur. Püüdes kujutada keha sõnumi stringina võib kergesti tarbida rohkem mälu kui ette nähtud, sest keha tuleb salvestada täielikult mällu. Püüdes salvestada keha päringu või vastuse mälus, välistaks selle rakenduse kasutamise alates võimet töötada suurte sõnumite kehadega. StreamInterface'i kasutatakse selleks, et varjata rakendamise üksikasjad, kust andmevooge loetakse. või kuhu kirjutatakse.
PSR-7 Psr\Http\Message\StreamInterface pakub mitmeid meetodeid, mis võimaldavad voogude lugemist, kirjutamist ja tõhusat läbimist.
Voolud avaldavad oma võimeid kolme meetodi abil: isReadable(),
isWritable() ja isSeekable(). Neid meetodeid saab kasutada stream
koostööpartnerid kindlaks teha, kas voog on võimeline nende nõuetele vastama.
Igal voo instantsil on erinevad võimalused: nad võivad olla ainult lugemiseks, ainult kirjutama, kirjutama, lubama suvalist juhuslikku juurdepääsu (otsides edasi või edasi). tagasi suvalisse kohta), või lubada ainult järjestikust juurdepääsu (nt. socket'i või toru puhul).
Guzzle kasutab guzzlehttp/psr7 paketti, et pakkuda voogedastuse tuge. Rohkem
teavet voogude kasutamise, voogude loomise, voogude PHP-sse konverteerimise kohta.
voogude ressursi ja voogude dekoraatorite kohta leiate dokumendist
Guzzle PSR-7 dokumentatsioon.
Parim viis voo loomiseks on kasutada GuzzleHttp\Psr7\Utils::streamFor
meetodi abil. See meetod võtab vastu stringid, fopen() poolt tagastatud ressursid,
objekti, mis rakendab __toString(), iteraatoreid, callables ja instantse.
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
Iteraatoritest saab luua voogusid. Iteraator võib anda suvalise arvu baiti ühe iteratsiooni kohta. Kõik iteraatori poolt tagastatud liigsed baidid, mis ei olnud ei ole nõutud voo tarbija poolt, puhverdatakse kuni järgmise lugemiseni.
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); // ...
Voogude metaandmed esitatakse getMetadata() meetodi abil. See
meetod pakub andmeid, mida te saaksite kätte, kui kutsuksite PHP-i
stream_get_meta_data() funktsiooni,
ja võib valikuliselt avaldada muid kohandatud andmeid.
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
Voogudele kohandatud funktsionaalsuse lisamine on väga lihtne voogude dekoraatorite abil. Guzzle pakub mitmeid sisseehitatud dekoraatoreid, mis pakuvad täiendavaid voogude funktsionaalsust.