¿Cómo convierto un OutputStream en un InputStream?

Estoy en la etapa de desarrollo donde tengo dos módulos y de uno obtuve salida como OutputStreamy una segunda que acepta sólo InputStream.

¿Sabes cómo convertir OutputStream a InputStream (no al revés, quiero decir realmente de esta manera) para poder conectar estas dos partes?

Parece que hay muchos enlaces y otras cosas similares, pero no hay código real que use tuberías. La ventaja de usar java.io.PipedInputStream y java.io.PipedOutputStream es que no hay consumo adicional de memoria. ByteArrayOutputStream.toByteArray() devuelve una copia del búfer original, lo que significa que lo que sea que tenga en la memoria, ahora tiene dos copias. Luego, escribiendo a un InputStream significa que ahora tiene tres copias de los datos.

El código usando lambdas (punta de sombrero a @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 notó @John Manko es que en ciertos casos, cuando no tienes el control de la creación del Flujo de salidapuede terminar en una situación en la que el creador puede limpiar el Flujo de salida objeto de forma prematura. Si está obteniendo el ClosedPipeExceptionentonces 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 para los ejemplos a continuación.

Gracias también a @AlexK por corregirme al comenzar un Thread en lugar de simplemente iniciar una 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 asume que el originalByteArrayOutputStream es un ByteArrayOutputStream ya 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 lo que sea que esté consumiendo su flujo de entrada también se transmitirá desde su antiguo flujo de salida. Eso es beneficioso porque el búfer puede permanecer más pequeño y tendrá menos latencia y menos uso de memoria.

Si no tienes un ByteArrayOutputStreamentonces en lugar de usar writeTo()tendrás que usar uno de los write() métodos en el java.io.OutputStream clase o uno de los otros métodos disponibles en una subclase.

Un OutputStream es uno donde escribes datos. Si algún módulo expone un OutputStreamla expectativa es que haya algo leyendo en el otro extremo.

Algo que expone un InputStreampor otro lado, indica que necesitará escuchar esta transmisión y habrá datos que podrá leer.

Entonces es posible conectar un InputStream a una OutputStream

InputStream----read---> intermediateBytes[n] ----write----> OutputStream

Como alguien mencionó, esto es lo que el copy() método de IOUtils te permite hacer No tiene sentido ir por el otro lado… ojalá esto tenga algún sentido

ACTUALIZAR:

Por supuesto, cuanto más pienso en esto, más puedo ver cómo esto realmente sería un requisito. Conozco algunos de los comentarios mencionados. Piped flujos de entrada/salida, pero hay otra posibilidad.

Si el flujo de salida que está expuesto es un ByteArrayOutputStreamsiempre puede obtener el contenido completo llamando al toByteArray() método. Luego puede crear un contenedor de flujo de entrada usando el ByteArrayInputStream subclase. Estos dos son pseudo flujos, ambos básicamente envuelven una matriz de bytes. Usar los flujos de esta manera, por lo tanto, es técnicamente posible, pero para mí sigue siendo muy extraño…

Como los flujos de entrada y salida son solo un punto de inicio y final, la solución es almacenar datos temporalmente en una matriz de bytes. Por lo que debe crear intermedio ByteArrayOutputStreama partir del cual creas byte[] que se utiliza como entrada para nuevos ByteArrayInputStream.

public void doTwoThingsWithStream(InputStream inStream, OutputStream outStream){ 
  //create temporary bayte array output stream
  ByteArrayOutputStream baos = new ByteArrayOutputStream();
  doFirstThing(inStream, baos);
  //create input stream from baos
  InputStream isFromFirstData = new ByteArrayInputStream(baos.toByteArray()); 
  doSecondThing(isFromFirstData, outStream);
}

Espero eso ayude.

ByteArrayOutputStream buffer = (ByteArrayOutputStream) aOutputStream;
byte[] bytes = buffer.toByteArray();
InputStream inputStream = new ByteArrayInputStream(bytes);

Necesitará una clase intermedia que actuará como búfer. Cada vez InputStream.read(byte[]...) se llama, la clase de almacenamiento en búfer llenará la matriz de bytes pasada con el siguiente fragmento pasado desde OutputStream.write(byte[]...). Dado que los tamaños de los fragmentos pueden no ser los mismos, la clase de adaptador deberá almacenar una cierta cantidad hasta que tenga suficiente para llenar el búfer de lectura y/o poder almacenar cualquier desbordamiento del búfer.

Este artículo tiene un buen desglose de algunos enfoques diferentes para este problema:

http://blog.ostermiller.org/convert-java-outputstream-inputstream

El corriente fácil La biblioteca de código abierto tiene soporte directo para convertir un OutputStream en un InputStream: http://io-tools.sourceforge.net/easystream/tutorial/tutorial.html

// create conversion
final OutputStreamToInputStream<Void> out = new OutputStreamToInputStream<Void>() {
    @Override
    protected Void doRead(final InputStream in) throws Exception {
           LibraryClass2.processDataFromInputStream(in);
           return null;
        }
    };
try {   
     LibraryClass1.writeDataToTheOutputStream(out);
} finally {
     // don't miss the close (or a thread would not terminate correctly).
     out.close();
}

También enumeran otras opciones: http://io-tools.sourceforge.net/easystream/outputstream_to_inputstream/implementations.html

• Escriba los datos en un búfer de memoria (ByteArrayOutputStream), obtenga el byteArray y léalo nuevamente con un ByteArrayInputStream. Este es el mejor enfoque si está seguro de que sus datos caben en la memoria.
• Copie sus datos en un archivo temporal y vuelva a leerlos.
• Use pipes: este es el mejor enfoque tanto para el uso de la memoria como para la velocidad (puede aprovechar al máximo los procesadores multinúcleo) y también la solución estándar que ofrece Sun.
• Utilice InputStreamFromOutputStream y OutputStreamToInputStream de la biblioteca easystream.

Encontré el mismo problema al convertir un ByteArrayOutputStream a un ByteArrayInputStream y lo resolvió usando una clase derivada de ByteArrayOutputStream que es capaz de devolver un ByteArrayInputStream que se inicializa con el búfer interno del ByteArrayOutputStream. De esta forma no se usa memoria adicional y la ‘conversión’ es muy rápida:

package info.whitebyte.utils;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;

/**
 * This class extends the ByteArrayOutputStream by 
 * providing a method that returns a new ByteArrayInputStream
 * which uses the internal byte array buffer. This buffer
 * is not copied, so no additional memory is used. After
 * creating the ByteArrayInputStream the instance of the
 * ByteArrayInOutStream can not be used anymore.
 * <p>
 * The ByteArrayInputStream can be retrieved using <code>getInputStream()</code>.
 * @author Nick Russler
 */
public class ByteArrayInOutStream extends ByteArrayOutputStream {
    /**
     * Creates a new ByteArrayInOutStream. The buffer capacity is
     * initially 32 bytes, though its size increases if necessary.
     */
    public ByteArrayInOutStream() {
        super();
    }

    /**
     * Creates a new ByteArrayInOutStream, with a buffer capacity of
     * the specified size, in bytes.
     *
     * @param   size   the initial size.
     * @exception  IllegalArgumentException if size is negative.
     */
    public ByteArrayInOutStream(int size) {
        super(size);
    }

    /**
     * Creates a new ByteArrayInputStream that uses the internal byte array buffer 
     * of this ByteArrayInOutStream instance as its buffer array. The initial value 
     * of pos is set to zero and the initial value of count is the number of bytes 
     * that can be read from the byte array. The buffer array is not copied. This 
     * instance of ByteArrayInOutStream can not be used anymore after calling this
     * method.
     * @return the ByteArrayInputStream instance
     */
    public ByteArrayInputStream getInputStream() {
        // create new ByteArrayInputStream that respects the current count
        ByteArrayInputStream in = new ByteArrayInputStream(this.buf, 0, this.count);

        // set the buffer of the ByteArrayOutputStream 
        // to null so it can't be altered anymore
        this.buf = null;

        return in;
    }
}

Puse las cosas en github: https://github.com/nickrussler/ByteArrayInOutStream