¿Cómo clonar un InputStream?

Tengo un InputStream que paso a un método para hacer algún procesamiento. Usaré el mismo InputStream en otro método, pero después del primer procesamiento, el InputStream parece estar cerrado dentro del método.

¿Cómo puedo clonar el InputStream para enviarlo al método que lo cierra? ¿Hay otra solución?

EDITAR: los métodos que cierran InputStream es un método externo de una lib. No tengo control sobre el cierre o no.

private String getContent(HttpURLConnection con) {
    InputStream content = null;
    String charset = "";
    try {
        content = con.getInputStream();
        CloseShieldInputStream csContent = new CloseShieldInputStream(content);
        charset = getCharset(csContent);            
        return  IOUtils.toString(content,charset);
    } catch (Exception e) {
        System.out.println("Error downloading page: " + e);
        return null;
    }
}

private String getCharset(InputStream content) {
    try {
        Source parser = new Source(content);
        return parser.getEncoding();
    } catch (Exception e) {
        System.out.println("Error determining charset: " + e);
        return "UTF-8";
    }
}

Si todo lo que quiere hacer es leer la misma información más de una vez, y los datos de entrada son lo suficientemente pequeños como para caber en la memoria, puede copiar los datos desde su InputStreama un ByteArrayOutputStream .

Luego puede obtener la matriz de bytes asociada y abrir tantos ByteArrayInputStream "clonados" como desee.

ByteArrayOutputStream baos = new ByteArrayOutputStream();

// Fake code simulating the copy
// You can generally do better with nio if you need...
// And please, unlike me, do something about the Exceptions :D
byte[] buffer = new byte[1024];
int len;
while ((len = input.read(buffer)) > -1 ) {
    baos.write(buffer, 0, len);
}
baos.flush();

// Open new InputStreams using the recorded bytes
// Can be repeated as many times as you wish
InputStream is1 = new ByteArrayInputStream(baos.toByteArray()); 
InputStream is2 = new ByteArrayInputStream(baos.toByteArray()); 

Pero si realmente necesita mantener abierta la transmisión original para recibir nuevos datos, deberá realizar un seguimiento de este close()método externo y evitar que se llame de alguna manera.

ACTUALIZACIÓN (2019):

Desde Java 9, los bits medios se pueden reemplazar con InputStream.transferTo:

ByteArrayOutputStream baos = new ByteArrayOutputStream();
input.transferTo(baos);
InputStream firstClone = new ByteArrayInputStream(baos.toByteArray()); 
InputStream secondClone = new ByteArrayInputStream(baos.toByteArray()); 

Quieres usar Apache's CloseShieldInputStream :

Este es un contenedor que evitará que la secuencia se cierre. Harías algo como esto.

InputStream is = null;

is = getStream(); //obtain the stream 
CloseShieldInputStream csis = new CloseShieldInputStream(is);

// call the bad function that does things it shouldn't
badFunction(csis);

// happiness follows: do something with the original input stream
is.read();

No puede clonarlo, y cómo va a resolver su problema depende de cuál sea la fuente de los datos.

Una solución es leer todos los datos del InputStream en una matriz de bytes, y luego crear un ByteArrayInputStream alrededor de esa matriz de bytes, y pasar esa secuencia de entrada a su método.

Edición 1: es decir, si el otro método también necesita leer los mismos datos. Es decir, desea "restablecer" la transmisión.

Si los datos leídos de la transmisión son grandes, recomendaría usar un TeeInputStream de Apache Commons IO. De esa manera, esencialmente puede replicar la entrada y pasar una tubería t'd como su clon.

Esto podría no funcionar en todas las situaciones, pero esto es lo que hice: extendí la clase FilterInputStream y realicé el procesamiento requerido de los bytes a medida que la biblioteca externa lee los datos.

public class StreamBytesWithExtraProcessingInputStream extends FilterInputStream {

    protected StreamBytesWithExtraProcessingInputStream(InputStream in) {
        super(in);
    }

    @Override
    public int read() throws IOException {
        int readByte = super.read();
        processByte(readByte);
        return readByte;
    }

    @Override
    public int read(byte[] buffer, int offset, int count) throws IOException {
        int readBytes = super.read(buffer, offset, count);
        processBytes(buffer, offset, readBytes);
        return readBytes;
    }

    private void processBytes(byte[] buffer, int offset, int readBytes) {
       for (int i = 0; i < readBytes; i++) {
           processByte(buffer[i + offset]);
       }
    }

    private void processByte(int readByte) {
       // TODO do processing here
    }

}

Luego, simplemente pasa una instancia de StreamBytesWithExtraProcessingInputStreamdónde habría pasado en la secuencia de entrada. Con la secuencia de entrada original como parámetro constructor.

