多个异常抛出函数的异常处理实践答案

【问题标题】：Exception handling practices of multiple exception throwing functions多个异常抛出函数的异常处理实践
【发布时间】：2017-04-13 16:04:49
【问题描述】：

如果我在一个函数中有多个抛出异常的函数，如果它们相互依赖，那么处理它们的最佳方法是什么？

相互依赖我的意思是，如果某些东西引发异常，则应该跳过引发异常的函数之后的代码。

我想出了三种方法来做到这一点：

异常嵌套

public void parent() {
    someFunction();
}

public void someFunction() {
    try {
        function1();
        try {
            function2();
            ...
        } catch (Func2xception e) {
            System.out.println("Function 2 failed!");
        }
    } catch (Func1Exception e) {
        System.out.println("Function 1 failed!");
    }
}

异常返回

public void parent() {
    someFunction();
}

public void someFunction() {
    try {
        function1();
    } catch (Func1Exception e) {
        System.out.println("Function 1 failed!");
        return;
    }

    try {
        function2();
    } catch (Func2xception e) {
        System.out.println("Function 2 failed!");
        return;
    }

    ...
}

为方法签名添加例外

public void parent() {
    try {
        someFunction();
    } catch (Func1Exception e) {
        System.out.println("Function 1 failed!");
    } catch (Func2Exception e) {
        System.out.println("Function 2 failed!");
    } ...
}

public void someFunction() throws Func1Exception, Func2Exception {
    function1();
    function2();
    ...
}

我有时会同时使用所有这些，这很混乱。有没有关于如何处理此类情况的良好做法？

【问题讨论】：

标签： java exception exception-handling coding-style

【解决方案1】：

使用方式取决于异常应该由someFunction()方法的客户端处理，还是在发生时立即捕获并处理，即在someFunction()方法内部。

在异常嵌套情况中，不需要嵌套。
您可以使用单个 try 语句并将可能生成异常的两个调用放在其中。
如果在两个调用的方法之一中发生异常，则在 catch 语句之一中完成，因此仅当第一个方法未引发捕获的异常时才执行第二个方法。它产生的结果与您的代码完全相同，但只有一个 try 并且没有嵌套，可读性较差。

public void someFunction() {
    try {
        function1();    
        function2();
            ...      
    } catch (Func1Exception e) {
        System.out.println("Function 1 failed!");
    }
    catch (Func2xception e) {
        System.out.println("Function 2 failed!");
    }    
}

如果您在 catch 语句之后还有一些其他指令并且您希望即使捕获到预期的异常之一也能执行这些指令，则这种方式是合适的。

返回异常情况表明了一个足够接近的问题。
可以用一个 try 重构它：

    public void someFunction() {
        try {
            function1();    
            function2();
                ...      
        } catch (Func1Exception e) {
            System.out.println("Function 1 failed!");
            return;
        }
        catch (Func2xception e) {
            System.out.println("Function 2 failed!");
            return;
        }    
    }
    ...
}

如果您在 catch 语句之后有一些其他指令并且您不希望在捕获到预期异常之一时执行它们，则这种方式是合适的。

尽管如此，对于这两种情况，如果两个异常（Func1Exception 和 Func2xception）的异常处理相同，您可以将它们分组到一个 catch 语句中：

public void someFunction() {
    try {
        function1();    
        function2();
            ...      
    } 
    catch (Func1Exception | Func2xception e) {
        System.out.println("Function 1 or 2 failed!");
    }
}

最后，向方法签名案例添加异常只有在异常应该由方法的客户端处理时才有意义。

【讨论】：

【解决方案2】：

我相信从 Java 7 开始，您可以在一个 catch 子句中捕获多个异常。

try { 
  ...
} catch(IOException | IllegalArgumentException | SomeOtherException e) { 
  ...
}

【讨论】：