Miglior modello di progettazione OOP per una sequenza di operazioni

Sembra che quello che stai cercando sia una catena di responsabilità . In questo caso potresti avere le seguenti classi:

• TransactionValidatorBase classe base astratta
• TransactionTimeValidator
• TransactionAmountValidator
• TransactionAccountValidator

Che sono concatenati per applicare comunque molte regole specificate.

Lettura successiva

• CoR su OODesign.com
• Seguito del CdR su JavaWorld

Lo schema corretto qui dipende in realtà da un contesto. Prima di scegliere un modello particolare su cui attenermi, cercherò di trovare le risposte a queste domande:

• È necessario creare diverse combinazioni di (1,2,3) assegni in fase di esecuzione?
• Hanno bisogno delle stesse variabili per eseguire le loro azioni o sono molto diversi?
• Quanto dovrebbero essere precisi i messaggi di errore?
• In caso di errore, l'utente riprova da (1) st step sempre?
• Come viene gestita la concorrenza?
• Ogni metodo aggiunge qualcosa alla richiesta o semplicemente convalida? (ad esempio ID acct predefinito?)

Sulla base di una sensazione istintiva, li codificherei come semplici metodi con parametri di aggregazione per i codici di errore.

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

Potrebbe essere una buona idea mettere DoTransaction nell'interfaccia "ITransactionValidationStragegy" e creare un super-tipo di livello che conterrà il codice boiler validation.

Tuttavia, in questo progetto presumo che la logica di validazione sia determinata al momento della compilazione.

Se la sequenza di passaggi sta svolgendo per lo più compiti di validazione (come sembra), senza mutare gli input, penso davvero al pattern "Chain of Responsibility", come spiegato nella sua risposta da @pswg

Ma dal momento che la tua domanda è un po 'più generica, vorrei aggiungere anche l'elaborazione Pipeline, poiché con questa, un passo produrrebbe un output che diventerebbe l'input per il passo successivo (mutando così input originale).

Ecco due articoli a riguardo:
Raccolta pipeline di Martin Fowler
Altre discussioni teoriche sul modello

Mentre i pattern sono già menzionati qui, ti suggerisco di pensare a come vorresti usare lo stesso nella tua applicazione, in base ai framework che stai utilizzando.

Ad esempio, la convalida che vorresti fare, molto probabilmente cambierà man mano che avanzi nel tempo (potresti voler aggiungere una nuova convalida in futuro che limita le transazioni a 10 al giorno). Inoltre, potresti non voler eseguire la convalida prima che il tuo attuale servizio aziendale o il codice di integrazione entrino in funzione. Sarebbe bello, se puoi avere le convalide aggiunte come quelle configurabili.

Nel caso stiate usando Struts, l'uso di intercettori potrebbe essere una buona idea. In caso di primavera, l'iniezione di fagioli come dipendenza offre maggiore flessibilità. Il mio suggerimento non è solo quello di guardare i modelli / gli idiomi, ma anche guardare il framework che usi per costruire l'applicazione e vedere come meglio adattarti alle tue esigenze da un punto di vista futuristico.

Secondo la mia comprensione, qualunque cosa sia richiesta può essere inserita nello schema di comando come sotto. La progettazione della classe può essere eseguita come di seguito.

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

La classe del tuo cliente conterrà il seguente frammento di codice:

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

Questo è secondo la mia comprensione, con lo scenario che è stato dato sopra.