Cabe señalar que esto funciona byte por byte, así que no lo use si se requiere un alto rendimiento.

UPD Mira el comentario antes. No es exactamente lo que se le preguntó.

Si está utilizando apache.commons, puede copiar transmisiones utilizando IOUtils.

Puedes usar el siguiente código:

InputStream = IOUtils.toBufferedInputStream(toCopy);

Aquí está el ejemplo completo adecuado para su situación:

public void cloneStream() throws IOException{
    InputStream toCopy=IOUtils.toInputStream("aaa");
    InputStream dest= null;
    dest=IOUtils.toBufferedInputStream(toCopy);
    toCopy.close();
    String result = new String(IOUtils.toByteArray(dest));
    System.out.println(result);
}

Este código requiere algunas dependencias:

MAVEN

<dependency>
    <groupId>commons-io</groupId>
    <artifactId>commons-io</artifactId>
    <version>2.4</version>
</dependency>

GRADLE

'commons-io:commons-io:2.4'

Aquí está la referencia DOC para este método:

Obtiene todo el contenido de un InputStream y representa los mismos datos que el resultado InputStream. Este método es útil donde,

Source InputStream es lento. Tiene recursos de red asociados, por lo que no podemos mantenerlo abierto durante mucho tiempo. Tiene un tiempo de espera de red asociado.

Puede encontrar más información IOUtilsaquí: http://commons.apache.org/proper/commons-io/javadocs/api-2.4/org/apache/commons/io/IOUtils.html#toBufferedInputStream(java.io.InputStream)

A continuación se muestra la solución con Kotlin.

Puede copiar su InputStream en ByteArray

val inputStream = ...

val byteOutputStream = ByteArrayOutputStream()
inputStream.use { input ->
    byteOutputStream.use { output ->
        input.copyTo(output)
    }
}

val byteInputStream = ByteArrayInputStream(byteOutputStream.toByteArray())

Si necesita leer byteInputStreamvarias veces, llame byteInputStream.reset()antes de volver a leer.

https://code.luasoftware.com/tutorials/kotlin/how-to-clone-inputstream/

La siguiente clase debería hacer el truco. Simplemente cree una instancia, llame al método de "multiplicación" y proporcione el flujo de entrada de origen y la cantidad de duplicados que necesita.

Importante: debe consumir todas las secuencias clonadas simultáneamente en subprocesos separados.

package foo.bar;

import java.io.IOException;
import java.io.InputStream;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class InputStreamMultiplier {
    protected static final int BUFFER_SIZE = 1024;
    private ExecutorService executorService = Executors.newCachedThreadPool();

    public InputStream[] multiply(final InputStream source, int count) throws IOException {
        PipedInputStream[] ins = new PipedInputStream[count];
        final PipedOutputStream[] outs = new PipedOutputStream[count];

        for (int i = 0; i < count; i++)
        {
            ins[i] = new PipedInputStream();
            outs[i] = new PipedOutputStream(ins[i]);
        }

        executorService.execute(new Runnable() {
            public void run() {
                try {
                    copy(source, outs);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        });

        return ins;
    }

    protected void copy(final InputStream source, final PipedOutputStream[] outs) throws IOException {
        byte[] buffer = new byte[BUFFER_SIZE];
        int n = 0;
        try {
            while (-1 != (n = source.read(buffer))) {
                //write each chunk to all output streams
                for (PipedOutputStream out : outs) {
                    out.write(buffer, 0, n);
                }
            }
        } finally {
            //close all output streams
            for (PipedOutputStream out : outs) {
                try {
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

La clonación de una secuencia de entrada podría no ser una buena idea, ya que esto requiere un conocimiento profundo sobre los detalles de la secuencia de entrada que se está clonando. Una solución para esto es crear una nueva secuencia de entrada que lea de la misma fuente nuevamente.

Entonces, usando algunas características de Java 8, esto se vería así:

public class Foo {

    private Supplier<InputStream> inputStreamSupplier;

    public void bar() {
        procesDataThisWay(inputStreamSupplier.get());
        procesDataTheOtherWay(inputStreamSupplier.get());
    }

    private void procesDataThisWay(InputStream) {
        // ...
    }

    private void procesDataTheOtherWay(InputStream) {
        // ...
    }
}

Este método tiene el efecto positivo de que reutilizará el código que ya está en su lugar: la creación de la secuencia de entrada encapsulada en inputStreamSupplier . Y no es necesario mantener una segunda ruta de código para la clonación de la secuencia.

Por otro lado, si la lectura de la transmisión es costosa (porque se realiza a través de una conexión de bajo ancho de banda), entonces este método duplicará los costos. Esto podría evitarse utilizando un proveedor específico que almacenará el contenido de la secuencia localmente primero y proporcionará un InputStreamrecurso local para ese momento.