Ist es notwendig, jeden verschachtelten OutputStream und Writer separat zu schließen?

Ich schreibe einen Code:

OutputStream outputStream = new FileOutputStream(createdFile);
GZIPOutputStream gzipOutputStream = new GZIPOutputStream(outputStream);
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(gzipOutputStream));

Muss ich jeden Stream oder Writer wie folgt schließen?

gzipOutputStream.close();
bw.close();
outputStream.close();

Oder ist es in Ordnung, nur den letzten Stream zu schließen?

bw.close();

Angenommen, alle Streams werden in Ordnung erstellt. Ja, nur das Schließen bwist für diese Stream-Implementierungen in Ordnung . aber das ist eine große Annahme.

Ich würde Try-with-Resources ( Tutorial ) verwenden, damit beim Erstellen der nachfolgenden Streams, die Ausnahmen auslösen, die vorherigen Streams nicht hängen bleiben und Sie sich nicht darauf verlassen müssen, dass die Stream-Implementierung den Aufruf zum Schließen hat der zugrunde liegende Stream:

try (
    OutputStream outputStream = new FileOutputStream(createdFile);
    GZIPOutputStream gzipOutputStream = new GZIPOutputStream(outputStream);
    OutputStreamWriter osw = new OutputStreamWriter(gzipOutputStream);
    BufferedWriter bw = new BufferedWriter(osw)
    ) {
    // ...
}

Beachten Sie, dass Sie überhaupt nicht mehr anrufen close.

Wichtiger Hinweis : Damit Try-with-Resources sie schließen kann, müssen Sie die Streams beim Öffnen Variablen zuweisen. Sie können die Verschachtelung nicht verwenden. Wenn Sie die Verschachtelung verwenden, lässt eine Ausnahme während der Erstellung eines der späteren Streams (z. B. GZIPOutputStream) jeden Stream offen, der durch die darin enthaltenen verschachtelten Aufrufe erstellt wurde. Aus JLS §14.20.3 :

Eine Try-with-Resources-Anweisung wird mit Variablen (so genannten Ressourcen) parametrisiert , die vor der Ausführung des tryBlocks initialisiert und nach der Ausführung des tryBlocks automatisch in der umgekehrten Reihenfolge geschlossen werden, in der sie initialisiert wurden .

Beachten Sie das Wort "Variablen" (meine Betonung) .

ZB mach das nicht:

// DON'T DO THIS
try (BufferedWriter bw = new BufferedWriter(
        new OutputStreamWriter(
        new GZIPOutputStream(
        new FileOutputStream(createdFile))))) {
    // ...
}

... weil eine Ausnahme vom GZIPOutputStream(OutputStream)Konstruktor (der besagt, dass er möglicherweise ausgelöst IOExceptionwird und einen Header in den zugrunde liegenden Stream schreibt) das FileOutputStreamoffen lassen würde. Da einige Ressourcen Konstruktoren haben, die möglicherweise ausgelöst werden, andere jedoch nicht, ist es eine gute Angewohnheit, sie nur separat aufzulisten.

Mit diesem Programm können wir unsere Interpretation dieses JLS-Abschnitts überprüfen:

public class Example {

    private static class InnerMost implements AutoCloseable {
        public InnerMost() throws Exception {
            System.out.println("Constructing " + this.getClass().getName());
        }

        @Override
        public void close() throws Exception {
            System.out.println(this.getClass().getName() + " closed");
        }
    }

    private static class Middle implements AutoCloseable {
        private AutoCloseable c;

        public Middle(AutoCloseable c) {
            System.out.println("Constructing " + this.getClass().getName());
            this.c = c;
        }

        @Override
        public void close() throws Exception {
            System.out.println(this.getClass().getName() + " closed");
            c.close();
        }
    }

    private static class OuterMost implements AutoCloseable {
        private AutoCloseable c;

        public OuterMost(AutoCloseable c) throws Exception {
            System.out.println("Constructing " + this.getClass().getName());
            throw new Exception(this.getClass().getName() + " failed");
        }

