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

Question

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

我的意思是，如果某些东西抛出异常，则应该跳过抛出异常的函数之后的代码。

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

异常嵌套

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

Return 出现异常

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

我有时会同时使用所有这些，那真是一团糟。对于如何处理这种情况，有什么好的做法吗？

Answer 1

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

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

Answer 2

使用方式取决于异常是由someFunction()方法的client处理还是一发生就捕获并处理，即在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 语句之后有一些其他指令，并且您希望即使捕获到预期的异常之一也能执行这些指令，这种做法是合适的。

异常情况 return 表明了一个足够接近的问题。
它可以用一个 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!");
    }
}

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

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

Exception handling practices of multiple exception throwing functions

java

coding-style

exception-handling

exception