Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

Transmisiones en la AWS SDK para PHP versión 3

Como parte de su integración del estándar de mensajes HTTP PSR-7, AWS SDK para PHP utiliza el PSR-7 StreamInterface internamente como su abstracción sobre los flujos de PHP. Cualquier comando con un campo de entrada definido como un blob, como el Body parámetro de un PutObject comando S3::, puede satisfacerse con una cadena, un recurso de flujo de PHP o una instancia de. Psr\Http\Message\StreamInterface

Decoradores de flujo

Guzzle proporciona varios decoradores de flujo que puede utilizar para controlar la forma en que el SDK y Guzzle interactúan con el recurso de flujo suministrado como parámetro de entrada a un comando. Estos decoradores pueden modificar la forma en que los controladores leen y buscan un flujo determinado. La siguiente es una lista parcial; puede encontrar más información en el repositorio GuzzleHttpPsr 7.

AppendStream

GuzzleHttp\ Psr7\ AppendStream

Lee varios flujos, uno detrás del otro.

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

Se utiliza para permitir la búsqueda de bytes leídos previamente en flujos no rastreables. Esto puede resultar útil cuando la transferencia de un cuerpo de entidad no rastreable falla debido a la necesidad de rebobinar el flujo (por ejemplo, debido a un redireccionamiento). Los datos que se leen en el flujo remoto se almacenan en búfer en un flujo temporal de PHP, de modo que los bytes leídos previamente se almacenan primero en caché en la memoria y luego en el 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

Utiliza el filtro zlib.inflate de PHP para inflar o desinflar contenido comprimido en un zip.

Este decorador de flujos omite los primeros 10 bytes del flujo dado para eliminar el encabezado gzip, convierte el flujo proporcionado en un recurso de flujo de PHP y, a continuación, añade el filtro zlib.inflate. El flujo se vuelve a convertir en un recurso de flujo de Guzzle que se va a utilizar como flujo de Guzzle.

LazyOpenStream

GuzzleHttp\ Psr7\ LazyOpenStream

Lee o escribe lentamente en un archivo que se abre después de que se produzca una operación de E/S en el flujo.

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

Se utiliza para leer un subconjunto o sector de un objeto de flujo existente. Esto puede resultar útil para dividir un archivo de gran tamaño en partes más pequeñas que se envían en fragmentos (por ejemplo, la API de carga multiparte de 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\ Psr7\ NoSeekStream

Encapsula un flujo y no permite que se encuentre.

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

Proporciona un flujo de solo lectura que bombea datos desde una función invocable de PHP.

Al invocar el invocable proporcionado, PumpStream pasa la cantidad de datos que se solicita leer al invocable. La función invocable puede elegir omitir este valor y devolver más o menos bytes de los solicitados. Cualquier dato adicional devuelto por el invocable proporcionado se almacena internamente hasta que se agota mediante la función read () del. PumpStream La función invocable proporcionada DEBE devolver el valor false cuando ya no queden datos por leer.

Implementar decoradores de flujo

Crear un decorador de flujos es muy fácil gracias al\ Psr7\. GuzzleHttp StreamDecoratorTrait Esta característica proporciona métodos que implementan Psr\Http\Message\StreamInterface al conectar mediante proxy con un flujo subyacente. Simplemente use la característica StreamDecoratorTrait e implemente sus métodos personalizados.

Por ejemplo, supongamos que quiere llamar a una función específica cada vez que se lea el último byte de un flujo. Esto podría implementarse anulando el método 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;
    }
}

Este decorador se podría agregar a cualquier flujo existente y utilizarse del siguiente 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!"