Java 中的 RAII...资源处理总是那么丑陋吗？

Question

我刚刚玩了一下Java文件系统API，并得到了以下函数，用于复制二进制文件。 原始来源来自网络，但我添加了 try/catch/finally 子句，以确保如果发生错误，缓冲区流将在退出该函数之前关闭（从而释放我的操作系统资源）。

我精简了函数以显示模式：

public static void copyFile(FileOutputStream oDStream, FileInputStream oSStream) throw etc...
{
   BufferedInputStream oSBuffer = new BufferedInputStream(oSStream, 4096);
   BufferedOutputStream oDBuffer = new BufferedOutputStream(oDStream, 4096);

   try
   { 
      try
      { 
         int c;

         while((c = oSBuffer.read()) != -1)  // could throw a IOException
         {
            oDBuffer.write(c);  // could throw a IOException
         }
      }
      finally
      {
         oDBuffer.close(); // could throw a IOException
      }
   }
   finally
   {
      oSBuffer.close(); // could throw a IOException
   }
}

据我了解，我不能将两个 close() 放在 finally 子句中，因为第一个 close() 可以好的抛出，然后，第二个不会被执行。

我知道 C# 有 Dispose 模式，可以使用 using 关键字来处理这个问题。

我什至更清楚 C++ 代码会是这样的（使用类似 Java 的 API）：

void copyFile(FileOutputStream & oDStream, FileInputStream & oSStream)
{
   BufferedInputStream oSBuffer(oSStream, 4096);
   BufferedOutputStream oDBuffer(oDStream, 4096);

   int c;

   while((c = oSBuffer.read()) != -1)  // could throw a IOException
   {
      oDBuffer.write(c);  // could throw a IOException
   }

   // I don't care about resources, as RAII handle them for me
}

我错过了一些东西，或者我真的必须在 Java 中生成丑陋且臃肿的代码只是为了处理 close( ) 缓冲流的方法？

（请告诉我我在某个地方错了......）

编辑：是我，还是在更新此页面时，我看到问题和所有答案在几分钟内都减少了一个点？ 是否有人在保持匿名的同时太享受自己了？

编辑 2：McDowell 提供了一个非常有趣的链接，我觉得我必须在这里提及： http://illegalargumentexception.blogspot .com/2008/10/java-how-not-to-make-mess-of-stream.html

编辑 3：按照 McDowell 的链接，我偶然发现了一个类似于 C# 模式的 Java 7 提案使用模式： http://tech.puredanger.com/java7/#resourceblock 。 我的问题已明确描述。 显然，即使使用 Java 7 do，问题仍然存在。

Answer 1

在大多数情况下，对于 Java 6 及更低版本，try/finally 模式是处理流的正确方法。

有些人主张悄悄关闭流。 由于以下原因，请小心执行此操作： Java：如何不让流处理变得混乱

---

Java 7 引入了try-with-resources：

/** transcodes text file from one encoding to another */
public static void transcode(File source, Charset srcEncoding,
                             File target, Charset tgtEncoding)
                                                             throws IOException {
    try (InputStream in = new FileInputStream(source);
         Reader reader = new InputStreamReader(in, srcEncoding);
         OutputStream out = new FileOutputStream(target);
         Writer writer = new OutputStreamWriter(out, tgtEncoding)) {
        char[] buffer = new char[1024];
        int r;
        while ((r = reader.read(buffer)) != -1) {
            writer.write(buffer, 0, r);
        }
    }
}

AutoCloseable 类型将自动关闭：

public class Foo {
  public static void main(String[] args) {
    class CloseTest implements AutoCloseable {
      public void close() {
        System.out.println("Close");
      }
    }
    try (CloseTest closeable = new CloseTest()) {}
  }
}

Answer 2

虽然存在一些问题，但您在网上发现的代码确实很差。

关闭缓冲区流会关闭下面的流。 你真的不想这样做。 您要做的就是刷新输出流。 此外，指定底层流用于文件也是没有意义的。 性能很差，因为您一次复制一个字节（实际上，如果您使用 java.io，可以使用 TransferTo/transferFrom，这仍然更快一点）。 当我们谈论它时，变量名称很糟糕。 所以：

public static void copy(
    InputStream in, OutputStream out
) throw IOException {
    byte[] buff = new byte[8192];
    for (;;) {
        int len = in.read(buff);
        if (len == -1) {
            break;
        }
        out.write(buff, 0, len);
    }
}

如果您发现自己经常使用 try-finally，那么您可以使用“execute around”习惯用法将其分解出来。

在我看来：Java 应该有某种方式在作用域结束时关闭资源。 我建议添加 private 作为一元后缀运算符以在封闭块的末尾关闭。

Answer 3

不幸的是，这种类型的代码在 Java 中往往会有点臃肿。

顺便说一句，如果对 oSBuffer.read 或 oDBuffer.write 的调用之一引发异常，那么您可能希望让该异常渗透到调用层次结构中。

在finally 子句中对close() 进行无保护的调用将导致原始异常被close() 调用产生的异常替换。 换句话说，失败的 close() 方法可能会隐藏 read() 或 write() 产生的原始异常。 因此，我认为如果并且仅其他方法没有抛出异常，您想忽略 close() 抛出的异常。

我通常通过在内部 try 中包含显式的关闭调用来解决此问题：

  try {
    while (...) {
      read...
      write...
    }
    oSBuffer.close(); // exception NOT ignored here
    oDBuffer.close(); // exception NOT ignored here
  } finally {
    silentClose(oSBuffer); // exception ignored here
    silentClose(oDBuffer); // exception ignored here
  }

  static void silentClose(Closeable c)  {
    try {
      c.close();
    } catch (IOException ie) {
      // Ignored; caller must have this intention
    }
  }

最后，为了性能，代码可能应该使用缓冲区（每次读/写多个字节）。 无法用数字来支持这一点，但更少的调用应该比在顶部添加缓冲流更有效。

Answer 4

是的，java就是这样工作的。 存在控制反转 - 对象的用户必须知道如何清理对象，而不是对象本身自行清理。 不幸的是，这会导致大量清理代码分散在您的 Java 代码中。

C# 具有“using”关键字，可以在对象超出范围时自动调用 Dispose。 Java没有这样的东西。

Answer 5

对于复制文件等常见 IO 任务，如上所示的代码是在重新发明轮子。 不幸的是，JDK 不提供任何更高级别的实用程序，但 apache commons-io 提供。

例如， FileUtils 包含用于处理文件和目录（包括复制）的各种实用方法。 另一方面，如果您确实需要使用 JDK 中的 IO 支持，IOUtils 包含一组 closeQuietly() 方法，可以关闭 Readers、Writers、Streams 等，而不引发异常。