Bestes OOP-Entwurfsmuster für eine Abfolge von Operationen

Ich arbeite an einer Anwendung, deren Modul die folgenden Finanzoperationen nacheinander ausführt:

Wenn ein Benutzer die Überweisung eines bestimmten Betrags auf sein Bankkonto anfordert:

1. Überprüfen Sie, ob jetzt eine Transaktion stattfinden kann. (Transaktion kann nur während eines bestimmten Zeitraums durchgeführt werden)
2. Überprüfen Sie, ob der Benutzer die Abhebung eines Mindestbetrags beantragt hat
3. Überprüfen Sie, ob der Benutzer über ein Standardkonto verfügt

Das Ergebnis aller oben genannten Aktionen sollte protokolliert werden.

Wenn alle oben genannten Bedingungen erfüllt sind, wird die Transaktion ausgeführt. In Zukunft könnte es einige zusätzliche Überprüfungen geben.

Welches objektorientierte Entwurfsmuster sollte für den obigen Fall am besten geeignet sein?

Es klingt so, als ob Sie nach einer Kette von Verantwortung suchen . In diesem Fall könnten Sie die folgenden Klassen haben:

• TransactionValidatorBase abstrakte Basisklasse
• TransactionTimeValidator
• TransactionAmountValidator
• TransactionAccountValidator

Diese sind verkettet, um die von Ihnen angegebenen Regeln anzuwenden.

Weiteres Lesen

• AdR auf OODesign.com
• Nach dem AdR auf JavaWorld

Das richtige Muster hängt hier wirklich von einem Kontext ab. Bevor ich ein bestimmtes Muster auswähle, werde ich versuchen, Antworten auf diese Fragen zu finden:

• Müssen zur Laufzeit verschiedene Kombinationen von (1,2,3) Prüfungen erstellt werden?
• Benötigen sie dieselben Variablen, um ihre Aktionen auszuführen, oder sind sie sehr unterschiedlich?
• Wie genau sollten die Fehlermeldungen sein?
• Im Falle eines Fehlers versucht der Benutzer immer, den ersten Schritt zu wiederholen?
• Wie wird mit Parallelität umgegangen?
• Fügt jede Methode der Anfrage etwas hinzu oder validiert sie einfach? (Sagen Sie Standard-Konto-ID?)

Basierend auf einem Bauchgefühl würde ich sie als einfache Methoden mit aggregierenden Parametern für Fehlercodes codieren.

public void DoTransaction(IErrorAgregator error, TransactionRequest request)
{
    if(!IsTransactionInCertainTimePeriod(request, error)) return;
    if(!IsTransactionAmountInUserBounds(request, error)) return;
    if(!UserHaveDefaultAccount(request, error)) return;
    bankingTransactor.PerformTransaction(request);
}

Es ist möglicherweise eine gute Idee, DoTransaction in die Schnittstelle "ITransactionValidationStragegy" einzufügen und einen Layer-Supertyp zu erstellen, der Validierungs-Boilerplate-Code enthält.

Bei diesem Entwurf gehe ich jedoch davon aus, dass die Validierungslogik zur Kompilierungszeit bestimmt wird.

Wenn Ihre Abfolge von Schritten hauptsächlich Validierungsaufgaben erfüllt (wie es aussieht), ohne die Eingaben zu mutieren, würde ich in der Tat an das Muster "Chain of Responsibility" denken, wie in seiner Antwort von @pswg erläutert

Da Ihre Frage jedoch etwas allgemeiner ist, möchte ich auch die "Pipeline-Verarbeitung" hinzufügen, da bei diesem Schritt ein Schritt eine Ausgabe erzeugt, die zur Eingabe für den nächsten Schritt wird (wodurch die ursprüngliche Eingabe mutiert wird). .

Hier sind zwei Artikel darüber:
Pipeline-Sammlung von Martin Fowler
Weitere theoretische Diskussion über das Muster

Während die Muster hier bereits erwähnt sind, würde ich Ihnen empfehlen, darüber nachzudenken, wie Sie sie in Ihrer Anwendung verwenden möchten, basierend auf den von Ihnen verwendeten Frameworks.

Beispielsweise wird sich die Validierung, die Sie durchführen möchten, höchstwahrscheinlich im Laufe der Zeit ständig ändern (möglicherweise möchten Sie in Zukunft eine neue Validierung hinzufügen, die Transaktionen auf 10 pro Tag beschränkt). Möglicherweise möchten Sie die Validierung auch nicht durchführen, bevor Ihr eigentlicher Business Service oder Integrationscode aktiviert wird. Es wäre gut, wenn Sie die Validierungen als konfigurierbare hinzufügen könnten.

Wenn Sie Struts verwenden, ist die Verwendung von Interceptors möglicherweise eine gute Idee. Im Frühling bietet die Bohneninjektion als Abhängigkeit mehr Flexibilität. Mein Vorschlag ist, nicht nur die Muster / Redewendungen zu betrachten, sondern auch das Framework, mit dem Sie die Anwendung erstellen, und herauszufinden, wie Sie aus futuristischer Sicht am besten zu Ihren Anforderungen passen können.

Nach meinem Verständnis kann alles, was erforderlich ist, wie unten beschrieben in das Befehlsmuster eingepasst werden. Das Klassendesign kann wie folgt durchgeführt werden.

interface Transaction{
void performAction();
}

class Banking{

void moneyValidation(){
//Validate Here
}

void timeValidation(){
//validate Here
}
}

class TimeValidation implements Transaction{

public Banking bank;

public TimeValidation (Banking bnk){
bank=bnk;
}

void performAction(){
bnk.timeValidation();
}


class MoneyValidation Implements Transaction{

public Banking bank;

public MoneyValidation(Banking bnk;){
bank=bnk;
}

void performAction(){
bnk.moneyValidation();
}
}


class Control{

private List val_list=new ArrayList();

void storeValidation(Transaction trans){
val_list.add(trans);
trans.performAction(val_list.getFirstAndRemove());
}
}

//Same for other validation classes

Ihre Client-Klasse enthält das folgende Code-Snippet:

Banking bnk = new Banking();
MoneyValidation m_val = new MoneyValidation (bnk);
TimeValidation t_val = new TimeValidation (bnk);
Control ctrl = new Control();
ctrl.storeValidation(m_val);
ctrl.storeValidation(t_val);

Dies ist nach meinem Verständnis mit dem oben angegebenen Szenario.