Ponowne wywoływanie metod ponownego próbkowania w sposób ogólny

Question

Moja aplikacja Java wymaga logiki ponownej próby w przypadku awarii połączeń zdalnych. Te zdalne połączenia są:

• rozrzucone po całym wniosku
• odnoszą się do różnych klas Remote Service.

Ponadto logika ponawiania może mieć zmienny interwał ponawiania prób i różne próby ponowienia.

muszę generic ponawiania() Wdrożenie, które mogą wprowadzić odpowiednie metody połączeń w zależności skąd to się nazywa. Poniżej znajduje się prosta ilustracja kodu, której szukam. Wiem, że możemy próbować zrobić to za pomocą refleksji java, ale czy istnieje jakiś framework lub open source, który jest dostępny do odczytu?

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

Skąd masz usługi? użyj fabryki, aby prosić o usługę, którą otrzymujesz z oryginalnej fabryki. Proxy może następnie wykonać operację powtórnie w sposób przezroczysty. Zobacz java Proxy/ProxyGenerators w refleksji.

Answer 2

Jest to przykład książka gdzie aspectj (lub aop ogólnie) może być stosowany, patrz 8.2.7 Example in Spring documentation i 5 Reasons Java Developers Should Learn and Use AspectJ.

Zasadniczo aspekt przechwytuje wszystkie połączenia do podanych metod (określonych za pomocą adnotacji, nazywając konwencją, cokolwiek) i próbach.

Answer 3

Jak już sugeruje, należy użyć AOP i Java adnotacje. Polecam odczytu mechanizm wykonany z jcabi-aspects (jestem programistą):

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

Czytaj także tego blogu: http://www.yegor256.com/2014/08/15/retry-java-method-on-exception.html

Aktualizacja: Sprawdź RetryFunc od Cactoos.

Answer 4

Załóżmy, że masz sposób, że konieczność retied na co 500ms i zapisu do 5 razy. Obecna klasa:

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

Zmodyfikowane podejście:

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