Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Streams in derAWS SDK for PHPVersion 3

Im Rahmen seiner Integration der\ PSR7\HTTP-Nachrichtenstandard, derAWS SDK for PHPverwendet die\ PSR7\ StreamInterfaceintern wie seine Abstraktion vorbeiPHP-Streams. Jeder Befehl mit einem als Blob definierten Eingabefeld, z. B.Body-Parameter auf einerS3::PutObject beherrschen, kann mit einer Zeichenfolge, einer PHP-Stream-Ressource oder einer Instance vonPsr\Http\Message\StreamInterface.

Stream-Decorators

Guzzle bietet mehrere Stream-Decoratoren, mit denen Sie steuern können, wie das SDK und Guzzle mit der Streaming-Ressource interagieren, die als Eingabeparameter für einen Befehl bereitgestellt wird. Diese Decoratoren können verändern, wie Handler in einem bestimmten Stream lesen und suchen können. Im Folgenden sehen Sie eine unvollständige Liste, mehr finden Sie auf derGuzzleHttpPsr7\.

AppendStream

GuzzleHttp\ Psr7\ Psr7AppendStream

Lesen aus mehreren Streams nacheinander.

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\ Psr7CachingStream

Wird verwendet, um die Suche nach zuvor gelesenen Bytes in nicht durchsuchbaren Streams zu ermöglichen. Dies kann nützlich sein, wenn die Übertragung eines nicht durchsuchbaren Entity-Rumpfs fehlschlägt, weil der Stream auf den Anfang zurückgesetzt werden muss (z. B. aufgrund einer Weiterleitung). Daten, die aus dem Remote-Stream gelesen werden, werden in einem temporären PHP-Stream gepuffert, sodass zuvor gelesene Bytes zuerst im Speicher und dann auf der Festplatte zwischengespeichert werden.

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\ Psr7InflateStream

Verwendet den zlib.inflate-Filter von PHP zum Erweitern oder Komprimieren von gezippten Inhalten.

Dieser Stream-Decorator überspringt die ersten 10 Bytes des vorgegebenen Streams, um den gzip-Header zu entfernen, wandelt den Stream in eine PHP-Stream-Ressource um und fügt ihn dann dem zlib.inflate-Filter hinzu. Der Stream wird dann wieder in eine Guzzle-Stream-Ressource umgewandelt, die als Guzzle-Stream verwendet werden kann.

LazyOpenStream

GuzzleHttp\ Psr7\ Psr7LazyOpenStream

Liest eine Datei langsam, die erst nach einer I/O-Operation auf dem Stream geöffnet wird, bzw. schreibt in diese.

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\ Psr7LimitStream

Wird verwendet, um eine Teilmenge oder ein Segment eines vorhandenen Stream-Objekts lesen. Dies kann nützlich sein, um eine große Datei in kleinere Teile zu zerlegen, die in Blöcken gesendet werden (z. B. die Amazon S3 Multipart Upload API).

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\ Psr7NoSeekStream

Verpackt einen Stream und lässt keine Suche zu.

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\ Psr7PumpStream

Stellt einen schreibgeschützten Datenstream bereit, der Daten aus einer aufrufbaren PHP-Funktion pumpt.

Wenn das bereitgestellte Callable aufgerufen wird, PumpStream gibt die zum Lesen angeforderte Datenmenge an die aufrufbare Funktion weiter. Der aufrufbare Funktion kann diesen Wert ignorieren und weniger oder mehr Bytes als gewünscht zurückgeben. Alle zusätzlichen Daten, die von der angegebenen aufrufbaren Funktion zurückgegeben werden, werden intern gepuffert, bis sie mit der read () -Funktion der PumpStream. Die bereitgestellte aufrufbare Funktion MUSS false zurückgegeben, wenn es keine weiteren Daten zu lesen gibt.

Stream-Decorators

Das Erstellen eines Stream-Decorators ist mit derGuzzleHttp\ Psr7\ Psr7StreamDecoratorTrait. Dieses Trait bietet Methoden, die Psr\Http\Message\StreamInterface implementieren, indem sie sich als Proxy für einen zugrundeliegenden Stream verhalten. Sie verwenden den use einfach mit StreamDecoratorTrait und implementieren Ihre benutzerdefinierten Methoden.

Angenommen, wir wollten jedes Mal eine bestimmte Funktion aufrufen, wenn das letzte Byte aus einem Stream gelesen wurde. Dies könnte durch Überschreiben der read()-Methode implementiert werden.

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;
    }
}

Dieser Decorator könnte in jedem vorhandenen Stream hinzugefügt und wie dieser verwendet werden.

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