Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Flux dans le kitAWS SDK for PHPVersion 3

Dans le cadre de son intégration duSRP 7norme de message HTTP, laAWS SDK for PHPutilise leSRP 7 StreamInterfaceen interne comme son abstraction terminéeflux PHP. Toute commande dont le champ de saisie est défini comme un blob, tel queBodyparamètre sur unS3 :PutObject commande, peut être satisfaite avec une chaîne, une ressource de flux PHP ou une instance dePsr\Http\Message\StreamInterface.

Décorateurs de flux

Guzzle fournit plusieurs décorateurs de flux que vous pouvez utiliser pour contrôler la façon dont le kit SDK et Guzzle interagissent avec la ressource de streaming fournie en tant que paramètre d'entrée à une commande. Ces décorateurs peuvent modifier la façon dont les gestionnaires sont en mesure de lire et de rechercher sur un flux donné. Ce qui suit est une liste partielle ; vous trouverez plus d'informations sur leGuzzleHttpPsr7 référentiel.

AppendStream

GuzzleHttp\ Psrp \AppendStream

Lectures à partir de plusieurs flux, l'un après l'autre.

use GuzzleHttp\Psr7;

$a = Psr7\stream_for('abc, ');
$b = Psr7\stream_for('123.');
$composed = new Psr7\AppendStream([$a, $b]);

$composed->addStream(Psr7\stream_for(' Above all listen to me'));

echo $composed(); // abc, 123. Above all listen to me.

CachingStream

GuzzleHttp\ Psrp \CachingStream

Utilisé pour autoriser la recherche sur les octets précédemment lus ou sur les flux qui ne peuvent pas être recherchés. Cela peut être utile lorsque le transfert d'un corps d'entité ne pouvant être recherché échoue en raison du besoin de revenir en arrière dans le flux (par exemple, suite à une redirection). Les données qui sont lues à partir du flux distant sont mises en mémoire tampon dans un flux temporaire PHP afin de mettre en cache les octets précédemment lus dans la mémoire, puis sur le disque.

use GuzzleHttp\Psr7;

$original = Psr7\stream_for(fopen('http://www.google.com', 'r'));
$stream = new Psr7\CachingStream($original);

$stream->read(1024);
echo $stream->tell();
// 1024

$stream->seek(0);
echo $stream->tell();
// 0

InflateStream

GuzzleHttp\ Psrp \InflateStream

Utilise le filtre PHP zlib.inflate pour gonfler ou dégonfler du contenu compressé avec gzip.

Ce décorateur de flux ignore les 10 premiers octets du flux donné pour supprimer l'en-tête gzip, convertit le flux fourni en ressource de flux PHP, et ajoute ensuite le filtre zlib.inflate. Le flux est ensuite converti en ressource de flux Guzzle pour être utilisé comme flux Guzzle.

LazyOpenStream

GuzzleHttp\ Psrp \LazyOpenStream

Lit ou écrit lentement dans un fichier qui est ouvert uniquement après qu'une opération d'I/O est effectuée dans le flux.

use GuzzleHttp\Psr7;

$stream = new Psr7\LazyOpenStream('/path/to/file', 'r');
// The file has not yet been opened...

echo $stream->read(10);
// The file is opened and read from only when needed.

LimitStream

GuzzleHttp\ Psrp \LimitStream

Permet de lire un sous-ensemble ou une tranche d'un objet de flux existant. Cela peut être utile pour casser un fichier volumineux en parties plus petites pour être envoyées sous forme de fragments (par exemple, l'API de chargement partitionné Amazon S3).

use GuzzleHttp\Psr7;

$original = Psr7\stream_for(fopen('/tmp/test.txt', 'r+'));
echo $original->getSize();
// >>> 1048576

// Limit the size of the body to 1024 bytes and start reading from byte 2048
$stream = new Psr7\LimitStream($original, 1024, 2048);
echo $stream->getSize();
// >>> 1024
echo $stream->tell();
// >>> 0

NoSeekStream

GuzzleHttp\ Psrp \NoSeekStream

Encapsule un flux et n'autorise pas la recherche.

use GuzzleHttp\Psr7;

$original = Psr7\stream_for('foo');
$noSeek = new Psr7\NoSeekStream($original);

echo $noSeek->read(3);
// foo
var_export($noSeek->isSeekable());
// false
$noSeek->seek(0);
var_export($noSeek->read(3));
// NULL

PumpStream

GuzzleHttp\ Psrp \PumpStream

Fournit un flux en lecture seule qui pompe des données depuis une fonction PHP callable.

Lorsque vous invoquez l'appelable fourni, le PumpStream passe le volume de données demandé pour lire le callable. Le callable peut choisir de ne pas tenir compte de cette valeur et de renvoyer plus ou moins d'octets que demandé. Toute donnée supplémentaire renvoyée par le callable fourni est mise en mémoire tampon en interne jusqu'à être drainée à l'aide de la fonction read () de PumpStream. Le callable fourni DOIT renvoyer faux lorsqu'il n'y a pas d'autres données à lire.

Implémentation des décorateurs

Créer un décorateur de flux est très facile grâce àGuzzleHttp\ Psrp \StreamDecoratorTrait. Cette caractéristique fournit des méthodes qui implémentent Psr\Http\Message\StreamInterface en redirigeant vers un flux sous-jacent. use simplement le StreamDecoratorTrait et implémentez vos méthodes personnalisées.

Par exemple, supposons que nous voulions appeler une fonction particulière chaque fois que le dernier octet d'un flux est lu. Ceci peut être implémenté en remplaçant la méthode read().

use Psr\Http\Message\StreamInterface;
use GuzzleHttp\Psr7\StreamDecoratorTrait;

class EofCallbackStream implements StreamInterface
{
    use StreamDecoratorTrait;

    private $callback;

    public function __construct(StreamInterface $stream, callable $cb)
    {
        $this->stream = $stream;
        $this->callback = $cb;
    }

    public function read($length)
    {
        $result = $this->stream->read($length);

        // Invoke the callback when EOF is hit
        if ($this->eof()) {
            call_user_func($this->callback);
        }

        return $result;
    }
}

Ce décorateur pourrait être ajouté à n'importe quel flux existant et utilisé comme ceci.

use GuzzleHttp\Psr7;

$original = Psr7\stream_for('foo');

$eofStream = new EofCallbackStream($original, function () {
    echo 'EOF!';
});

$eofStream->read(2);
$eofStream->read(1);
// echoes "EOF!"
$eofStream->seek(0);
$eofStream->read(3);
// echoes "EOF!"