Comment cloner un InputStream ?

Question

J'ai un InputStream que je passe à une méthode pour effectuer un traitement. Je vais utiliser le même InputStream dans une autre méthode, mais après le premier traitement, l'InputStream semble être fermé dans la méthode.

Comment je peux cloner l'InputStream pour l'envoyer à la méthode qui le ferme ? Il existe une autre solution ?

EDIT : la méthode qui ferme l'InputStream est une méthode externe d'une librairie. Je n'ai pas le contrôle de la fermeture ou non.

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 tout ce que vous voulez faire est de lire la même information plus d'une fois, et que les données d'entrée sont assez petites pour tenir dans la mémoire, vous pouvez copier les données de votre InputStream a un Tableau d'octets de sortie (ByteArrayOutputStream) .

Vous pouvez ensuite obtenir le tableau d'octets associé et ouvrir autant de "clones" que nécessaire. Flux d'entrée ByteArrayInputStream comme vous le souhaitez.

ByteArrayOutputStream baos = new ByteArrayOutputStream();

// Code simulating the copy
// You could alternatively use NIO
// 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 recorded bytes
// Can be repeated as many times as you wish
InputStream is1 = new ByteArrayInputStream(baos.toByteArray()); 
InputStream is2 = new ByteArrayInputStream(baos.toByteArray()); 

Mais si vous avez vraiment besoin de garder le flux original ouvert pour recevoir de nouvelles données, alors vous devrez suivre l'appel externe à close() . Vous devrez empêcher close() d'être appelé d'une manière ou d'une autre.

MISE À JOUR (2019) :

Depuis Java 9, les bits du milieu peuvent être remplacés par InputStream.transferTo :

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

Answer 2

Vous voulez utiliser la fonction CloseShieldInputStream :

Il s'agit d'une enveloppe qui empêchera la fermeture du flux. Vous feriez quelque chose comme ça.

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 3

Vous ne pouvez pas le cloner, et la façon dont vous allez résoudre votre problème dépend de la source des données.

Une solution consiste à lire toutes les données de l'InputStream dans un tableau d'octets, puis à créer un ByteArrayInputStream autour de ce tableau d'octets, et à passer ce flux d'entrée dans votre méthode.

Edit 1 : C'est-à-dire, si l'autre méthode doit également lire les mêmes données. C'est-à-dire que vous voulez "réinitialiser" le flux.

Answer 4

Si les données lues à partir du flux sont importantes, je recommande d'utiliser un TeeInputStream de Apache Commons IO. De cette façon, vous pouvez essentiellement répliquer l'entrée et passer un tube t'd comme clone.

Answer 5

Cela peut ne pas fonctionner dans toutes les situations, mais voici ce que j'ai fait : J'ai étendu le FilterInputStream et effectue le traitement nécessaire des octets pendant que la bibliothèque externe lit les données.

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
    }

}

Ensuite, vous passez simplement une instance de StreamBytesWithExtraProcessingInputStream où vous auriez passé le flux d'entrée. Avec le flux d'entrée original comme paramètre du constructeur.

Il convient de noter que cette méthode fonctionne octet par octet, donc ne l'utilisez pas si vous avez besoin de hautes performances.