        @Override
        public void close() throws Exception {
            System.out.println(this.getClass().getName() + " closed");
            c.close();
        }
    }

    public static final void main(String[] args) {
        // DON'T DO THIS
        try (OuterMost om = new OuterMost(
                new Middle(
                    new InnerMost()
                    )
                )
            ) {
            System.out.println("In try block");
        }
        catch (Exception e) {
            System.out.println("In catch block");
        }
        finally {
            System.out.println("In finally block");
        }
        System.out.println("At end of main");
    }
}

... was die Ausgabe hat:

Konstruktionsbeispiel $ InnerMost
Konstruktionsbeispiel $ Middle
Konstruktionsbeispiel $ OuterMost
Im Fangblock
In endlich blockieren
Am Ende der Hauptleitung

Beachten Sie, dass dort keine Anrufe closeeingehen.

Wenn wir Folgendes beheben main:

public static final void main(String[] args) {
    try (
        InnerMost im = new InnerMost();
        Middle m = new Middle(im);
        OuterMost om = new OuterMost(m)
        ) {
        System.out.println("In try block");
    }
    catch (Exception e) {
        System.out.println("In catch block");
    }
    finally {
        System.out.println("In finally block");
    }
    System.out.println("At end of main");
}

dann bekommen wir die entsprechenden closeAnrufe:

Konstruktionsbeispiel $ InnerMost
Konstruktionsbeispiel $ Middle
Konstruktionsbeispiel $ OuterMost
Beispiel $ Middle geschlossen
Beispiel $ InnerMost geschlossen
Beispiel $ InnerMost geschlossen
Im Fangblock
In endlich blockieren
Am Ende der Hauptleitung

