Comment convertir un OutputStream en InputStream en Java ?

Comment convertir un OutputStream en un InputStream

Dans le développement de logiciels, il n'est pas rare de rencontrer des situations où vous devez convertir des données d'un type de flux vers un autre. L'un de ces scénarios consiste à convertir un OutputStream en un InputStream.

Introduction aux flux canalisés

La solution à ce problème réside dans l'utilisation des classes PipedInputStream et PipedOutputStream de Java. Ces classes permettent la communication entre les flux en créant un canal bidirectionnel.

PipedInputStream vers OutputStream (pas l'inverse)

Expression Lambda :

PipedInputStream in = new PipedInputStream();
final PipedOutputStream out = new PipedOutputStream(in);
// in a background thread, write the given output stream to the PipedOutputStream for consumption
new Thread(() -> {
    originalOutputStream.writeTo(out);
}).start();

Remarque : Il est essentiel de gérer les situations dans lesquelles OutputStream peut être fermé prématurément, conduisant à une ClosedPipeException. Pour éviter cela, vous pouvez inverser les constructeurs :

PipedInputStream in = new PipedInputStream(out);
new Thread(() -> {
    originalOutputStream.writeTo(out);
}).start();

Try-With-Resources :

// take the copy of the stream and re-write it to an InputStream
PipedInputStream in = new PipedInputStream();
new Thread(new Runnable() {
    public void run() {
        // try-with-resources here
        // putting the try block outside the Thread will cause the PipedOutputStream resource to close before the Runnable finishes
        try (final PipedOutputStream out = new PipedOutputStream(in)) {
            // write the original OutputStream to the PipedOutputStream
            // note that in order for the below method to work, you need to ensure that the data has finished writing to the ByteArrayOutputStream
            originalByteArrayOutputStream.writeTo(out);
        } catch (IOException e) {
            // logging and exception handling should go here
        }
    }
}).start();

PipedOutputStream en InputStream

Si vous n'avez pas de ByteArrayOutputStream, vous pouvez utiliser le code suivant :

PipedInputStream in = new PipedInputStream();
final PipedOutputStream out = new PipedOutputStream(in);
new Thread(new Runnable() {
    public void run() {
        try {
            // write the original OutputStream to the PipedOutputStream
            // note that in order for the below method to work, you need to ensure that the data has finished writing to the OutputStream
            originalOutputStream.writeTo(out);
        } catch (IOException e) {
            // logging and exception handling should go here
        } finally {
            // close the PipedOutputStream here because we're done writing data
            // once this thread has completed its run
            if (out != null) {
                // close the PipedOutputStream cleanly
                out.close();
            }
        }
    }
}).start();

L'utilisation de flux redirigés offre plusieurs avantages, notamment :

• Concurrence : Le transfert de données s'effectue dans un thread séparé, permettant un traitement parallèle.
• Efficacité de la mémoire : Les flux redirigés évitent de créer des copies tampon supplémentaires, réduisant ainsi la consommation de mémoire.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!