Java: wie geht man mit Wiederholungen ohne copy-paste-code?

Off-hand, die ich denken kann, zwei verschiedene Ansätze:

Wenn die Unterschiede in der Ausnahmebehandlung kann deklarativ ausgedrückt werden, könnten Sie mit AOP zu Weben, die exception-handling-code, um Ihre Methoden. Dann, Ihre business-code könnte wie folgt Aussehen:

@Retry(times = 3, loglevel = LogLevel.INFO)
List<User> getActiveUsers() throws DatabaseException {
    //talk to the database
}

Der Vorteil ist, dass es wirklich einfach ist, retry-Verhalten eine Methode, der Nachteil ist die Komplexität des Webens, die Beratung (die Sie nur umsetzen müssen, einmal. Wenn Sie mit einem dependency-injection-Bibliothek, die Chancen sind Sie werden bieten Methode abfangen Unterstützung).

Anderer Ansatz ist die Verwendung des command pattern:

abstract class Retrieable<I,O> {
    private final LogLevel logLevel;

    protected Retrieable(LogLevel loglevel) {
        this.logLevel = loglevel;
    }

    protected abstract O call(I input);

    //subclasses may override to perform custom logic.
    protected void handle(RuntimeException e) {
        //log the exception. 
    }

    public O execute(I input) {
        for (int iteration = 1; ; iteration++) {
            try {
                return call(input);
            } catch (RuntimeException e) {
                if (iteration == helper.getNumberOfRetries()) {
                    throw e;
                } else {
                    handle();
                    utilities.defaultDelayForIteration(iteration);
                }
            }
        }
    }
}

Das problem mit dem Befehl Muster sind die Methode Argumente. Sie sind nur auf einen einzigen parameter, und die Generika sind eher sperrigen für den Anrufer. Außerdem funktioniert es nicht mit checked exceptions. Auf der plus-Seite, keine Lust AOP Sachen 🙂

Implementierte ich die RetryLogic Klasse, unterhalb dessen bietet wiederverwendbare wiederholen Sie die Logik und unterstützt Parameter, da der code wiederholt werden soll, ist in einer Stellvertretung übergeben.

/**
 * Generic retry logic. Delegate must throw the specified exception type to trigger the retry logic.
 */
public class RetryLogic<T>
{
    public static interface Delegate<T>
    {
        T call() throws Exception;
    }

    private int maxAttempts;
    private int retryWaitSeconds;
    @SuppressWarnings("rawtypes")
    private Class retryExceptionType;

    public RetryLogic(int maxAttempts, int retryWaitSeconds, @SuppressWarnings("rawtypes") Class retryExceptionType)
    {
        this.maxAttempts = maxAttempts;
        this.retryWaitSeconds = retryWaitSeconds;
        this.retryExceptionType = retryExceptionType;
    }

    public T getResult(Delegate<T> caller) throws Exception {
        T result = null;
        int remainingAttempts = maxAttempts;
        do {
            try {
                result = caller.call();
            } catch (Exception e){
                if (e.getClass().equals(retryExceptionType))
                {
                    if (--remainingAttempts == 0)
                    {
                        throw new Exception("Retries exausted.");
                    }
                    else
                    {
                        try {
    Thread.sleep((1000*retryWaitSeconds));
                        } catch (InterruptedException ie) {
                        }
                    }
                }
                else
                {
                    throw e;
                }
            }
        } while  (result == null && remainingAttempts > 0);
        return result;
    }
}

Unten ist ein Beispiel. Der code wiederholt werden soll, ist in der call-Methode.

private MyResultType getDataWithRetry(final String parameter) throws Exception {
    return new RetryLogic<MyResultType>(5, 15, Exception.class).getResult(new RetryLogic.Delegate<MyResultType> () {
        public MyResultType call() throws Exception {
            return  dataLayer.getData(parameter);
        }});
}

In Fall, dass Sie wollen, um zu wiederholen, nur, wenn eine bestimmte Art von exception Auftritt (und nicht auf alle anderen Arten von Ausnahmen) die RetryLogic-Klasse unterstützt eine Ausnahme der Klasse parameter.

