Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Flussi nell'AWS SDK for PHPVersione 3

Come parte della sua integrazione delPSR7standard per i messaggi HTTP,AWS SDK for PHPutilizza ilPSR7 StreamInterfaceinternamente mentre la sua astrazione è finitaflussi. Qualsiasi comando con un campo di input definito come un blob, ad esempioBodyparametro su un3:PutObject comando, può essere soddisfatto con una stringa, una risorsa di flusso PHP o un'istanza diPsr\Http\Message\StreamInterface.

Decoratori di flussi

Guzzle fornisce diversi decoratori di flussi che puoi utilizzare per controllare come l'SDK e Guzzle interagiscono con le risorse di streaming fornite come parametro di input a un comando. Questi decoratori possono modificare il modo in cui i gestori sono in grado di leggere e cercare su un determinato flusso. Di seguito è riportato un elenco parziale; ulteriori sono reperibili sulGuzzleHttpPsr7. Archivio 7.

AppendStream

GuzzleHttp\ Psr7\AppendStream

Le letture provenienti da più flussi, una dopo l'altra.

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\ Psr7\CachingStream

Utilizzato per consentire la ricerca sui byte precedentemente letti su flusso non ricercabili. Questo può essere utile quando il trasferimento di un corpo entità non ricercabile ha esito negativo a causa della necessità di riavvolgere il flusso (ad esempio, dopo un reindirizzamento). I dati che vengono letti dal flusso remoto sono eseguiti nel buffer in un flusso PHP temporaneo, in modo che i byte letti in precedenza vengano prima salvati nella cache in memoria, poi su disco.

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\ Psr7\InflateStream

Utilizza il filtro zlib.inflate di PHP per decomprimere o comprimere il contenuto gzipped.

Questo decoratore di flussi salta i primi 10 byte del flusso per eliminare l'intestazione gzip, converte il flusso fornito in una risorsa di flusso PHP, quindi aggiunge il filtro zlib.inflate. Il flusso viene poi riconvertito in una risorsa di flusso Guzzle per essere utilizzato come flusso Guzzle.

LazyOpenStream

GuzzleHttp\ Psr7\LazyOpenStream

Esegue lentamente operazioni di lettura e scrittura di un file che viene aperto solo dopo un'operazione di I/O sul flusso.

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\ Psr7\LimitStream

Utilizzato per leggere un sottoinsieme o una porzione di un oggetto di flusso esistente. Questo può essere utile per dividere un file di grandi dimensioni in parti più piccole da inviare in blocchi (ad esempio, l'API di caricamento in più parti di Amazon S3 in più parti di).

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\ Psr7\NoSeekStream

Racchiude un flusso e non consente di cercare.

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\ Psr7\PumpStream

Fornisce un flusso di sola lettura che pompa dati da un chiamabile PHP.

Quando si richiama il chiamabile fornito, PumpStream passa la quantità di dati richiesti per leggere il chiamabile. Il chiamabile può scegliere di ignorare questo valore e restituire un numero minore o più byte di quanto richiesto. Eventuali dati aggiuntivi restituiti dal chiamabile, vengono eseguiti in buffer internamente finché non finiscono utilizzando la funzione read () del PumpStream. Il chiamabile fornito DEVE restituire false quando non ci sono più dati da leggere.

L'implementazione di decoratori di flussi

Creare un decoratore di flussiGuzzleHttp\ Psr7\StreamDecoratorTrait. Questa caratteristica offre metodi che implementano Psr\Http\Message\StreamInterface con il proxy a un flusso sottostante. Basta use StreamDecoratorTrait e implementare i metodi personalizzati.

Supponiamo, ad esempio, che desideri chiamare una determinata funzione ogni volta che l'ultimo byte viene letto da un flusso. Questo potrebbe essere implementato sostituendo il metodo 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;
    }
}

Questo decoratore potrebbe essere aggiunto a qualsiasi flusso esistente e utilizzato in questo modo.

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!"