Comment cloner un InputStream?

J'ai un InputStream que je passe à une méthode pour faire du traitement. J'utiliserai le même InputStream dans une autre méthode, mais après le premier traitement, l'InputStream semble être fermé à l'intérieur de la méthode.

Comment puis-je cloner le InputStream pour l'envoyer à la méthode qui le ferme? Il y a une autre solution?

EDIT: la méthode qui ferme l'InputStream est une méthode externe à partir d'une bibliothèque. Je n'ai pas de contrôle sur 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";
    }
}

Si tout ce que vous voulez faire est de lire les mêmes informations plus d'une fois et que les données d'entrée sont suffisamment petites pour tenir en mémoire, vous pouvez copier les données de votre InputStreamvers un ByteArrayOutputStream .

Ensuite, vous pouvez obtenir le tableau d'octets associé et ouvrir autant de ByteArrayInputStream "clonés" que vous le souhaitez.

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

Mais si vous avez vraiment besoin de garder le flux d'origine ouvert pour recevoir de nouvelles données, vous devrez suivre cette close()méthode externe et l'empêcher d'être appelée 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()); 

Vous souhaitez utiliser Apache CloseShieldInputStream:

Il s'agit d'un wrapper 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();

Vous ne pouvez pas le cloner et la manière 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 InputStream dans un tableau d'octets, puis à créer un ByteArrayInputStream autour de ce tableau d'octets et à transmettre ce flux d'entrée à votre méthode.

Edit 1: Autrement dit, si l'autre méthode doit également lire les mêmes données. Ie vous voulez "réinitialiser" le flux.

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

Cela peut ne pas fonctionner dans toutes les situations, mais voici ce que j'ai fait: j'ai étendu la classe FilterInputStream et effectué le traitement requis des octets lorsque 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 l' StreamBytesWithExtraProcessingInputStreamendroit où vous auriez passé dans le flux d'entrée. Avec le flux d'entrée d'origine comme paramètre de constructeur.

Il convient de noter que cela fonctionne octet pour octet, donc ne l'utilisez pas si des performances élevées sont requises.

UPD. Vérifiez le commentaire avant. Ce n'est pas exactement ce qui a été demandé.

Si vous utilisez, apache.commonsvous pouvez copier des flux en utilisant IOUtils.

Vous pouvez utiliser le code suivant:

InputStream = IOUtils.toBufferedInputStream(toCopy);

Voici l'exemple complet adapté à votre situation:

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

Ce code nécessite certaines dépendances:

MAVEN

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

GRADLE

'commons-io:commons-io:2.4'

Voici la référence DOC pour cette méthode:

Récupère tout le contenu d'un InputStream et représente les mêmes données que le résultat InputStream. Cette méthode est utile lorsque,

Source InputStream est lent. Il a des ressources réseau associées, nous ne pouvons donc pas le garder ouvert pendant longtemps. Il a un délai d'expiration du réseau associé.

Vous pouvez en savoir plus IOUtilsici: http://commons.apache.org/proper/commons-io/javadocs/api-2.4/org/apache/commons/io/IOUtils.html#toBufferedInputStream(java.io.InputStream)

Voici la solution avec Kotlin.

Vous pouvez copier votre InputStream dans ByteArray

val inputStream = ...

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

val byteInputStream = ByteArrayInputStream(byteOutputStream.toByteArray())

Si vous avez besoin de lire byteInputStreamplusieurs fois, appelez byteInputStream.reset()avant de relire.

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

La classe ci-dessous devrait faire l'affaire. Créez simplement une instance, appelez la méthode "multiplier" et fournissez le flux d'entrée source et la quantité de doublons dont vous avez besoin.

Important: vous devez consommer tous les flux clonés simultanément dans des threads séparés.

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

Le clonage d'un flux d'entrée peut ne pas être une bonne idée, car cela nécessite une connaissance approfondie des détails du flux d'entrée en cours de clonage. Une solution de contournement pour cela consiste à créer un nouveau flux d'entrée qui lit à nouveau à partir de la même source.

Donc, en utilisant certaines fonctionnalités de Java 8, cela ressemblerait à ceci:

public class Foo {

    private Supplier<InputStream> inputStreamSupplier;

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

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

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

Cette méthode a pour effet positif de réutiliser le code déjà en place - la création du flux d'entrée encapsulé dans inputStreamSupplier. Et il n'est pas nécessaire de maintenir un deuxième chemin de code pour le clonage du flux.

D'un autre côté, si la lecture à partir du flux coûte cher (parce que c'est fait sur une connexion à faible bande passante), alors cette méthode doublera les coûts. Cela pourrait être contourné en utilisant un fournisseur spécifique qui stockera d'abord le contenu du flux localement et fournira une InputStreamressource pour cette ressource maintenant locale.