werfen Sie einen Blick auf: dies wiederholen utility

diese Methode sollte funktionieren für die meisten Anwendungsfälle:

public static <T> T executeWithRetry(final Callable<T> what, final int nrImmediateRetries,
            final int nrTotalRetries, final int retryWaitMillis, final int timeoutMillis)

können Sie eassily implementieren Sie einen Aspekt mit diesem Dienstprogramm, um dies zu tun, selbst mit weniger code.

Eine Sache, die ich hinzufügen möchte. Die meisten Ausnahmen (99.999%) bedeuten, gibt es etwas sehr falsch mit Ihrem code oder die Umgebung, die Anforderungen an admins Aufmerksamkeit. Wenn Ihr code kann nicht mit der Datenbank verbinden, ist es wahrscheinlich eine falsch konfigurierte Umgebung gibt es wenig Punkt zu wiederholen es, nur um herauszufinden, es hat nicht funktioniert, die 3., 4. oder 5. mal entweder. Wenn Sie eine Ausnahme auslösen, weil die person nicht geben Sie eine gültige Kreditkarten-Nummer, Wiederholung nicht magisch auszufüllen, die Nummer der Kreditkarte.

Nur Situationen, die aus der Ferne lohnt sich zu wiederholen ist, wenn ein system ist enorm angespannt und die Dinge sind timing, aber in diesem Fall wiederholen Sie die Logik ist wahrscheinlich, verursachen mehr Belastung als weniger (3x für 3 Wiederholungen für jede Transaktion). Aber das ist, was die Systeme tun, um wieder nach unten Nachfrage (siehe die apollo-lander-mission Geschichte). Wenn ein system ist gefragt, mehr zu tun, als es kann, beginnt es fallen Arbeitsplätze und die timeouts sind das signal das system ist angespannt (oder schlecht geschrieben). Sie wären in einer viel besseren situation, wenn Sie nur erhöht die Kapazität des Systems (hinzufügen von mehr ram, größere Server, mehr Server, bessere algorithmen skalieren!).

Die andere situation wäre, wenn Sie das optimistische sperren und kann man das irgendwie wiederherstellen und automatische Zusammenführen von zwei Versionen eines Objekts. Ich habe zwar gesehen, dies vor, ich würde vorsichtig mit diesem Ansatz, aber es könnte getan werden, für einfache Objekte, die zusammengefasst werden können, ohne Konflikte 100% der Zeit.

Meisten Ausnahmen Logik sollte fangen auf der entsprechenden Ebene (sehr wichtig), stellen Sie sicher, dass Ihr system ist in einem guten konsistenten Zustand (dh rollback Transaktionen, Dateien schließen, etc), log-it, informieren Sie die Benutzer hat es nicht funktioniert.

Aber ich werde humor dieser Idee und versuchen Sie eine gute Grundlage (auch weil es Spaß macht gerne Kreuzworträtsel, puzzle-Spaß).

//client code - what you write a lot
public class SomeDao {
    public SomeReturn saveObject( final SomeObject obj ) throws RetryException {
        Retry<SomeReturn> retry = new Retry<SomeReturn>() {
            public SomeReturn execute() throws Exception {
               try {
                  //doSomething
                  return someReturn;
               } catch( SomeExpectedBadExceptionNotWorthRetrying ex ) {
                  throw new NoRetryException( ex ); //optional exception block
               }
            }
        }
        return retry.run();
    }
}

//framework - what you write once
public abstract class Retry<T> {

    public static final int MAX_RETRIES = 3;

    private int tries = 0;

    public T execute() throws Exception;

    public T run() throws RetryException {
        try {
           return execute();
        } catch( NoRetryException ex ) {
           throw ex;
        } catch( Exception ex ) {
           tries++;
           if( MAX_RETRIES == tries ) {
              throw new RetryException("Maximum retries exceeded", ex );
           } else {
              return run();
           }
        }
    }
}