Il modo più efficiente per creare InputStream da OutputStream

Question

Questa pagina: http://blog.ostermiller.org/convert-java-outputstream -inputstream descrive come creare un InputStream da OutputStream:

new ByteArrayInputStream(out.toByteArray())

Altre alternative sono usare PipedStreams e nuovi thread che sono ingombranti.

Non mi piace l'idea di copiare molti megabyte in nuovi array di byte di memoria. Esiste una libreria che lo fa in modo più efficiente?

EDIT:

Su consiglio di Laurence Gonsalves, ho provato PipedStreams e ho scoperto che non sono così difficili da affrontare. Ecco il codice di esempio in clojure:

(defn #^PipedInputStream create-pdf-stream [pdf-info]
  (let [in-stream (new PipedInputStream)
        out-stream (PipedOutputStream. in-stream)]
    (.start (Thread. #(;Here you write into out-stream)))
    in-stream))

Answer 1

Se non si desidera copiare contemporaneamente tutti i dati in un buffer in memoria, sarà necessario disporre del codice che utilizza OutputStream (il produttore) e il codice che utilizza InputStream (il consumatore) si alternano nello stesso thread o operano contemporaneamente in due thread separati. Il fatto che funzionino nello stesso thread è probabilmente molto più complicato del fatto che l'utilizzo di due thread separati, è molto più soggetto a errori (dovrai assicurarti che il consumatore non mai blocchi in attesa di input, oppure tu ' si bloccherà efficacemente) e richiederebbe che il produttore e il consumatore funzionino nello stesso circuito, che sembra accoppiato in modo troppo stretto.

Quindi usa un secondo thread. Non è poi così complicato. La pagina a cui hai effettuato il collegamento ha avuto un esempio perfetto:

  PipedInputStream in = new PipedInputStream();
  PipedOutputStream out = new PipedOutputStream(in);
  new Thread(
    new Runnable(){
      public void run(){
        class1.putDataOnOutputStream(out);
      }
    }
  ).start();
  class2.processDataFromInputStream(in);

Answer 2

Esiste un'altra libreria Open Source chiamata EasyStream che tratta tubi e fili in modo trasparente. Non è molto complicato se tutto va bene. I problemi sorgono quando (guardando l'esempio di Laurence Gonsalves)

  

class1.putDataOnOutputStream (out);

Genera un'eccezione. In questo esempio il thread si completa semplicemente e l'eccezione viene persa, mentre il InputStream esterno potrebbe essere troncato.

Easystream si occupa della propagazione delle eccezioni e di altri fastidiosi problemi di debug da circa un anno. (Sono il manutentore della biblioteca: ovviamente la mia soluzione è la migliore;)) Ecco un esempio su come usarlo:

final InputStreamFromOutputStream<String> isos = new InputStreamFromOutputStream<String>(){
 @Override
 public String produce(final OutputStream dataSink) throws Exception {
   /*
    * call your application function who produces the data here
    * WARNING: we're in another thread here, so this method shouldn't 
    * write any class field or make assumptions on the state of the outer class. 
    */
   return produceMydata(dataSink)
 }
};

C'è anche una bella introduzione in cui tutti gli altri modi per convertire un OutputStream in un InputStream sono spiegati. Vale la pena dare un'occhiata.

Answer 3

Una soluzione semplice che evita di copiare il buffer è quella di creare un ByteArrayOutputStream per scopi speciali:

public class CopyStream extends ByteArrayOutputStream {
    public CopyStream(int size) { super(size); }

    /**
     * Get an input stream based on the contents of this output stream.
     * Do not use the output stream after calling this method.
     * @return an {@link InputStream}
     */
    public InputStream toInputStream() {
        return new ByteArrayInputStream(this.buf, 0, this.count);
    }
}

Scrivere nello stream di output sopra come necessario, quindi chiamare toInputStream per ottenere un flusso di input sul buffer sottostante. Considera il flusso di output come chiuso dopo quel punto.

Answer 4

Penso che il modo migliore per connettere InputStream a un OutputStream sia attraverso stream convogliati - disponibile nel pacchetto java.io, come segue:

// 1- Define stream buffer
private static final int PIPE_BUFFER = 2048;

// 2 -Create PipedInputStream with the buffer
public PipedInputStream inPipe = new PipedInputStream(PIPE_BUFFER);

// 3 -Create PipedOutputStream and bound it to the PipedInputStream object
public PipedOutputStream outPipe = new PipedOutputStream(inPipe);

// 4- PipedOutputStream is an OutputStream, So you can write data to it
// in any way suitable to your data. for example:
while (Condition) {
     outPipe.write(mByte);
}

/*Congratulations:D. Step 4 will write data to the PipedOutputStream
which is bound to the PipedInputStream so after filling the buffer
this data is available in the inPipe Object. Start reading it to
clear the buffer to be filled again by the PipedInputStream object.*/

Secondo me ci sono due vantaggi principali per questo codice:

1 - Non vi è alcun consumo aggiuntivo di memoria ad eccezione del buffer.

2 - Non è necessario gestire manualmente l'accodamento dei dati

Answer 5

Di solito cerco di evitare di creare un thread separato a causa della maggiore possibilità di deadlock, della maggiore difficoltà di comprensione del codice e dei problemi di gestione delle eccezioni.

Ecco la mia soluzione proposta: un ProducerInputStream che crea contenuto in blocchi mediante ripetute chiamate a produceChunk ():

public abstract class ProducerInputStream extends InputStream {

    private ByteArrayInputStream bin = new ByteArrayInputStream(new byte[0]);
    private ByteArrayOutputStream bout = new ByteArrayOutputStream();

    @Override
    public int read() throws IOException {
        int result = bin.read();
        while ((result == -1) && newChunk()) {
            result = bin.read();
        }
        return result;
    }

    @Override
    public int read(byte[] b, int off, int len) throws IOException {
        int result = bin.read(b, off, len);
        while ((result == -1) && newChunk()) {
            result = bin.read(b, off, len);
        }
        return result;
    }

    private boolean newChunk() {
        bout.reset();
        produceChunk(bout);
        bin = new ByteArrayInputStream(bout.toByteArray());
        return (bout.size() > 0);
    }

    public abstract void produceChunk(OutputStream out);

}