Try-catch是用来帮助异常处理的。这意味着它将在某种程度上帮助我们的系统变得更加健壮:尝试从意外事件中恢复。
我们怀疑在执行和指令(发送消息)时可能会发生一些事情，因此它被包含在try中。如果发生了几乎意想不到的事情，我们可以做些什么:我们编写捕获。我不认为我们调用只是为了记录异常。我认为catch块是为了给我们从错误中恢复的机会。
现在，假设我们从错误中恢复，因为我们可以修复错误。如果能再试一次，那就太好了:
try{ some_instruction(); }
catch (NearlyUnexpectedException e){
fix_the_problem();
retry;
}
这将很快陷入永恒循环，但让我们假设fix_the_problem返回true，然后重试。假设在Java中没有这样的东西，你将如何解决这个问题?你认为解决这个问题的最佳设计代码是什么?
这就像一个哲学问题，因为我已经知道Java不直接支持我所要求的内容。
当前回答
Try-Catch所做的就是允许程序优雅地失败。在catch语句中，通常尝试记录错误，如果需要，可能还会回滚更改。
bool finished = false;
while(finished == false)
{
try
{
//your code here
finished = true
}
catch(exception ex)
{
log.error("there was an error, ex");
}
}
其他回答
我不确定这是否是“专业”的方式来做这件事，我不完全确定它是否适用于所有事情。
boolean gotError = false;
do {
try {
// Code You're Trying
} catch ( FileNotFoundException ex ) {
// Exception
gotError = true;
}
} while ( gotError = true );
生产就绪代码:
@FunctionalInterface
public interface Operation {
void doCall() throws IOException;
default void handleException(Exception e) {
//Your custom default implementation
}
public class OperationHelper {
public static void doWithRetry(int maxAttempts, Operation operation) {
for (int count = 0; count <= maxAttempts; count++) {
try {
operation.doCall();
return;
} catch (Exception e) {
if (count == maxAttempts) {
e.printStackTrace();
return;
} else {
operation.handleException(e);
}
}
}
}
}
在代码中使用默认实现:
OperationHelper.doWithRetry(10,
() -> //do your job );
当需要自定义异常句柄时使用:
OperationHelper.doWithRetry(10, new Operation() {
@Override public void doIt() {
//do some stuff
}
@Override public void handleException(Exception cause) {
//recover from the Exception
}
});
此解决方案允许您配置一个可重用的功能，以便在不使用任何外部库的情况下基于特定异常进行重试
//创建一个适合你需要的函数。
@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并维护一个计数。通过这种方式，您可以根据其他变量检查计数，同时维护故障日志，从而防止出现无限循环。这不是最精致的解决方案，但它是可行的。
尝试使用spring @Retryable注解，当RuntimeException发生时，下面的方法将重试3次
@Retryable(maxAttempts=3,value= {RuntimeException.class},backoff = @Backoff(delay = 500))
public void checkSpringRetry(String str) {
if(StringUtils.equalsIgnoreCase(str, "R")) {
LOGGER.info("Inside retry.....!!");
throw new RuntimeException();
}
}
