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

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

异常返回

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

使用方式取决于异常是应该由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!");
    }
}

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