Chiamate di nuovo metodo in modo generico

Question

La mia applicazione Java richiede una logica di tentativi in ​​caso di errori di chiamate remote. Queste chiamate remote sono:

• sparsi in tutta l'applicazione
• appartengono a diverse classi di servizio remoto.

Inoltre, la logica di tentativi potrà avere vari Retry e variando riprovare tentativi.

Ho bisogno di un'implementazione generica retry() che può effettuare chiamate di metodo appropriate a seconda di dove viene chiamato. Di seguito è riportata una semplice illustrazione del codice di cui sto cercando. So che possiamo provare a fare ciò usando java reflection, ma c'è un framework o un open source disponibile da qualche parte che è read-to-use?

try { 
ClassA objA = remoteServiceA.call(paramA1, paramA2, ...); 
} catch (Exception e){ 
ClassA objA = (ClassA)retry(remoteService, listOfParams, ..); // generic method call 
} 
.. 

try { 
ClassB objB = remoteServiceB.call(paramB1, paramB2, ...); 
} catch (Exception e){ 
ClassA objB = (ClassB)retry(remoteService, listOfParams, ..); // generic method call 
} 

Answer 1

da dove si ricevono i servizi? utilizzare una fabbrica per Proxy il servizio che si ottiene dalla fabbrica originale. Il proxy può quindi implementare il tentativo in modo trasparente. Guarda i proxy Proxy/Proxy java in riflessione.

Answer 2

Questo è un esempio di libro dove può essere utilizzato aspectj (o aop in generale), vedi 8.2.7 Example in Spring documentation e 5 Reasons Java Developers Should Learn and Use AspectJ.

Fondamentalmente un aspetto intercetta tutte le chiamate a determinati metodi (specificati usando annotazioni, convenzioni di denominazione, qualsiasi cosa) e riprova.

Answer 3

Come già suggerito, è necessario utilizzare le annotazioni AOP e Java. Mi sento di raccomandare un meccanismo di lettura fatta da jcabi-aspects (Sono uno sviluppatore):

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

Leggi anche questo post del blog: http://www.yegor256.com/2014/08/15/retry-java-method-on-exception.html

Update: Controllare RetryFunc da Cactoos.

Answer 4

Si supponga di avere un metodo, che deve essere ripetuto ogni 500ms e fino a 5 volte. classe corrente:

public class RemoteCaller{ 
    Service serviceCaller; 
    public void remoteCall(String message) { 
       serviceCaller.updateDetails(this.message); 
       return null; 
    } 
} 

approccio Modificato:

public class RetriableHelper<T> implements Callable<T> { 

    private Callable<T> task; 

    private int numberOfRetries; 

    private int numberOfTriesLeft; 

    private long timeToWait; 


    public RetriableHelper(int numberOfRetries, long timeToWait, Callable<T> task) { 
     this.numberOfRetries = numberOfRetries; 
     numberOfTriesLeft = numberOfRetries; 
     this.timeToWait = timeToWait; 
     this.task = task; 
    } 

    public T call() throws Exception { 
     while (true) { 
      try { 
       return task.call(); 
      } catch (InterruptedException e) { 
       throw e; 
      } catch (CancellationException e) { 
       throw e; 
      } catch (Exception e) { 
       numberOfTriesLeft--; 
       if (numberOfTriesLeft == 0) { 
        throw e; 
       } 
       Thread.sleep(timeToWait); 
      } 
     } 
    } 
} 


Backend system/remote call class: 

public class RemoteCaller{ 

    Service serviceCaller; 

    public void remoteCall(String message) { 

     class RemoteCallable implements Callable<Void> { 
      String message; 
      public RemoteCallable(String message) 
      { 
       this.message = message; 
      } 
      public Void call() throws Exception{ 
       serviceCaller.updateDetails(this.message); 
       return null; 
      } 
     } 


     RetriableHelper<Void> retriableHelper = new RetriableHelper<Void>(5, 500, new RemoteCallable(message)); 
     try { 
      retriableHelper.call(); 
     } catch (Exception e) { 
      throw e; 
     } 
    } 
}