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

Question

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

这里的“依赖”指的是如果某个函数抛出异常，该函数后面的代码应该被跳过。

我想到了三种方法来处理： 1. 异常嵌套

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();
    ...
}

我有时会把它们都一起使用，这很混乱。有没有关于如何处理这种情况的好方法？

- Dave-it

Answer 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!");
    }
}

最后，在方法签名中添加异常的情况只有在客户端需要处理异常时才会有意义。

- davidxxx

Answer 2

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

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

- Nayeem Zen