是否有一种优雅的方式来处理finally 块中抛出的异常？
例如：
try {
// Use the resource.
}
catch( Exception ex ) {
// Problem with the resource.
}
finally {
try{
resource.close();
}
catch( Exception ex ) {
// Could not close the resource?
}
}
如何避免finally 块中的try/catch？
【问题讨论】：
标签： java exception try-catch finally
我遇到过类似的情况，我无法对资源使用 try，但我也想处理来自关闭的异常，而不仅仅是像 closeQuietly 机制那样记录并忽略它。就我而言，我实际上并没有处理输出流，因此关闭失败比简单的流更有趣。
IOException ioException = null;
try {
outputStream.write("Something");
outputStream.flush();
} catch (IOException e) {
throw new ExportException("Unable to write to response stream", e);
}
finally {
try {
outputStream.close();
} catch (IOException e) {
ioException = e;
}
}
if (ioException != null) {
throw new ExportException("Unable to close outputstream", ioException);
}
【讨论】：
将 Resource 从 best answer 更改为 Closeable
Streams 实现了Closeable，因此您可以对所有流重用该方法
protected void closeQuietly(Closeable resource) {
if (resource == null)
return;
try {
resource.close();
} catch (IOException e) {
//log the exception
}
}
【讨论】：
从 Java 7 开始，您不再需要在 finally 块中显式关闭资源，而是可以使用 try-with-resources 语法。 try-with-resources 语句是声明一个或多个资源的 try 语句。资源是程序完成后必须关闭的对象。 try-with-resources 语句确保每个资源在语句结束时关闭。任何实现 java.lang.AutoCloseable 的对象，包括所有实现 java.io.Closeable 的对象，都可以用作资源。
假设以下代码：
try( Connection con = null;
Statement stmt = con.createStatement();
Result rs= stmt.executeQuery(QUERY);)
{
count = rs.getInt(1);
}
如果发生任何异常，close 方法将在这三个资源中的每一个上以与它们创建时相反的顺序被调用。这意味着将首先为 ResultSetm 调用 close 方法，然后是 Statement，最后是 Connection 对象。
知道自动调用 close 方法时发生的任何异常都会被抑制，这一点也很重要。这些被抑制的异常可以通过 Throwable 类中定义的 getsuppressed() 方法检索。
来源：https://docs.oracle.com/javase/tutorial/essential/exceptions/tryResourceClose.html
【讨论】：
我通常使用org.apache.commons.io.IOUtils 中的closeQuietly 方法之一：
public static void closeQuietly(OutputStream output) {
try {
if (output != null) {
output.close();
}
} catch (IOException ioe) {
// ignore
}
}
【讨论】：
忽略出现在“finally”块中的异常通常是一个坏主意，除非知道这些异常是什么以及它们代表什么条件。在正常的try/finally 使用模式中，try 块将事物置于外部代码不期望的状态，finally 块将这些事物的状态恢复为外部代码期望的状态。捕获异常的外部代码通常会期望，尽管出现异常，但一切都已恢复到normal 状态。例如，假设某些代码启动了一个事务，然后尝试添加两条记录； “finally”块执行“如果未提交则回滚”操作。调用者可能已准备好在执行第二个“添加”操作期间发生异常，并且可能期望如果它捕获此类异常，则数据库将处于尝试任一操作之前的状态。但是，如果在回滚期间发生第二个异常，如果调用者对数据库状态做出任何假设，则可能会发生不好的事情。回滚失败代表了一个重大危机——不应被期望仅仅“添加记录失败”异常的代码捕获。
我个人倾向于使用 finally 方法捕获发生的异常并将它们包装在“CleanupFailedException”中，认识到此类失败代表一个主要问题，不应轻易捕获此类异常。
【讨论】：
如果您使用的是 Java 7，并且 resource 实现了 AutoClosable，您可以这样做（以 InputStream 为例）：
try (InputStream resource = getInputStream()) {
// Use the resource.
}
catch( Exception ex ) {
// Problem with the resource.
}
【讨论】：
经过大量考虑，我发现以下代码最好：
MyResource resource = null;
try {
resource = new MyResource();
resource.doSomethingFancy();
resource.close();
resource = null;
} finally {
closeQuietly(resource)
}
void closeQuietly(MyResource a) {
if (a!=null)
try {
a.close();
} catch (Exception e) {
//ignore
}
}
该代码保证如下：
【讨论】：
可以说有点过头了，但如果你让异常冒泡并且你不能从你的方法中记录任何东西（例如，因为它是一个库，你宁愿让调用代码处理异常和记录）：
Resource resource = null;
boolean isSuccess = false;
try {
resource = Resource.create();
resource.use();
// Following line will only run if nothing above threw an exception.
isSuccess = true;
} finally {
if (resource != null) {
if (isSuccess) {
// let close throw the exception so it isn't swallowed.
resource.close();
} else {
try {
resource.close();
} catch (ResourceException ignore) {
// Just swallow this one because you don't want it
// to replace the one that came first (thrown above).
}
}
}
}
更新：我对此进行了更多研究，发现一个比我更清楚地考虑这一点的人写了一篇很棒的博客文章：http://illegalargumentexception.blogspot.com/2008/10/java-how-not-to-make-mess-of-stream.html 他更进一步，将两个例外合二为一，我可以看到在某些情况下很有用。
【讨论】：
ignore 异常
我通常这样做：
try {
// Use the resource.
} catch( Exception ex ) {
// Problem with the resource.
} finally {
// Put away the resource.
closeQuietly( resource );
}
其他地方：
protected void closeQuietly( Resource resource ) {
try {
if (resource != null) {
resource.close();
}
} catch( Exception ex ) {
log( "Exception during Resource.close()", ex );
}
}
【讨论】：
Resource => Closeable?
try {
final Resource resource = acquire();
try {
use(resource);
} finally {
resource.release();
}
} catch (ResourceException exx) {
... sensible code ...
}
工作完成。没有空测试。单次捕获，包括获取和释放异常。当然，您可以使用 Execute Around 习惯用法，并且只需为每种资源类型编写一次。
【讨论】：
我通常这样做：
MyResource r = null;
try {
// use resource
} finally {
if( r != null ) try {
r.close();
} catch( ThatSpecificExceptionOnClose teoc ){}
}
基本原理：如果我用完了资源，唯一的问题就是关闭它，我就无能为力了。如果我用完资源，杀死整个线程也没有意义。
这是一种情况，至少对我来说，忽略检查的异常是安全的。
直到今天我在使用这个成语时还没有遇到任何问题。
【讨论】：
您可以将其重构为另一种方法...
public void RealDoSuff()
{
try
{ DoStuff(); }
catch
{ // resource.close failed or something really weird is going on
// like an OutOfMemoryException
}
}
private void DoStuff()
{
try
{}
catch
{
}
finally
{
if (resource != null)
{
resource.close();
}
}
}
【讨论】：
为什么要避免附加块？由于 finally 块包含可能引发异常的“正常”操作，并且您希望 finally 块完全运行，您必须捕获异常。
如果您不希望 finally 块抛出异常并且您不知道如何处理异常（您只会转储堆栈跟踪）让异常在调用堆栈中冒泡（删除 try-catch从 finally 块）。
如果你想减少打字，你可以实现一个“全局”外部 try-catch 块，它将捕获 finally 块中抛出的所有异常：
try {
try {
...
} catch (Exception ex) {
...
} finally {
...
}
try {
...
} catch (Exception ex) {
...
} finally {
...
}
try {
...
} catch (Exception ex) {
...
} finally {
...
}
} catch (Exception ex) {
...
}
【讨论】：
如果可以的话，你应该测试一下，以避免一开始就出现错误情况。
try{...}
catch(NullArgumentException nae){...}
finally
{
//or if resource had some useful function that tells you its open use that
if (resource != null)
{
resource.Close();
resource = null;//just to be explicit about it was closed
}
}
此外，您可能应该只捕获可以从中恢复的异常，如果您无法恢复，则让它传播到程序的顶层。如果您无法测试错误情况，您将不得不像您已经完成的那样用 try catch 块包围您的代码（尽管我建议仍然捕获特定的预期错误）。
【讨论】：
一个解决方案，如果两个异常是两个不同的类
try {
...
}
catch(package1.Exception err)
{
...
}
catch(package2.Exception err)
{
...
}
finally
{
}
但有时你无法避免第二次尝试捕捉。例如用于关闭流
InputStream in=null;
try
{
in= new FileInputStream("File.txt");
(..)// do something that might throw an exception during the analysis of the file, e.g. a SQL error
}
catch(SQLException err)
{
//handle exception
}
finally
{
//at the end, we close the file
if(in!=null) try { in.close();} catch(IOException err) { /* ignore */ }
}
【讨论】：