Funktionalität für die automatische Wiederholung nach Ausnahme

Habe ich aus dieser abstrakten Klasse automatisch wiederholen-Netzwerk Anrufe, wenn einige exception geworfen wird.

  • Ich aufpassen, um nicht erneut nach InterruptedException &
    UnknownHostException.
  • Ich wiederholen 5 mal. Nach jedem Versagen
    Ich führe eine exponentielle wieder aus, ab 300ms gehen bis zu
    1500ms.
public abstract class AutoRetry {

  private Object dataToReturn = null;
  public Object getDataToReturn() {
    return this.dataToReturn;
  }

  public AutoRetry() {

    short retry = -1;
    while (retry++ < StaticData.NETWORK_RETRY) {

      try {
        Thread.sleep(retry * StaticData.NETWORK_CALL_WAIT);
        this.dataToReturn = doWork();
        break;
      } catch (InterruptedException | UnknownHostException e) {
        e.printStackTrace();
        this.dataToReturn = null;
        return;
      } catch (IOException e) {
        e.printStackTrace();
      }
    }
  }

  protected abstract Object doWork() throws IOException;
}

Ich benutze es wie folgt : 

final Object dataAfterWork = new AutoRetry() {     
  @Override
  protected Object doWork() throws IOException {
    return; //a network call which returns something
  }
}.getDataToReturn();

So ist diese Umsetzung gut/richtig ?

BEARBEITEN

verschoben https://codereview.stackexchange.com/questions/87686

  • Ich würde Java 8 Lambda-Ausdrücke - Fragen Sie nach einem Supplier<T> und zurück T. Dies würde drastisch verringern, boilerplate.
  • Gute Idee, aber ich nicht verwenden Java8. Seine android-Anwendung. (Hinzugefügt tag)
  • Wenn Ihr code arbeitet, würde ich Ihnen raten, den Kopf über code-review hier codereview.stackexchange.com 😉
  • Mein code immer noch gilt - die anonyme Klasse. Ihre Methode ist etwas unangenehm mit der null und die Zuordnung und die break. Auch die Generika-in meinem Ansatz sind viel sauberer als Ihre Object.
  • Mein Rat ist, teilen Sie die Aufgabe aus der Ausführung; ich würde übergeben einer Runnable oder eine Benutzerdefinierte Schnittstelle zu AutoRetry; dies entkoppelt, was Sie tun, von der Politik wiederholen
  • Ich denke, Boris, die Antwort entspricht deinen Vorschlag, richtig ?
  • ja, es ist

InformationsquelleAutor Dexter | 2015-04-22
  1. 2

    Dieser sieht ziemlich gut aus, aber ich würde split der ausgeführten Aufgabe aus der Wiederholung. Auch Generika verwendet werden, nicht nur werfen Object über.

    Verwenden Java 8 lambda und die return der Methode:

    public static <T> Optional<T> doWithRetry(final Supplier<T> t) {
    for (int retry = 0; retry <= StaticData.NETWORK_RETRY; ++retry) {
        try {
            Thread.sleep(retry * StaticData.NETWORK_CALL_WAIT);
            return Optional.of(t.get());
        } catch (InterruptedException | UnknownHostException e) {
            LOGGER.log(Level.SEVERE, "Call failed.", e);
            return Optional.empty();
        } catch (IOException e) {
            LOGGER.log(Level.WARNING, "Call failed. Retry.", e);
        }
    }
    LOGGER.log(Level.SEVERE, "Call failed. Retries exceeded.");
    return Optional.empty();
}

    Außerdem verwenden Sie ein real logger, nicht printStackTrace...

    Verwendung:

    final String data = doWithRetry(() -> {
   //do stuff 
});

    Wenn Ihr lambda muss eine exception werfen, müssen Sie definieren Ihre eigenen @FunctionalInterface:

    @FunctionalInterface
interface StuffDoer<T> {
    T doStuff() throws Exception;
}

    Und verwenden Sie, dass in der Signatur der Methode, Sie benötigen, um generische Exception.

    Pre-Java-8 Verwendung:

    final String data = doWithRetry(new StuffDoer<T>() {
    @Override
    public T get() throws Exception {
        return null;
    }
});
    • Ok ich verwenden kann, Guave-Versionen Optional und Lieferanten. Was ist falsch mit printStackTrace ?
    • es gibt auf STDOUT aus. Sie haben keine Kontrolle darüber, wo seine gedruckt und Wann Sie gedruckt werden. Mit STDOUT für die Anmeldung ist ein Sicheres Zeichen, dass der code nicht geschrieben ist, in einem professionellen Umfeld.
    • Ok, das macht Sinn. Aber ich bin mit Android Studio, auch die Google-tutorials hatte printStackTrace. (Ich kann den Log in android)
    • Meine ganze app hat printStackTrace überall, sollte ich in Erwägung ziehen dieses ?
    • Tutorials oft tun, weil die Einrichtung eines logging-Frameworks ist kompliziert und nicht Teil des Tutorials. Mit STDOUT funktioniert TM. Ja, ich würde in Erwägung ziehen, denn dann können Sie schalten Sie alle Ihre debug-Protokollierung für den Einsatz in der Produktion - Sie vielleicht nicht wollen, dass die Leute sehen die Innenseiten der code.
    • Jetzt, wo ich darüber nachdenke, habe ich oft nicht viel von stackTraces..hmm, ok hab dein Punkt 🙂

    InformationsquelleAutor Boris the Spider
  2. 4

    Haben Sie einen Blick auf Failsafe. Es unterstützt wiederholen Richtlinien, synchrone und asynchrone Wiederholungen, Ereignis-Listener, die integration mit Java 8 ist CompletableFuture, etc. Ex:

    RetryPolicy retryPolicy = new RetryPolicy()
  .retryOn(ConnectException.class)
  .withDelay(1, TimeUnit.SECONDS)
  .withMaxRetries(100);

//Synchronous get with retries
Connection connection = Failsafe.with(retryPolicy).get(() -> connect());

//Asynchronous get with retries
Failsafe.with(retryPolicy, executor)
  .get(() -> connect())
  .onSuccess(connection -> log.info("Connected to {}", connection))
  .onFailure(failure -> log.error("Connection attempts failed", failure));
    InformationsquelleAutor Jonathan
Schreibe einen Kommentar