Cómo clonar un InputStream?

Question

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 aparece 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 el InputStream son 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"; 
    } 
} 

Answer 1

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

A continuación, puede obtener la matriz asociada de bytes y abrir tantos "clonados" ByteArrayInputStream 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 se necesita para mantener el flujo original abierta para recibir nuevos datos, a continuación, tendrá que realizar un seguimiento de este método externo close() y evitar que sea llamado de alguna manera.

Answer 2

No se puede clonar, y la forma en que se va a resolver el problema depende de la fuente de los datos.

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

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

Answer 3

que desea utilizar Apache de CloseShieldInputStream:

Este es un envoltorio que impida el flujo de cerrarse. 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(); 

Answer 4

Si los datos leídos de la secuencia son grandes, recomendaría usar un TeeInputStream de Apache Commons IO. De esta forma, puedes replicar esencialmente la entrada y pasar un t'd pipe como tu clon.

Answer 5

Esto podría no funcionar en todas las situaciones, pero esto es lo que hice: amplié la clase FilterInputStream y realicé el procesamiento requerido de los bytes cuando la lib 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 
    } 

} 

Entonces sólo tiene que pasar una instancia de StreamBytesWithExtraProcessingInputStream donde habría pasado en el flujo de entrada. Con el flujo de entrada original como parámetro de constructor.

Cabe señalar que esto funciona byte para byte, por lo tanto, no lo use si el alto rendimiento es un requisito.

Answer 6

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

Importante: debe consumir todas las secuencias clonadas simultáneamente en hilos 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(); 
       } 
      } 
     } 
    } 
} 

Answer 7

Si está utilizando apache.commons puede copiar corrientes usando IOUtils.

Puede utilizar 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í es la referencia DOC para este método:

Obtiene totalidad del contenido de un InputStream y representan mismos datos que 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 tiempo de espera de red asociado.

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

Answer 8

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

Así, utilizando algunos de Java 8 Características Este sería el siguiente:

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 que va a reutilizar el código que ya está en su lugar - la creación del flujo de entrada encapsulado en inputStreamSupplier. Y no hay necesidad de mantener una segunda ruta de código para la clonación de la secuencia.

Por otro lado, si la lectura de la secuencia es costosa (porque a se hace en una conexión de bajo ancho de banda), este método duplicará los costos. Esto podría evitarse mediante el uso de un proveedor específico que almacenará el contenido de la cadena localmente primero y proporcionará un InputStream para ese recurso ahora local.