Question

我使用核心java开发测试框架。在我的应用程序中，我有一个父方法，它调用十个不同的子方法，其中每个方法都可以抛出自己的异常。要求是提供有关父方法执行的详细日志信息，其中包含执行方法所花费的总时间，执行每个子方法所花费的时间，记录任何异常等信息。我正在使用多个try catch finally块。

我的问题是，如果其中一个子方法抛出异常，跳过剩余子方法执行的最佳方法是什么？例如：如果方法4抛出异常，我想记录该异常并转到结尾并记录父方法所用的时间，直到那时为止。

我尝试在父方法的开头使用布尔变量将其初始化为true。我在执行每个子方法之前检查boolean varible是否为true。每当抛出异常时，我都将布尔变量标记为false。

我的伪代码如下：

public String parentMethod(){
    boolean execute = true;
    if(execute) {
        try event1; 
        catch(Event1Exception e1)  
            log e1; execute = false; 
        finally log event 1 time taken;
    }
    if(execute) {
        try event2; 
        catch(Event1Exception e2)  
            log e2; execute = false; 
        finally log event 2 time taken;
    }
    and so on ....
    log total time taken;

在我的实际代码中，我有大约十个不同的事件，它们抛出自己的异常，有时不止一个。使用这种方法，为捕获的每个异常分配execute = false，然后再次检查execute的值似乎很笨拙。有没有比这更好的方法，而不使用任何额外的插件？

Answer 1

您可以记录异常并重新抛出它：

public String parentMethod(){
    try {
        try {
            ... 
        } catch(Event1Exception e1) { 
            log e1;
            throw e1;
        } finally {
            log event 1 time taken;
        }

        try {
            ... 
        } catch(Event2Exception e2) { 
            log e2;
            throw e2;
        } finally {
            log event 2 time taken;
        }

    } catch (Event1Exception | Event2Exception | ... e) {
        // Can be safely ignored
    }
}

或者，如果您不想单独处理每个例外，您可以这样做：

public String parentMethod(){
    try {
        try {
            ... 
        } finally {
            log event 1 time taken;
        }

        try {
            ... 
        } finally {
            log event 2 time taken;
        }

    } catch (Event1Exception | Event2Exception | ... e) {
        log e
    }
}

Answer 2

嗨Sree我会建议在单个try块中使用方法调用。在此try块的末尾写下具有不同异常的所有catch块。每当任何方法抛出异常时，控制将直接转到相应的catch块，跳过剩余的方法调用。

例如：

try
{
    method1(); // Exception1 occured
    method2(); // skipped
    method3(); // skipped
}
catch(Exception1 e)
{
    // control goes here
    // End timer 

    // Calculate difference
    // Store difference in global variable
}
catch(Exception2 e)
{
}
catch(Exception3 e)
{
}

method1()
{
    // start timer

    // your code

    // End timer, if no exception occurred
    // Store difference in global variable
}

希望这会有所帮助。： - ）

Answer 3

如果您只对第一个异常感兴趣，那么您可以在一个try-catch块中执行所有事件，并处理catch块中的任何抛出异常。

try {
    event1();
    event2();
    // etc
} catch(Exception e) {
    //Handle
}

否则为每个进程启动一个线程，并在一个失败时立即终止所有其他线程来处理失败。

Answer 4

看起来你有点过分思考。 try-catch构造已经为您提供了您想要的东西。考虑一下：

try {
     method1();
     method2();
     method3();
     method4();
 } catch(Exception e) {
   //do error hanlig here (log it for example)
 }

在这种情况下，说数学模型1和2成功执行，method3抛出异常 - 控件将进入catch块，method4将 NOT 执行。如果我正确地感觉到你正是你所需要的那样

Answer 5

这里没有答案：不要这样做。

听起来就像你在这里违反单一责任原则一样。一个类/方法应该有一个目的，而且只有一个目的！

含义：你必须要调用10种不同的其他方法 - 在一个如此复杂的环境中你认为值得在这里提出一个问题。

所以，我的建议宁愿退一步看看你是否可以重新考虑你的代码库，最终以某种方式捆绑在一起的不同的方法调用结束！

当你真的无法调用10种方法时，只需使用multiatch：

 try {
   foo();
   bar();
   ...
 } catch (ExceptionA | ExceptionB | ...

除此之外：你应该绝对致力于防止代码重复。想到这样的事情：

private interface CallContext<T, X extends Throwable> {
  T execute() throws X;
}

private static <T, X extends Throwable> T runTimed(CallContext<T, X> context) throws X {
     prepare timer
     T result = context.execute();
     put timed value somewhere
     return result;
}

使用这样的东西：

try {
  SomeT t = runTimed(() -> return foo());
} catch (ExceptionA a) ...

如果其中一个子方法抛出异常，则跳过代码执行的最佳设计模式

5 个答案: