Question

因此，在某些方法中，我将打开一个新的IO流，对其进行一些处理，然后使用该流作为输入来打开另一个IO流。我不相信我可以使用单个try-with-resources块，因为第一个IO流处于打开第一个和第二个流之间的处理。因此，使用单个try-catch-finally块来打开和关闭这些流或使用嵌套的try-with-resources块来打开和关闭流更好（在编码设计意义上）？我知道如果第一个和第二个IO流之间没有处理，最好在一个try-with-resources块中打开所有三个流。

一个简单的例子如下：

尝试捕获，最后

void someMethod(InputStream is) throws SomeException {
   SomeIOStream io1 = null;
   SomeIOStream io2 = null;
   SomeIOStream io3 = null;

   try{
      io1 = new SomeIOStream( someSortOfProcessing() );
      io1.moreStreamProcessing();
      io2 = new SomeIOStream( someSortOfProcessing(io1) );
      io3 = new SomeIOStream (is);
      //do stuff with io2 and io3
   } catch (Throwable t) {
      //Exception Handling
   } finally {
      //closing streams io3, io2, io1, is
   }
}

尝试与 - 资源

void someMethod(InputStream is) throws SomeException {
   try ( SomeIOStream io1 = new SomeIOStream( someSortOfProcessing() ) ){
      io1.moreStreamProcessing();
      try ( SomeIOStream io2 = new SomeIOStream( someSortOfProcessing(io1) );
            SomeIOStreeam io3 = new SomeIOStream (is); ){
            //do stuff with io2 and io3
      }
   } catch (Throwable t) {
      //Exception Handling
   } finally {
      //closing stream is
   }
}

对我而言，看起来第一个更干净，但第二个具有资源试用块的好处。当然，另一个替代方案是使用try-with-resources打开初始io1，但在该try-block中打开io2和io3。那么第三种混合方法会比上面两种更好吗？

混合方法

void someMethod(InputStream is) throws SomeException {
   SomeIOStream io1 = null;
   SomeIOStream io2 = null;
   SomeIOStream io3 = null;

   try (SomeIOStream io1 = new SomeIOStream( someSortOfProcessing() ) ){
      io1.moreStreamProcessing();
      io2 = new SomeIOStream( someSortOfProcessing(io1) );
      io3 = new SomeIOStream (is);
      //do stuff with io2 and io3
   } catch (Throwable t) {
      //Exception Handling
   } finally {
      //closing streams io3, io2, is
   }
}

另外作为一个额外的问题，我是否正确地假设关闭InputStream is的唯一方法是将它放在finally块中？

Answer 1

这可能是基于意见的，但我当然希望尽可能多地使用try-with-resources。这清楚地显示了可关闭资源使用的范围，使程序逻辑更容易理解。如果您担心嵌套的try-with-resources块，请考虑将内部块提取到单独的方法中。

此外，如果您将流作为参数传递（在您的示例中为is），则关闭它通常不是一个好主意。如果调用者创建了这个流，那么调用者通常需要关闭它（最好使用调用方法中的try-with-resource语句）。最后，catch the Throwable很少有好主意。

Answer 2

看来，你不知道，资源尝试对你有什么作用。它不仅确保调用close()，还确保在close()失败并出现异常的情况下，它不会影响初始异常（如果有），而是记录使用addSuppressed的次要例外。

所以相当于

try(Resource r = allocation ) {
    …
}

是

{
    Resource r = allocation;
    Throwable primary = null;
    try {
        …
    }
    catch(Throwable t) { primary = t; }
    finally {
        if(r != null) try {
            r.close();
        }
        catch(Throwable t) {
            if(primary!=null) primary.addSuppressed(t); else primary=t;
        }
    }
    if(primary!=null) throw primary;
}

现在再想一想是否用资源语句重写任何，尝试手动执行此操作，创建更清晰的代码。即使没有正确处理关闭，你对资源语句的嵌套try的替代方法已经在代码大小上更大，更复杂并且扩展了变量的范围，超出了它们的实际用途。

相比之下，使用资源语句的嵌套try使用嵌套作用域中的资源准确反映了您正在执行的操作。如果你删除有问题的catch-all部分和关闭传入资源，它会变得更好。

请注意，在极少数情况下，关闭传入资源可能是可以接受的，例如：如果它是private方法并且行为有充分的记录。但即便如此，你也不应诉诸finally：

void someMethod(InputStream incomingIs) throws SomeException {
    try(InputStream is=incomingIs;// it must be documented that we will close incomingIs
        SomeIOStream io1 = new SomeIOStream(someSortOfProcessing()) ) {
        io1.moreStreamProcessing();
        try(SomeIOStream io2 = new SomeIOStream(someSortOfProcessing(io1));
            SomeIOStreeam io3 = new SomeIOStream (is) ) {
            //do stuff with io2 and io3
        }
    }
}

如果在打开新的流之间处理IO流，那么拥有一个try-finally块或嵌套try-with-resources会更好吗？

2 个答案: