java - 在 java 中，有没有办法确保在 finally block 中调用多个方法？

Question

所以我有一个 try/finally block 。我需要在 finally block 中执行许多方法。但是，这些方法中的每一个都可能引发异常。有没有办法确保在没有嵌套的 finally block 的情况下调用(或尝试)所有这些方法？

这就是我现在所做的，非常丑陋:

protected void verifyTable() throws IOException {
    Configuration configuration = HBaseConfiguration.create();
    HTable hTable = null;                                               

    try {
        hTable = new HTable(configuration, segmentMatchTableName);      

        //...
        //various business logic here
        //...

    } finally {                         
        try {
            try {
                if(hTable!=null) {
                    hTable.close(); //This can throw an IOException
                }               
            } finally {
                try {
                    generalTableHelper.deleteTable(configuration, segmentMatchTableName); //This can throw an IOException
                } finally {
                    try {
                        generalTableHelper.deleteTable(configuration, wordMatchTableName); //This can throw an IOException
                    } finally {
                        generalTableHelper.deleteTable(configuration, haplotypeTableName); //This can throw an IOException      
                    }
                }
            }                               
        } finally {
            HConnectionManager.deleteConnection(configuration, true); //This can throw an IOException   
        }
    }               
}

有没有更优雅的方法来做到这一点？

Answer 1

Java 中权限资源管理的标准(有效)方法(该原则也适用于其他语言)是:

Resource resource = acquire(resource);
try {
    use(resource);
} finally {
    resource.release();
}

或者在当前版本的 Java SE 中使用快捷方式(更聪明一点):

try (Resource resource = acquire(resource)) {
    use(resource);
}

(正如 Joe K 指出的那样，您可能需要包装资源以使其确认 Java 语言所依赖的特定接口(interface)。)

两个资源，你只需应用两次成语:

Resource resource = acquire(resource);
try {
    SubResource sub = resource.acquire();
    try {
        use(sub);
    } finally {
        sub.release();
    }
} finally {
    resource.release();
}

在 Java SE 7 中:

try (
    Resource resource = acquire(resource);
    SubResource sub = resource.acquire()
) {
    use(resource, sub);
}

新语言功能的真正巨大优势在于，资源处理在编写时经常会中断。

您可能有更复杂的异常处理。例如，您不想将诸如 IOException 之类的低级异常抛出到应用程序本身 - 您可能希望包装在 RuntimeException 的某些子类型中。由于 Java 典型的冗长性，这可以使用 Execute Around 习惯用法(参见 this excellent question )来分解。从 Java SE 8 开始，还将有更短的语法和随机不同的语义。

with(new ResourceSubAction() { public void use(Resource resource, SubResource sub) {
    ... use resource, sub ...
}});