java - sintaxe - try catch uso




Como você implementa um re-try-catch? (14)

A maioria dessas respostas é essencialmente a mesma. O meu também é, mas esta é a forma que eu gosto

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

https://code.i-harness.com

Try-catch destina-se a ajudar no tratamento de exceções. Isso significa que isso ajudará nosso sistema a ser mais robusto: tente se recuperar de um evento inesperado.

Suspeitamos que algo possa acontecer durante a execução e a instrução (enviando uma mensagem), de modo que ela seja incluída na tentativa. Se algo quase inesperado acontecer, podemos fazer algo: escrevemos a captura. Eu não acho que ligamos para registrar a exceção. Eu acho que o bloco catch serve para nos dar a oportunidade de nos recuperarmos do erro.

Agora, digamos que nos recuperamos do erro porque podemos consertar o que estava errado. Pode ser super legal fazer uma nova tentativa:

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

Isso cairia rapidamente no eterno loop, mas digamos que o fix_the_problem retorne true, então nós tentamos novamente. Dado que não existe tal coisa em Java, como você resolveria esse problema? Qual seria o seu melhor código de design para resolver isso?

Isso é como uma questão filosófica, já que eu já sei o que estou pedindo não é diretamente suportado pelo Java.


A seguir está minha solução com uma abordagem muito simples!

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

                    }
                }

Caso seja útil, mais algumas opções a considerar, todas juntas (stopfile em vez de tentativas, sleep, continue loop maior), todas possivelmente úteis.

 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
}

Como de costume, o melhor design depende das circunstâncias particulares. Geralmente, eu escrevo algo como:

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

Eu sei que já existem muitas respostas similares aqui, e a minha não é muito diferente, mas vou postar de qualquer maneira, porque ela lida com um caso / problema específico.

Ao lidar com a facebook Graph API do facebook Graph API no PHP você algumas vezes obtém um erro, mas imediatamente tentar novamente a mesma coisa dará um resultado positivo (por vários motivos mágicos da Internet que estão além do escopo desta questão). Neste caso, não há necessidade de corrigir nenhum erro, mas simplesmente tentar novamente porque houve algum tipo de "erro no facebook".

Este código é usado imediatamente após a criação de uma sessão no 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(); }
    }
}

Além disso, fazendo com que a contagem do loop for até zero ( $attempt-- ), é muito fácil alterar o número de tentativas no futuro.


Não tenho certeza se esta é a maneira "profissional" de fazê-lo e não tenho certeza se ele funciona para tudo.

boolean gotError = false;

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

Seu cenário exato tratado via Failsafe :

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

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

Bem simples.


Solução "empreendedora" obrigatória:

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

E para ligar:

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

Tudo o que um Try-Catch faz é permitir que seu programa falhe normalmente. Em uma instrução catch, você geralmente tenta registrar o erro e, talvez, reverter as alterações, se necessário.

bool finished = false;

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

Uma maneira simples de resolver o problema seria envolver o try / catch em um loop while e manter uma contagem. Desta forma, você poderia evitar um loop infinito, verificando uma contagem contra alguma outra variável, mantendo um log de suas falhas. Não é a solução mais requintada, mas funcionaria.


Use um loop while com o sinalizador de status local. Inicialize o sinalizador como false e defina-o como true quando a operação for bem-sucedida, por exemplo, abaixo:

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

Isso continuará tentando até que seja bem-sucedido.

Se você quiser repetir apenas um determinado número de vezes, use um contador também:

  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
  }

Isso vai tentar no máximo 10 vezes se não for bem sucedido até então um vai sair se o seu sucesso antes da mão.


Você pode usar https://github.com/bnsd55/RetryCatch

Exemplo:

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

Em vez do new ExampleRunnable() você pode passar sua própria função anônima.


Você precisa colocar seu try-catch dentro de um loop while assim:

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

Eu maxTries count e maxTries para evitar executar um loop infinito, caso a exceção continue ocorrendo em seu try block .






try-catch