(Ja, zwei Aufrufe von InnerMost#closesind korrekt; einer stammt von Middle, der andere von try-with-resources.)

Sie können den äußersten Stream schließen. Tatsächlich müssen Sie nicht alle umschlossenen Streams beibehalten, und Sie können Java 7 Try-with-Resources verwenden.

try (BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(
                     new GZIPOutputStream(new FileOutputStream(createdFile)))) {
     // write to the buffered writer
}

Wenn Sie YAGNI abonnieren oder es nicht brauchen, sollten Sie nur den Code hinzufügen, den Sie tatsächlich benötigen. Sie sollten keinen Code hinzufügen, von dem Sie sich vorstellen, dass Sie ihn benötigen, aber in Wirklichkeit tun Sie nichts Nützliches.

Nehmen Sie dieses Beispiel und stellen Sie sich vor, was möglicherweise schief gehen könnte, wenn Sie dies nicht tun würden und welche Auswirkungen dies hätte.

try (
    OutputStream outputStream = new FileOutputStream(createdFile);
    GZIPOutputStream gzipOutputStream = new GZIPOutputStream(outputStream);
    OutputStreamWriter osw = new OutputStreamWriter(gzipOutputStream);
    BufferedWriter bw = new BufferedWriter(osw)
    ) {
    // ...
}

Beginnen wir mit FileOutputStream, der aufruft, openum die gesamte eigentliche Arbeit zu erledigen.

/**
 * Opens a file, with the specified name, for overwriting or appending.
 * @param name name of file to be opened
 * @param append whether the file is to be opened in append mode
 */
private native void open(String name, boolean append)
    throws FileNotFoundException;

Wenn die Datei nicht gefunden wird, muss keine zugrunde liegende Ressource geschlossen werden, sodass das Schließen keinen Unterschied macht. Wenn die Datei vorhanden ist, sollte eine FileNotFoundException ausgelöst werden. Es gibt also nichts zu gewinnen, wenn versucht wird, die Ressource allein aus dieser Zeile zu schließen.

Der Grund, warum Sie die Datei schließen müssen, ist, wenn die Datei erfolgreich geöffnet wurde, aber später eine Fehlermeldung angezeigt wird.

Schauen wir uns den nächsten Stream an GZIPOutputStream

Es gibt Code, der eine Ausnahme auslösen kann

private void writeHeader() throws IOException {
    out.write(new byte[] {
                  (byte) GZIP_MAGIC,        // Magic number (short)
                  (byte)(GZIP_MAGIC >> 8),  // Magic number (short)
                  Deflater.DEFLATED,        // Compression method (CM)
                  0,                        // Flags (FLG)
                  0,                        // Modification time MTIME (int)
                  0,                        // Modification time MTIME (int)
                  0,                        // Modification time MTIME (int)
                  0,                        // Modification time MTIME (int)
                  0,                        // Extra flags (XFLG)
                  0                         // Operating system (OS)
              });
}

Dies schreibt den Header der Datei. Jetzt wäre es sehr ungewöhnlich, dass Sie eine Datei zum Schreiben öffnen können, aber nicht einmal 8 Bytes darauf schreiben können. Stellen Sie sich jedoch vor, dass dies passieren könnte und wir die Datei danach nicht schließen. Was passiert mit einer Datei, wenn sie nicht geschlossen ist?

Sie erhalten keine nicht geleerten Schreibvorgänge, sie werden verworfen, und in diesem Fall gibt es keine erfolgreich geschriebenen Bytes in den Stream, die zu diesem Zeitpunkt ohnehin nicht gepuffert sind. Aber eine Datei, die nicht geschlossen ist, lebt nicht für immer, sondern FileOutputStream

protected void finalize() throws IOException {
    if (fd != null) {
        if (fd == FileDescriptor.out || fd == FileDescriptor.err) {
            flush();
        } else {
            /* if fd is shared, the references in FileDescriptor
             * will ensure that finalizer is only called when
             * safe to do so. All references using the fd have
             * become unreachable. We can call close()
             */
            close();
        }
    }
}

Wenn Sie eine Datei überhaupt nicht schließen, wird sie trotzdem geschlossen, nur nicht sofort (und wie gesagt, Daten, die in einem Puffer verbleiben, gehen auf diese Weise verloren, aber zu diesem Zeitpunkt gibt es keine).

Was ist die Folge davon, dass die Datei nicht sofort geschlossen wird? Unter normalen Bedingungen verlieren Sie möglicherweise einige Daten, und Ihnen gehen möglicherweise die Dateideskriptoren aus. Wenn Sie jedoch ein System haben, in dem Sie Dateien erstellen, aber nichts darauf schreiben können, haben Sie ein größeres Problem. Das heißt, es ist schwer vorstellbar, warum Sie wiederholt versuchen, diese Datei zu erstellen, obwohl Sie einen Fehler machen.

Sowohl OutputStreamWriter als auch BufferedWriter lösen keine IOException in ihren Konstruktoren aus, sodass nicht klar ist, welches Problem sie verursachen würden. Im Fall von BufferedWriter könnten Sie einen OutOfMemoryError erhalten. In diesem Fall wird sofort ein GC ausgelöst, der, wie wir gesehen haben, die Datei trotzdem schließt.

Wenn alle Streams instanziiert wurden, ist es in Ordnung, nur den äußersten zu schließen.

In der Dokumentation zur CloseableSchnittstelle heißt es: Schließen Sie die Methode:

Schließt diesen Stream und gibt alle damit verbundenen Systemressourcen frei.

Das Freigeben von Systemressourcen umfasst das Schließen von Streams.

Es heißt auch, dass:

Wenn der Stream bereits geschlossen ist, hat das Aufrufen dieser Methode keine Auswirkung.

Wenn Sie sie also später explizit schließen, passiert nichts Falsches.

Ich würde lieber try(...)Syntax (Java 7) verwenden, z

try (OutputStream outputStream = new FileOutputStream(createdFile)) {
      ...
}

Es ist in Ordnung, wenn Sie nur den letzten Stream schließen - der Abschlussaufruf wird auch an die zugrunde liegenden Streams gesendet.

Nein, die oberste Ebene Streamoder stellt readersicher, dass alle zugrunde liegenden Streams / Reader geschlossen sind.

Überprüfen Sie die close()Methode Umsetzung Ihrer obersten Ebene Stream.

In Java 7 gibt es eine Funktion zum Ausprobieren von Ressourcen . Sie müssen Ihre Streams nicht explizit schließen, das wird erledigt.