É necessário fechar cada OutputStream e Writer aninhado separadamente?

Estou escrevendo um pedaço de código:

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

Preciso fechar todos os fluxos ou gravadores como o seguinte?

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

Ou será bom apenas fechar o último fluxo?

bw.close();

Supondo que todos os fluxos são criados bem, sim, apenas o encerramento bwé muito bem com essas implementações de fluxo ; mas isso é uma grande suposição.

Eu usaria o try-with-resources ( tutorial ) para que quaisquer problemas na construção dos fluxos subseqüentes que geram exceções não deixem os fluxos anteriores suspensos e, assim, você não precise confiar na implementação do fluxo para encerrar a chamada. o fluxo subjacente:

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

Observe que você não liga mais close.

Nota importante : Para que a tentativa com recursos os feche, você deve atribuir os fluxos às variáveis ​​ao abri-las, não é possível usar o aninhamento. Se você usar o aninhamento, uma exceção durante a construção de um dos fluxos posteriores (por exemplo, GZIPOutputStream) deixará aberto qualquer fluxo construído pelas chamadas aninhadas dentro dele. Do JLS §14.20.3 :

Uma instrução try-with-resources é parametrizada com variáveis (conhecidas como recursos) que são inicializadas antes da execução do trybloco e fechadas automaticamente, na ordem inversa em que foram inicializadas, após a execução do trybloco.

Observe a palavra "variáveis" (ênfase minha) .

Por exemplo, não faça isso:

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

... porque uma exceção do GZIPOutputStream(OutputStream)construtor (que diz que pode ser lançada IOExceptione grava um cabeçalho no fluxo subjacente) deixaria FileOutputStreamaberta. Como alguns recursos têm construtores que podem ser lançados e outros não, é um bom hábito apenas listá-los separadamente.

Podemos verificar novamente nossa interpretação dessa seção JLS com este programa:

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

... que tem a saída:

Exemplo de construção $ InnerMost
Exemplo de construção $ Middle
Exemplo de construção $ OuterMost
No bloco de captura
Finalmente no bloco
No final do principal

Observe que não há chamadas para closelá.

Se corrigirmos 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");
}

então recebemos as closechamadas apropriadas :

Exemplo de construção $ InnerMost
Exemplo de construção $ Middle
Exemplo de construção $ OuterMost
Exemplo $ Middle closed
Exemplo $ InnerMost fechado
Exemplo $ InnerMost fechado
No bloco de captura
Finalmente no bloco
No final do principal

(Sim, duas chamadas para InnerMost#closeestão corretas; uma é de Middlee a outra de tentativa com recursos.)

Você pode fechar o fluxo mais externo, na verdade, não precisa reter todos os fluxos agrupados e pode usar o Java 7 try-with-resources.

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

Se você se inscrever no YAGNI, ou não precisar, deve adicionar apenas o código que realmente precisa. Você não deve adicionar o código que imagina ser necessário, mas na realidade não faz nada de útil.

Pegue este exemplo e imagine o que poderia dar errado se você não fizesse isso e qual seria o impacto?

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

Vamos começar com FileOutputStream, que chama openpara fazer todo o trabalho real.

/**
 * 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;

Se o arquivo não for encontrado, não há recurso subjacente para fechar, portanto, fechá-lo não fará nenhuma diferença. Se o arquivo existir, ele deve lançar uma FileNotFoundException. Portanto, não há nada a ganhar tentando fechar o recurso somente dessa linha.

O motivo pelo qual você precisa fechar o arquivo é quando o arquivo é aberto com êxito, mas você mais tarde recebe um erro.

Vamos ver o próximo stream GZIPOutputStream

Há código que pode gerar uma exceção

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

Isso grava o cabeçalho do arquivo. Agora, seria muito incomum você poder abrir um arquivo para gravação, mas não conseguir escrever nem 8 bytes, mas vamos imaginar que isso poderia acontecer e não fecharemos o arquivo posteriormente. O que acontece com um arquivo se ele não estiver fechado?

Você não recebe gravações não liberadas, elas são descartadas e, nesse caso, não há bytes gravados com sucesso no fluxo que não sejam armazenados em buffer neste momento. Mas um arquivo que não está fechado não fica para sempre, mas o FileOutputStream tem

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

Se você não fechar um arquivo, ele será fechado de qualquer maneira, mas não imediatamente (e, como eu disse, os dados deixados em um buffer serão perdidos dessa maneira, mas não há nenhum neste momento)

Qual é a consequência de não fechar o arquivo imediatamente? Em condições normais, você potencialmente perde alguns dados e os descritores de arquivos ficam em potencial. Mas se você possui um sistema em que pode criar arquivos, mas não pode gravar nada neles, há um problema maior. ou seja, é difícil imaginar por que você está tentando criar esse arquivo repetidamente, apesar de estar falhando.

OutputStreamWriter e BufferedWriter não lançam IOException em seus construtores, portanto, não está claro qual problema eles causariam. No caso do BufferedWriter, você pode obter um OutOfMemoryError. Nesse caso, ele acionará imediatamente um GC, que, como vimos, fechará o arquivo de qualquer maneira.

Se todos os fluxos tiverem sido instanciados, o fechamento apenas do lado externo será bom.

A documentação na Closeableinterface afirma que método fechado:

Fecha esse fluxo e libera todos os recursos do sistema associados a ele.

Os recursos do sistema de liberação incluem fluxos de fechamento.

Também afirma que:

Se o fluxo já estiver fechado, a invocação desse método não terá efeito.

Portanto, se você fechá-los explicitamente depois, nada de errado acontecerá.

Eu prefiro usar try(...)sintaxe (Java 7), por exemplo

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

Tudo bem se você fechar apenas o último fluxo - a chamada final também será enviada para os fluxos subjacentes.

Não, o nível mais alto Streamou readergarantirá que todos os fluxos / leitores subjacentes sejam fechados.

Verifique a implementação do close()método do seu fluxo de nível superior.

No Java 7, há um recurso try-with-resources . Você não precisa fechar explicitamente seus fluxos, ele cuidará disso.