在对象构建期间从与主体分开的try-with-资源中捕获错误

Question

我有一个可关闭类型，CloseableClass，它可以在其构造函数、方法甚至内部抛出IOError。我想使用try-with-resources，但在处理构建过程中的错误时仍然与使用过程中的错误不同（使用包括清理）。更好的是，我想编写可维护的代码。

假设您希望构造一个可关闭的类实例并将其与try-with资源语句一起使用。它可以在其构造函数和try-with资源主体中使用的方法中抛出IOException：

import java.io.Closeable;
import java.io.IOException;
import java.util.Random;

public class CloseableClass implements Closeable {
    public CloseableClass() throws IOException {
        if (new Random().nextBoolean()) {
            throw new IOException();
        }
    }

    public void internetStuff() throws IOException {
        if (new Random().nextBoolean()) {
            throw new IOException();
        }
    }

    public void close() throws IOException {
        if (new Random().nextBoolean()) {
            throw new IOException();
        }
    }

    public static void main(String[] args) {
        try (CloseableClass closeable = new CloseableClass()) {
            closeable.internetStuff();
        }
        catch (IOException e) {
            System.out.println("Bad error!");
        }
    }
}

假设您想分别处理构造函数和主体中抛出的错误。有没有支持的方法可以做到这一点？在Python中，我会：

try:
    closeable = CloseableClass()
except IOException:
    print("Constructor error")
    return

try:
    with closeable:
        closeable.internet_stuff()
except IOException:
    print("Body error")

但在Java中，如果不为对象指定第二个名称，则无法执行以下操作：

CloseableClass closeable_;

try {
    closeable_ = new CloseableClass();
}
catch (IOException e) {            
    System.out.println("Constructor error!");
    return;
}

try (CloseableClass closeable = closeable_) {
    closeable.internetStuff();
}
catch (IOException e) {
    System.out.println("Body error!");
}

有人告诉我，这是“无法维护的代码”，主要是因为使用了“closeable\uu”，我对此表示同意。我希望避免使用try finally，因为如果使用try finally，您在模拟它时会遇到更糟糕的问题：

CloseableClass closeable;

try {
    closeable = new CloseableClass();
}
catch (IOException e) {            
    System.out.println("Constructor error!");
    return;
}

try {
    closeable.internetStuff();
}
catch (IOException e) {
    try {
        closeable.close();
    }
    catch (IOException ignore) {
        // Already dealing with this
    }

    System.out.println("Body error!");
}
finally {
    try {
        closeable.close();
    }
    catch (IOException e) {
        System.out.println("Body error!");
    }
}

注意，这需要第二次调用关闭（no op），测试类不遵守这一点（注意，自动关闭（AutoCloseable）不需要这一点，尽管关闭（AutoCloseable）需要这一点）。如果关闭时不能抛出，但不会抛出太多，这会更好一些。

基本上问题是

• 关闭可以抛出
• 在处理IOException之前关闭以防止打印“身体错误！”两次
• 如何让它与来自try with资源的多个初始化程序一起工作并不明显
• 无论如何，您最终都会复制代码。

我是被迫生活在“无法维护的代码”中，还是忽略了一个处理这个问题的好方法？




Answer 1

从Java9开始，try-with-资源已经接受了“有效的最终”变量，因此您不需要重新分配变量。

CloseableClass closeable;

try {
    closeable = new CloseableClass();
}
catch (IOException e) {            
    System.out.println("Constructor error!");
    return;
}

try (closeable) {
    closeable.internetStuff();
}
catch (IOException e) {
    System.out.println("Body error!");
}

Answer 2

一种解决方案是定义一种方法，将初始化错误封装在自定义异常类型中，然后使用该方法确定错误发生的时间。

private CloseableClass createCloseable() throws CloseableCreateException{
    try {
        return new CloseableClass();
    } except (IOException e) {
        throw new CloseableCreateException(e);
    }
}

try (CloseableClass closeable = initCloseable()) {
    closeable.internetStuff();
} catch (CloseableCreateException e) {
    System.out.println("Constructor error!");
} catch (IOException e) {
    System.out.println("Body error!");
}

另一个简单但有点不优雅的解决方案是使用布尔标志：

boolean init = true;
try (CloseableClass closeable = new CloseableClass()) {
    init = false;
    closeable.internetStuff();
} catch (IOException e) {
    if (init) {
        System.out.println("Constructor error!");
    } else {
        System.out.println("Body error!");
    }
}

Answer 3

匿名用户

'注意，这需要第二次调用close以成为no op'-不，您不需要在catch块中执行close（），因为最后总是要执行。如果使用类似于系统的调用终止JVM，则只会在catch中使用close（）block。exit（）在捕捉块中。通常，您会从catch时钟向调用方抛出异常，但您将在大部分时间内最终执行清理。

尝试与资源更好，但您可以使用抛出的Exception的类型和描述来破译错误的内容和位置。

编辑

据我所知，我建议：

1） 试用资源：

try(Resource resource = new Resource()){
    // use resource.
}catch(Exception e){
    // handle exception.
    // OR better to throw exception to caller.
    throw e;
}

2） 传统风格：

Resource resource = null;
try{
    resource = new Resource();
    // use resource
}catch(Exception e){
    // handle exception.
    // OR better to throw exception to caller.
    throw e;
} finally {
   if(resource != null){
       try{
           resource.close();
       } catch(Exception e){
           // most of time you wont or cant do anything here.
       }
   }
}