Java io丑陋的try-finally块

Question

是否有一种不那么丑陋的方式来处理close() 异常以关闭两个流：

    InputStream in = new FileInputStream(inputFileName);
    OutputStream out = new FileOutputStream(outputFileName);

    try {
        copy(in, out);
    } finally {
        try {
            in.close();
        } catch (Exception e) {
            try {
                // event if in.close fails, need to close the out
                out.close();
            } catch (Exception e2) {}
                throw e; // and throw the 'in' exception
            }
        }
        out.close();
    }

更新：以上所有代码都在一个 try-catch 中，感谢您的警告。

终于（在答案之后）：

使用Execute Around idiom 可以完成一个很好的实用方法（感谢 Tom Hawtin）。

Answer 1

这是正确的惯用语（而且效果很好）：

   InputStream in = null;
   OutputStream out = null;
   try {
       in = new FileInputStream(inputFileName);
       out = new FileOutputStream(outputFileName);
       copy(in, out);
   finally {
       close(in);
       close(out);
   }

  public static void close(Closeable c) {
     if (c == null) return; 
     try {
         c.close();
     } catch (IOException e) {
         //log the exception
     }
  }

之所以能正常工作，是因为在 finally 代码完成后会抛出在 finally 之前抛出的异常，前提是您的 finally 代码本身不会抛出异常或以其他方式异常终止。

编辑：从 Java 7（和 Android SDK 19 - KitKat）开始，现在有一个 Try with resources 语法以使这个更干净。 this question 中解决了如何处理。

Answer 2

你可以实现一个实用方法：

public final class IOUtil {
  private IOUtil() {}

  public static void closeQuietly(Closeable... closeables) {
    for (Closeable c : closeables) {
        if (c != null) try {
          c.close();
        } catch(Exception ex) {}
    }
  }
}

那么你的代码将被简化为：

try {
  copy(in, out);
} finally {
  IOUtil.closeQuietly(in, out);
}

附加

我想在第 3 方开源库中会有这样的方法。但是，我的偏好是避免不必要的库依赖，除非我使用它的大部分功能。因此，我倾向于自己实现这样的简单实用方法。

Answer 3

try {
    final InputStream in = new FileInputStream(inputFileName);
    try {
        final OutputStream out = new FileOutputStream(outputFileName);    
        try {
            copy(in, out);
            out.flush(); // Doesn't actually do anything in this specific case.
        } finally {
            out.close();
        }
    } finally {
        in.close();
    }
} catch (IOException exc) {
    throw new SomeRelevantException(exc);
}

请记住，打开流可能会引发异常，因此您确实需要在流开口之间使用try（请不要做一些涉及nulls 的hack。任何东西都可能引发Error（这不是Exception) 的实例。

事实证明catch 和finally 应该很少共享相同的try。

从 Java SE 7 开始，您可以编写使用 try-with-resource 来避免太多缩进。尽管隐藏了被抑制的异常，但它或多或少做同样的事情。

try (
    final InputStream in = new FileInputStream(inputFileName);
    final OutputStream out = new FileOutputStream(outputFileName);    
) {
    copy(in, out);
    out.flush(); // Doesn't actually do anything in this specific case.
} catch (IOException exc) {
    throw new SomeRelevantException(exc);
}

您可能想使用Execute Around idiom。

我相信标准的良好复制方法是使用 NIO 的transferTo/transferFrom。

Answer 4

我坚信在 Java 7.0 中，您不再需要自己显式关闭流。 Language Features in Java 7

try (BufferedReader br = new BufferedReader(new FileReader(path)) {
   return br.readLine();
}

Answer 5

Guava 有非常好的 IO API，可以消除这种需求。例如，您的示例是：

Files.copy(new File(inputFileName), new File(outputFileName));

更一般地说，它使用InputSuppliers 和OutputSuppliers 的概念来允许在其实用程序方法中创建InputStreams 和OutputStreams，允许它完全控制它们以便它可以处理正确关闭。

此外，它还有Closeables.closeQuietly(Closeable)，这基本上是大多数答案所建议的方法类型。

其中的 IO 内容仍处于测试阶段，可能会发生变化，但值得一试甚至使用，具体取决于您正在处理的内容。

Answer 6

从 Java 7 开始，对于 Closeable 资源，有一种更好的方式来编写 try-finally 块。

现在您可以在 try 关键字后面的括号中创建资源，如下所示：

try (initialize resources here) {
   ...
}

并且它们将在代码块完成后自动关闭。不需要finally 部分。

一个例子：

try (
   ZipFile zf = new ZipFile(zipFileName);
   BufferedWriter writer = Files.newBufferedWriter(outputFilePath, charset);
) {
    // Enumerate each entry
    for (Enumeration entries = zf.entries(); entries.hasMoreElements();) {
        // Get the entry name and write it to the output file
        String newLine = System.getProperty("line.separator");
        String zipEntryName = ((java.util.zip.ZipEntry)entries.nextElement()).getName() + newLine;
        writer.write(zipEntryName, 0, zipEntryName.length());
    }
}

并且在for循环完成后，资源将被关闭！

Answer 7

在 commons io 中，IOUtils 有一些 closeQuietly 方法。

Answer 8

我有时使用的一个技巧是定义一个名为closeQuietly(Closeable) 的方法，该方法测试它的参数是否为null，然后关闭它，忽略任何异常。但是你需要小心地关闭 OutputStreams 和 Writers，因为它们实际上可能会抛出一个重要的异常；例如如果最终刷新失败。

Java 7 可能会有所改进。据报道，它将有一个新的结构，提供一种更简洁的方式来处理托管资源；例如完成后需要关闭的流。

最后，您应该知道您的示例存在错误。如果方法调用打开了第二个流，第一个流将不会被关闭。第二次打开需要在try 块内完成。

Answer 9

在大多数情况下，'in' close() 异常是无关紧要的，所以：

    try {
      copy(in, out);
    } finally {
    try {  in.close()  }  catch (Exception e) { /* perhaps log it */ }
    try {  out.close() }  catch (Exception e) {/* perhaps log it */ }
    } 

吞下异常通常是不好的做法，但在这种情况下，我认为没关系。

Answer 10

使用

IOUtils.closeNoThrow(myInputStream);

简洁优雅。

Answer 11

这是我的答案，希望好多了

https://stackoverflow.com/a/35623998/2585433

try {
    fos = new FileOutputStream(new File("..."));
    bos = new BufferedOutputStream(fos);
    oos = new ObjectOutputStream(bos);
}
catch (Exception e) {
}
finally {
    Stream.close(oos,bos,fos);
}


class Stream {

public static void close(AutoCloseable... array) {
    for (AutoCloseable c : array) {
        try {c.close();}
        catch (IOException e) {}
        catch (Exception e) {}
    }
  } 
}

Answer 12

在 C# 中，using 构造会在我们离开作用域时自动关闭可关闭对象：

using(Stream s = new Stream(filename)) {
  s.read();
}

我认为这是 java 的 try-finally 块的简写形式。 Java 6 引入了 Closable 接口。所以，using 就快到了。当最后一步在 Java 7 中完成时，它确实很棒。