Jak sklonować InputStream?

Mam InputStream, który przekazuję do metody, aby wykonać pewne przetwarzanie. Użyję tego samego InputStream w innej metodzie, ale po pierwszym przetworzeniu InputStream wydaje się być zamknięty wewnątrz metody.

Jak mogę sklonować InputStream, aby wysłać go do metody, która go zamyka? Czy jest inne rozwiązanie?

EDYCJA: metody, które zamykają InputStream to metoda zewnętrzna z biblioteki. Nie mam kontroli nad zamykaniem, czy nie.

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";
    }
}

Jeśli wszystko, co chcesz zrobić, to przeczytać te same informacje więcej niż raz, a dane wejściowe są wystarczająco małe, aby zmieścić się w pamięci, możesz skopiować dane ze swojego InputStreamdo ByteArrayOutputStream .

Następnie możesz uzyskać powiązaną tablicę bajtów i otworzyć tyle „sklonowanych” ByteArrayInputStream, ile chcesz.

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()); 

Ale jeśli naprawdę chcesz pozostawić oryginalny strumień otwarty, aby otrzymywać nowe dane, będziesz musiał śledzić ten zewnętrzny close() metodę i w jakiś sposób zapobiec jej wywołaniu.

AKTUALIZACJA (2019):

Od wersji Java 9 środkowe bity można zastąpić InputStream.transferTo:

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

Chcesz użyć Apache CloseShieldInputStream:

To jest opakowanie, które zapobiegnie zamknięciu strumienia. Zrobiłbyś coś takiego.

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();

Nie możesz go sklonować, a sposób rozwiązania problemu zależy od źródła danych.

Jednym z rozwiązań jest odczytanie wszystkich danych z InputStream do tablicy bajtów, a następnie utworzenie ByteArrayInputStream wokół tej tablicy bajtów i przekazanie tego strumienia wejściowego do metody.

Edycja 1: to znaczy, jeśli druga metoda również musi odczytać te same dane. To znaczy chcesz „zresetować” strumień.

Jeśli dane odczytane ze strumienia są duże, polecam użycie TeeInputStream z Apache Commons IO. W ten sposób możesz zasadniczo powielić dane wejściowe i przekazać potok t'd jako klon.

To może nie działać we wszystkich sytuacjach, ale oto, co zrobiłem: rozszerzyłem klasę FilterInputStream i wykonałem wymagane przetwarzanie bajtów, gdy zewnętrzna biblioteka odczytuje dane.

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
    }

}

Następnie po prostu przekazujesz wystąpienie miejsca, w StreamBytesWithExtraProcessingInputStreamktórym przeszedłbyś w strumieniu wejściowym. Z oryginalnym strumieniem wejściowym jako parametrem konstruktora.

Należy zauważyć, że działa to bajt po bajcie, więc nie używaj tego, jeśli wymagana jest wysoka wydajność.

UPD. Sprawdź komentarz wcześniej. To nie jest dokładnie to, o co pytano.

Jeśli używasz apache.commons, możesz kopiować strumienie za pomocąIOUtils .

Możesz użyć następującego kodu:

InputStream = IOUtils.toBufferedInputStream(toCopy);

Oto pełny przykład odpowiedni dla Twojej sytuacji:

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);
}

Ten kod wymaga pewnych zależności:

MAVEN

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

GRADLE

'commons-io:commons-io:2.4'

Oto odniesienie DOC dla tej metody:

Pobiera całą zawartość InputStream i reprezentuje te same dane co wynik InputStream. Ta metoda jest przydatna, gdy

Źródłowy strumień wejściowy jest wolny. Ma powiązane zasoby sieciowe, więc nie możemy go długo otwierać. Ma powiązany limit czasu sieci.

Więcej na ten temat można znaleźć IOUtilstutaj: http://commons.apache.org/proper/commons-io/javadocs/api-2.4/org/apache/commons/io/IOUtils.html#toBufferedInputStream(java.io.InputStream)

Poniżej znajduje się rozwiązanie z Kotlinem.

Możesz skopiować swój InputStream do ByteArray

val inputStream = ...

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

val byteInputStream = ByteArrayInputStream(byteOutputStream.toByteArray())

Jeśli chcesz przeczytać byteInputStreamkilka razy, zadzwoń byteInputStream.reset()przed ponownym przeczytaniem.

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

Poniższa klasa powinna załatwić sprawę. Po prostu utwórz instancję, wywołaj metodę „multiply” i podaj źródłowy strumień wejściowy oraz wymaganą liczbę duplikatów.

Ważne: musisz używać wszystkich sklonowanych strumieni jednocześnie w oddzielnych wątkach.

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();
                }
            }
        }
    }
}

Klonowanie strumienia wejściowego może nie być dobrym pomysłem, ponieważ wymaga to dogłębnej wiedzy na temat szczegółów klonowanego strumienia wejściowego. Aby obejść ten problem, należy utworzyć nowy strumień wejściowy, który ponownie odczytuje dane z tego samego źródła.

Tak więc przy użyciu niektórych funkcji Java 8 wyglądałoby to tak:

public class Foo {

    private Supplier<InputStream> inputStreamSupplier;

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

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

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

Ta metoda ma pozytywny wpływ na to, że ponownie użyje kodu, który jest już na miejscu - utworzenie strumienia wejściowego hermetyzowanego w inputStreamSupplier. Nie ma też potrzeby utrzymywania drugiej ścieżki kodu do klonowania strumienia.

Z drugiej strony, jeśli odczytywanie ze strumienia jest drogie (ponieważ odbywa się to przez połączenie o niskiej przepustowości), ta metoda podwoi koszty. Można to obejść, używając określonego dostawcy, który najpierw zapisze zawartość strumienia lokalnie i zapewni InputStreamdla tego teraz lokalny zasób.