¿Cómo implementar un re-try-catch?

Solución "emprendedora" obligatoria:

public abstract class Operation {
    abstract public void doIt();
    public void handleException(Exception cause) {
        //default impl: do nothing, log the exception, etc.
    }
}

public class OperationHelper {
    public static void doWithRetry(int maxAttempts, Operation operation) {
        for (int count = 0; count < maxAttempts; count++) {
            try {
                operation.doIt();
                count = maxAttempts; //don't retry
            } catch (Exception e) {
                operation.handleException(e);
            }
        }
    }
}

Y llamar:

OperationHelper.doWithRetry(5, new Operation() {
    @Override public void doIt() {
        //do some stuff
    }
    @Override public void handleException(Exception cause) {
        //recover from the Exception
    }
});

Como de costumbre, el mejor diseño depende de las circunstancias particulares. Por lo general, sin embargo, escribo algo como:

for (int retries = 0;; retries++) {
    try {
        return doSomething();
    } catch (SomeException e) {
        if (retries < 6) {
            continue;
        } else {
            throw e;
        }
    }
}

Aunque try/catch dentro de while es una estrategia bien conocida y buena, quiero sugerirte una llamada recursiva:

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

Puedes usar anotaciones AOP y Java desde jcabi-aspects (soy desarrollador):

@RetryOnFailure(attempts = 3, delay = 5)
public String load(URL url) {
  return url.openConnection().getContent();
}

También puedes usar @Loggable y @LogException anotaciones.

Su escenario exacto manejado a través de A prueba de fallos :

RetryPolicy retryPolicy = new RetryPolicy()
  .retryOn(NearlyUnexpectedException.class);

Failsafe.with(retryPolicy)
  .onRetry((r, f) -> fix_the_problem())
  .run(() -> some_instruction());

Bastante simple.

La mayoría de estas respuestas son esencialmente las mismas. La mía también, pero esta es la forma que me gusta

boolean completed = false;
Throwable lastException = null;
for (int tryCount=0; tryCount < config.MAX_SOME_OPERATION_RETRIES; tryCount++)
{
    try {
        completed = some_operation();
        break;
    }
    catch (UnlikelyException e) {
        lastException = e;
        fix_the_problem();
    }
}
if (!completed) {
    reportError(lastException);
}

Use un bucle while con una bandera local status. Inicialice el indicador como false y establézcalo en true cuando la operación se realice correctamente, por ejemplo, a continuación:

  boolean success  = false;
  while(!success){
     try{ 
         some_instruction(); 
         success = true;
     } catch (NearlyUnexpectedException e){
       fix_the_problem();
     }
  }

Esto seguirá volviendo a intentarlo hasta que tenga éxito.

Si desea volver a intentarlo solo un cierto número de veces, use un contador también:

  boolean success  = false;
  int count = 0, MAX_TRIES = 10;
  while(!success && count++ < MAX_TRIES){
     try{ 
         some_instruction(); 
         success = true;
     } catch (NearlyUnexpectedException e){
       fix_the_problem();
     }
  }
  if(!success){
    //It wasn't successful after 10 retries
  }

Esto intentará máximo 10 veces si no tiene éxito hasta entonces un saldrá si su éxito antes de la mano.

Una forma sencilla de resolver el problema sería envolver el try/catch en un bucle while y mantener un conteo. De esta manera, podría evitar un bucle infinito comprobando un recuento contra alguna otra variable mientras mantiene un registro de sus errores. No es la solución más exquisita, pero funcionaría.

En caso de que sea útil, un par de opciones más a considerar, todas juntas (stopfile en lugar de reintentos, sleep, continue loop más grande), todas posiblemente útiles.

 bigLoop:
 while(!stopFileExists()) {
    try {
      // do work
      break;
    }
    catch (ExpectedExceptionType e) {

       // could sleep in here, too.

       // another option would be to "restart" some bigger loop, like
       continue bigLoop;
    }
    // ... more work
}

Puedes usar https://github.com/bnsd55/RetryCatch

Ejemplo:

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

En lugar de new ExampleRunnable() puede pasar su propia función anónima.

Todo lo que hace un Try-Catch es permitir que su programa falle correctamente. En una instrucción catch, generalmente intenta registrar el error y tal vez revertir los cambios si es necesario.

bool finished = false;

while(finished == false)
{
    try
    {
        //your code here
        finished = true
    }
    catch(exception ex)
    {
        log.error("there was an error, ex");
    }
}

Utilice un do-while para diseñar el bloque re-try.

boolean successful = false;
int maxTries = 3;
do{
  try {
    something();
    success = true;
  } catch(Me ifUCan) {
    maxTries--;
  }
} while (!successful || maxTries > 0)

Sé que ya hay muchas respuestas similares aquí, y la mía no es muy diferente, pero la publicaré de todos modos porque trata de un caso/tema específico.

Cuando se trata de la facebook Graph API en PHP a veces se obtiene un error, pero inmediatamente volver a intentar la misma cosa dará un resultado positivo (por varias mágicas Razones de Internet que están más allá del alcance de esta pregunta). En este caso no hay necesidad de corregir cualquier error, sino simplemente intentarlo de nuevo porque hay fue una especie de "error de Facebook".

Este código se usa inmediatamente después de crear una sesión de facebook:

//try more than once because sometimes "facebook error"
$attempt = 3;
while($attempt-- > 0)
{
    // To validate the session:
    try 
    {
        $facebook_session->validate();
        $attempt = 0;
    } 
    catch (Facebook\FacebookRequestException $ex)
    {
        // Session not valid, Graph API returned an exception with the reason.
        if($attempt <= 0){ echo $ex->getMessage(); }
    } 
    catch (\Exception $ex) 
    {
        // Graph API returned info, but it may mismatch the current app or have expired.
        if($attempt <= 0){ echo $ex->getMessage(); }
    }
}

Además, al tener la cuenta atrás del bucle for a cero ($attempt--) hace que sea bastante fácil cambiar el número de intentos en el futuro.

Siguiente es mi solución con un enfoque muy simple!

               while (true) {
                    try {
                        /// Statement what may cause an error;
                        break;
                    } catch (Exception e) {

                    }
                }

No estoy seguro de si esta es la forma "Profesional" de hacerlo y no estoy del todo seguro de si funciona para todo.

boolean gotError = false;

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

Https://github.com/tusharmndr/retry-function-wrapper/tree/master/src/main/java/io

int MAX_RETRY = 3; 
RetryUtil.<Boolean>retry(MAX_RETRY,() -> {
    //Function to retry
    return true;
});

Aquí un enfoque reutilizable y más genérico para Java 8 + que no requiere bibliotecas externas:

public interface IUnreliable<T extends Exception>
{
    void tryRun ( ) throws T;
}

public static <T extends Exception> void retry (int retryCount, IUnreliable<T> runnable) throws T {
    for (int retries = 0;; retries++) {
        try {
            runnable.tryRun();
            return;
        } catch (Exception e) {
            if (retries < retryCount) {
                continue;
            } else {
                throw e;
            }
        }
    }
}

Uso:

@Test
public void demo() throws IOException {
    retry(3, () -> {
        new File("/tmp/test.txt").createNewFile();
    });
}