Guzzle izmanto PSR-7 kā HTTP ziņojumu saskarni. Tas ļauj Guzzle strādāt ar jebkuru citu bibliotēku, kas izmanto PSR-7 ziņojumu saskarnes.
Guzzle ir HTTP klients, kas sūta HTTP pieprasījumus serverim un saņem HTTP atbildes. Gan pieprasījumus, gan atbildes sauc par ziņojumiem.
Guzzle paļaujas uz guzzlehttp/psr7 Composer paketi PSR-7 ziņojumu implementācijai.
Pieprasījumu var izveidot, izmantojot GuzzleHttp\Psr7\Request klasi:
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);
Atbildi var izveidot, izmantojot GuzzleHttp\Psr7\Response klasi:
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);
Gan pieprasījuma, gan atbildes ziņojumos ir HTTP galvenes.
Varat pārbaudīt, vai pieprasījumam vai atbildei ir noteikta galvene, izmantojot hasHeader() metodi.
use GuzzleHttp\Psr7;
$request = new Psr7\Request('GET', '/', ['X-Foo' => 'bar']);
if ($request->hasHeader('X-Foo')) {
echo 'It is there';
}
Visas galvenes vērtības var iegūt kā virkņu masīvu, izmantojot getHeader().
$request->getHeader('X-Foo'); // ['bar']
// Retrieving a missing header returns an empty array.
$request->getHeader('X-Bar'); // []
Ziņojuma galvenes var pārlūkot, izmantojot getHeaders() metodi.
foreach ($request->getHeaders() as $name => $values) {
echo $name . ': ' . implode(', ', $values) . "\r\n";
}
Dažās galvenēs ir papildu informācija par atslēgu un vērtību pāriem. Piemēram, saite galvenēs ir saite un vairāki atslēgu vērtību pāri:
<http://foo.com>; rel="thing"; type="image/jpeg"
Guzzle nodrošina ērtu funkciju, ko var izmantot, lai analizētu šāda veida galvenes:
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);
Būs produkcija:
array (
0 =>
array (
0 => '<http:/.../front.jpeg>',
'rel' => 'front',
'type' => 'image/jpeg',
),
)
Rezultātā tiek iegūts atslēgu un vērtību pāru hash. Header vērtības, kurām nav atslēgas (t. i., saite), tiek indeksētas skaitliski, bet galvenes daļas, kas veido atslēgu, tiek indeksētas skaitliski. vērtību pāri, tiek pievienotas kā atslēgas un vērtības pāri.
Gan pieprasījuma, gan atbildes ziņojums var saturēt ķermeni.
Ziņojuma tekstu var iegūt, izmantojot getBody() metodi:
$response = GuzzleHttp\get('http://httpbin.org/get');
echo $response->getBody();
// JSON string: { ... }
Pieprasījuma un atbildes objektos izmantotais ķermenis ir
Psr\Http\Message\StreamInterface. Šo plūsmu izmanto gan
datu augšupielādei un datu lejupielādei. Guzzle pēc noklusējuma saglabās straumju ķermeni
plūsmā, kas izmanto PHP pagaidu plūsmas. Kad ķermeņa lielums
pārsniedz 2 MB, plūsma automātiski pārslēgsies uz datu glabāšanu diskā.
nevis atmiņā (pasargājot lietojumprogrammu no atmiņas izsmelšanas).
Visvienkāršākais veids, kā izveidot ziņojuma ķermeni, ir izmantot streamFor
metodi no GuzzleHttp\Psr7\Utils klases --
Utils::streamFor. Šī metode pieņem virknes, resursus,
un iteratorus, citus streamables, un atdod instance of
Psr\Http\Message\StreamInterface.
Pieprasījuma vai atbildes tekstu var pārvērst virknē vai pēc vajadzības lasīt un rakstīt baitus no plūsmas.
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());
Pieprasījumi tiek nosūtīti no klienta uz serveri. Pieprasījumi ietver metodi resursam piemērojamo metodi, resursa identifikatoru un protokolu. izmantojamā protokola versiju.
Veidojot pieprasījumu, ir jānorāda vēlamā HTTP metode. izpildīt. Varat norādīt jebkuru vēlamo metodi, tostarp pielāgotu metodi. kas var nebūt iekļauta RFC 7231 (piemēram, "MOVE").
// Create a request using a completely custom HTTP method
$request = new \GuzzleHttp\Psr7\Request('MOVE', 'http://httpbin.org/move');
echo $request->getMethod();
// MOVE
Varat izveidot un nosūtīt pieprasījumu, izmantojot klienta metodes, kas atbilst HTTP metodei, kuru vēlaties izmantot.
$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 **/])Piemēram:
$response = $client->patch('http://httpbin.org/patch', ['body' => 'content']);
Pieprasījuma URI tiek attēlots ar Psr\Http\Message\UriInterface objektu.
Guzzle nodrošina šīs saskarnes implementāciju, izmantojot objektu
GuzzleHttp\Psr7\Uri klasi.
Veidojot pieprasījumu, URI var norādīt kā virkni vai Psr\Http\Message\UriInterface gadījumu.
$response = $client->request('GET', 'http://httpbin.org/get?q=foo');
Pieprasījuma shēma norāda protokolu, kas jāizmanto, nosūtot pieprasījumu. Izmantojot Guzzle shēmu var iestatīt kā "http" vai "https".
$request = new Request('GET', 'http://httpbin.org');
echo $request->getUri()->getScheme(); // http
echo $request->getUri(); // http://httpbin.org
Saimnieks ir pieejams, izmantojot pieprasījumam piederošo URI vai piekļūstot Host galvenei.
$request = new Request('GET', 'http://httpbin.org');
echo $request->getUri()->getHost(); // httpbin.org
echo $request->getHeader('Host'); // httpbin.org
Izmantojot shēmas "http" vai "https", nav nepieciešams ports.
$request = new Request('GET', 'http://httpbin.org:8080');
echo $request->getUri()->getPort(); // 8080
echo $request->getUri(); // http://httpbin.org:8080
Pieprasījuma ceļš ir pieejams, izmantojot URI objektu.
$request = new Request('GET', 'http://httpbin.org/get');
echo $request->getUri()->getPath(); // /get
Ceļa saturs tiks automātiski filtrēts, lai nodrošinātu, ka tikai ceļā ir tikai atļautās rakstzīmes. Jebkuras neatļautas rakstzīmes ceļā tiks procentuāli kodētas saskaņā ar RFC 3986 3.3. sadaļa.
Pieprasījuma vaicājuma rindai var piekļūt, izmantojot getQuery() no URI objekta, kam pieder pieprasījums.
$request = new Request('GET', 'http://httpbin.org/?foo=bar');
echo $request->getUri()->getQuery(); // foo=bar
Pieprasījuma virknes saturs tiks automātiski filtrēts, lai nodrošinātu, ka vaicājuma rindā ir tikai atļautās rakstzīmes. Jebkuras rakstzīmes, kas nav atļautas vaicājuma virknē, tiks procentuāli kodētas saskaņā ar RFC 3986 3.4. sadaļa.
Atbildes ir HTTP ziņojumi, ko klients saņem no servera pēc HTTP pieprasījuma ziņojuma nosūtīšanas.
Atbildes sākuma rindā ir norādīts protokols un protokola versija, statusa kods un iemesla frāze.
$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
Kā aprakstīts iepriekš, atbildes ķermeni var iegūt, izmantojot getBody() metodi.
$body = $response->getBody();
echo $body;
// Cast to a string: { ... }
$body->seek(0);
// Rewind the body
$body->read(1024);
// Read bytes of the body
Guzzle izmanto PSR-7 plūsmas objektus, lai attēlotu pieprasījuma un atbildes ziņojumu. korpusus. Šie plūsmas objekti ļauj strādāt ar dažādiem datu veidiem. izmantojot vienotu saskarni.
HTTP ziņojumus veido sākuma rinda, galvenes un saturs. HTTP var būt ļoti mazs vai ļoti liels. Mēģinājums atveidot tekstu ziņojumu kā virkni, var viegli patērēt vairāk atmiņas, nekā paredzēts, jo ķermenis pilnībā jāuzglabā atmiņā. Mēģinājums saglabāt ziņojuma ķermeni vai atbildes pieprasījumu vai atbildi atmiņā neļautu izmantot šo implementāciju no iespēju strādāt ar lieliem ziņojumu korpusiem. StreamInterface tiek izmantota lai paslēptu implementācijas detaļas par to, no kurienes tiek nolasīta datu plūsma. vai uz kuru tiek rakstīts.
PSR-7 Psr\Http\Message\StreamInterface piedāvā vairākas metodes, kas ļauj efektīvi lasīt, rakstīt un pārlūkot plūsmas.
Straumes savas iespējas atklāj, izmantojot trīs metodes: isReadable(),
isWritable() un isSeekable(). Šīs metodes var izmantot plūsmā
lai noteiktu, vai plūsma spēj izpildīt to prasības.
Katrai plūsmas instancei ir dažādas iespējas: tās var būt tikai lasāmās, tikai rakstīšanai, lasīšanai un rakstīšanai, ļaut patvaļīgu nejaušu piekļuvi (meklējot uz priekšu vai atpakaļ uz jebkuru atrašanās vietu) vai atļaut tikai secīgu piekļuvi (piem. ligzdas vai caurules gadījumā).
Guzzle izmanto guzzlehttp/psr7 paketi, lai nodrošinātu straumju atbalstu. Vairāk
informāciju par plūsmu lietošanu, plūsmu izveidi, plūsmu konvertēšanu uz PHP
plūsmu resursus un plūsmu dekoratorus var atrast sadaļā
Guzzle PSR-7 dokumentācijā.
Labākais veids, kā izveidot straumi, ir izmantot GuzzleHttp\Psr7\Utils::streamFor
metodi. Šī metode pieņem virknes, resursus, kas atgriežas no fopen(),
objektu, kas implementē __toString(), iteratorus, callables un instances.
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
No iteratoriem var izveidot plūsmas. Iterators var dot jebkuru skaitu baitu vienā iterācijā. Jebkurš liekais iteratora atdotais baits, kas nebija pieprasījis plūsmas patērētājs, tiks buferizēti līdz nākamajai lasīšanai.
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); // ...
Straumes atklāj plūsmas metadatus, izmantojot getMetadata() metodi. Šī
metode nodrošina datus, kurus jūs iegūtu, izsaucot PHP
stream_get_meta_data() funkciju,
un pēc izvēles var atklāt citus pielāgotus datus.
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
Izmantojot plūsmu dekoratorus, ir ļoti vienkārši pievienot plūsmām pielāgotu funkcionalitāti. Guzzle nodrošina vairākus iebūvētos dekoratorus, kas nodrošina papildu plūsmas funkcionalitāti.