¿Cómo convierto un OutputStream en un InputStream?

Parece haber muchos enlaces y otras cosas similares, pero ningún código real que utilice tuberías. La ventaja de utilizar java.io.PipedInputStreamy java.io.PipedOutputStreames que no hay consumo adicional de memoria. ByteArrayOutputStream.toByteArray()devuelve una copia del búfer original, lo que significa que lo que sea que tengas en la memoria, ahora tienes dos copias. Luego, escribir en un InputStreamsignifica que ahora tiene tres copias de los datos.

El código que usa lambdas(sombrero para @John Manko de los comentarios):

PipedInputStream in = new PipedInputStream();
final PipedOutputStream out = new PipedOutputStream(in);
// in a background thread, write the given output stream to the
// PipedOutputStream for consumption
new Thread(() -> {originalOutputStream.writeTo(out);}).start();

Una cosa que @John Manko notó es que en ciertos casos, cuando no tienes control de la creación de OutputStream , puedes terminar en una situación en la que el creador puede limpiar el objeto OutputStream prematuramente. Si obtienes el ClosedPipeException, deberías intentar invertir los constructores:

PipedInputStream in = new PipedInputStream(out);
new Thread(() -> {originalOutputStream.writeTo(out);}).start();

Tenga en cuenta que también puede invertir los constructores de los ejemplos siguientes.

Gracias también a @AlexK por corregirme al iniciar un Threaden lugar de simplemente iniciar un Runnable.

El código usando try-with-resources:

// take the copy of the stream and re-write it to an InputStream
PipedInputStream in = new PipedInputStream();
    new Thread(new Runnable() {
        public void run () {
            // try-with-resources here
            // putting the try block outside the Thread will cause the
            // PipedOutputStream resource to close before the Runnable finishes
            try (final PipedOutputStream out = new PipedOutputStream(in)) {
                // write the original OutputStream to the PipedOutputStream
                // note that in order for the below method to work, you need
                // to ensure that the data has finished writing to the
                // ByteArrayOutputStream
                originalByteArrayOutputStream.writeTo(out);
            }
            catch (IOException e) {
                // logging and exception handling should go here
            }
        }
    }).start();

El código original que escribí:

// take the copy of the stream and re-write it to an InputStream
PipedInputStream in = new PipedInputStream();
final PipedOutputStream out = new PipedOutputStream(in);
new Thread(new Runnable() {
    public void run () {
        try {
            // write the original OutputStream to the PipedOutputStream
            // note that in order for the below method to work, you need
            // to ensure that the data has finished writing to the
            // ByteArrayOutputStream
            originalByteArrayOutputStream.writeTo(out);
        }
        catch (IOException e) {
            // logging and exception handling should go here
        }
        finally {
            // close the PipedOutputStream here because we're done writing data
            // once this thread has completed its run
            if (out != null) {
                // close the PipedOutputStream cleanly
                out.close();
            }
        }   
    }
}).start();

Este código supone que originalByteArrayOutputStream es un, ByteArrayOutputStreamya que suele ser el único flujo de salida utilizable, a menos que esté escribiendo en un archivo. Lo mejor de esto es que, dado que está en un hilo separado, también funciona en paralelo, por lo que cualquier cosa que consuma su flujo de entrada también saldrá de su antiguo flujo de salida. Esto es beneficioso porque el búfer puede permanecer más pequeño y tendrá menos latencia y menos uso de memoria.

Si no tiene un ByteArrayOutputStream, en lugar de usarlo writeTo(), tendrá que usar uno de los write()métodos de la java.io.OutputStreamclase o uno de los otros métodos disponibles en una subclase.

May 26 '2014 16:05 mikeho