Try-catch是用来帮助异常处理的。这意味着它将在某种程度上帮助我们的系统变得更加健壮:尝试从意外事件中恢复。

我们怀疑在执行和指令(发送消息)时可能会发生一些事情,因此它被包含在try中。如果发生了几乎意想不到的事情,我们可以做些什么:我们编写捕获。我不认为我们调用只是为了记录异常。我认为catch块是为了给我们从错误中恢复的机会。

现在,假设我们从错误中恢复,因为我们可以修复错误。如果能再试一次,那就太好了:

try{ some_instruction(); }
catch (NearlyUnexpectedException e){
   fix_the_problem();
   retry;
}

这将很快陷入永恒循环,但让我们假设fix_the_problem返回true,然后重试。假设在Java中没有这样的东西,你将如何解决这个问题?你认为解决这个问题的最佳设计代码是什么?

这就像一个哲学问题,因为我已经知道Java不直接支持我所要求的内容。


当前回答

解决这个问题的一个简单方法是在while循环中包装try/catch并维护一个计数。通过这种方式,您可以根据其他变量检查计数,同时维护故障日志,从而防止出现无限循环。这不是最精致的解决方案,但它是可行的。

其他回答

我不确定这是否是“专业”的方式来做这件事,我不完全确定它是否适用于所有事情。

boolean gotError = false;

do {
    try {
        // Code You're Trying
    } catch ( FileNotFoundException ex ) {
        // Exception
        gotError = true;
    }
} while ( gotError = true );

此解决方案允许您配置一个可重用的功能,以便在不使用任何外部库的情况下基于特定异常进行重试

//创建一个适合你需要的函数。

@FunctionalInterface
public interface ThrowableBiFunction<U,T,R> {
    R apply(U u ,T t) throws Exception;
}

//这是解决方案的关键

public interface ExceptionRetryable<T, U, R> {
    
 int getRetries();
   
 List<Class<? extends Exception>> getRetryableExceptions();

    default R execute(ThrowableBiFunction<T, U, R> function, T t, U u) throws Exception {
        int numberOfRetries = getRetries();
        return execute(function, t, u, numberOfRetries);
    }

    default R execute(ThrowableBiFunction<T, U, R> function, T t, U u, int retryCount) throws Exception {
        try {
            log.info(" Attempting to execute ExceptionRetryable#execute ,Number of remaining retries {} ",retryCount);
            return function.apply(t, u);
        } catch (Exception e) {

           log.info(" error occurred in ExceptionRetryable#execute",e);
            if (retryCount == 0)
                throw e;
            for (Class exp : getRetryableExceptions()) {
                if (e.getClass() == exp) {
                   return execute(function, t, u, retryCount - 1);
                }
            }
            throw e;
        }

    }
}

//创建一个异常可重执行的实现

public class TestRetryable implements ExceptionRetryable<String, String, List<String>> {
    @Override
    public int getRetries() {
        return 10;
    }

    @Override
    public List<Class<? extends Exception>> getRetryableExceptions() {
        return Arrays.asList(new Exception1().getClass(), new Exception2().getClass());
        ;
    }
}

//最后创建一个throwablebiffunction,它封装了需要在exception上重试的代码段和ExceptionRetryable实例

 TestRetryable retryable = new TestRetryable();
    ThrowableBiFunction<Integer,Long, String> testRetrablefcn = { i, l ->
           // your code goes here
};
    Integer i = 0;
    Long l = 1l;
      String output = testRetrablefcn.execute(testRetrablefcn,i,l); 

你需要像这样在while循环中封装try-catch: -

int count = 0;
int maxTries = 3;
while(true) {
    try {
        // Some Code
        // break out of loop, or return, on success
    } catch (SomeException e) {
        // handle exception
        if (++count == maxTries) throw e;
    }
}

我已经采取了count和maxTries,以避免运行到一个无限循环,以防异常继续发生在你的try块。

你可以使用https://github.com/bnsd55/RetryCatch

例子:

RetryCatch retryCatchSyncRunnable = new RetryCatch();
        retryCatchSyncRunnable
                // For infinite retry times, just remove this row
                .retryCount(3)
                // For retrying on all exceptions, just remove this row
                .retryOn(ArithmeticException.class, IndexOutOfBoundsException.class)
                .onSuccess(() -> System.out.println("Success, There is no result because this is a runnable."))
                .onRetry((retryCount, e) -> System.out.println("Retry count: " + retryCount + ", Exception message: " + e.getMessage()))
                .onFailure(e -> System.out.println("Failure: Exception message: " + e.getMessage()))
                .run(new ExampleRunnable());

你可以传递自己的匿名函数,而不是新的ExampleRunnable()。

虽然try/catch into while是众所周知的好策略,我想建议你递归调用:

void retry(int i, int limit) {
    try {

    } catch (SomeException e) {
        // handle exception
        if (i >= limit) {
            throw e;  // variant: wrap the exception, e.g. throw new RuntimeException(e);
        }
        retry(i++, limit);
    }
}