Klasse Level-Design für die Validierung Motor mit zwei unabhängigen Einheiten

Question

ich einen Anwendungsfall, wo es drei Arten von Daten

1. Business_Enrollment_Program sein (sie mit BEP_1, BEP_2 ... bezeichnen kann)
2. Validation_Rule (lasst sie mit R1, R2 bezeichnen ...)
3. Transaction_Type (bezeichnen wir sie TT_1, TT_2 ...). Dies ist eine Entitätsklasse mit einigen Attributen. Auf diesen Entitäten muss Validation_Rule ausgeführt werden.

TRANSACTION_TYPE Einheiten so etwas wie

public TT_1 { 
private Business_Enrollment_Program; 
private COMMON_FIELD_1; 
private COMMON_FIELD_2; 
private TT_1_SPECIFIC_FIELD; 
} 

public TT_2 { 
private Business_Enrollment_Program; 
private COMMON_FIELD_1; 
private COMMON_FIELD_2; 
private TT_2_SPECIFIC_FIELD; 
} 

aussehen i2 Anforderung Jetzt haben während Validierungsregeln Ausführung:

1. Set von Validation_Rule

   , die ausgeführt werden müssen, hängt von der TRANSACTION_TYPE und es ist Business_Enrollment_Program. Das bedeutet, dass wir für TT_1, die unter BEP_1 registriert sind, möglicherweise Regeln (R1, R2) ausführen müssen, aber für TT_1, die unter BEP_2 registriert sind, müssen wir möglicherweise (R1, R3) Regeln ausführen.

2. Das Verhalten der Regel hängt von Transaction_Type und dessen Business_Enrollment_Program ab. Das bedeutet für TT_1 unter BEP_1 Verhalten der Regel R1 eingeschrieben könnte im Vergleich zu TT_1 unterschiedlich sein eingeschrieben unter BEP_2

Für Regeln i eine Struktur wie unten erstellen:

und ich kann die Regeln ausführen wie unten

public processTransaction(T transactioType) { 
    private boolean result = true; 
    if(t instanceof TT_1) { 
     result = result && R1_For_TT_1.execute(t); 
    } 
    else if (t instanceof TT_2) { 
     result = result && R1_For_TT_1.execute(t); 
     result = result && R2_For_TT_1.execute(t); 
    } 

    if(result) { 
    // Do something 
    } 
    else { 
    // Do something else 
    } 
} 

Problem mit diesem Ansatz ist, ich bin nicht treffen meine zweite Anforderung, wo ich das Verhalten der Regel wollte TRANSACTION_TYPE abzuhängen und es ist Business_Enrollment_Progr bin.

Jede Idee, wie kann ich meine Klassen und Entitäten so arrangieren, dass beide Anforderungen elegant erfüllt werden?

Answer 1

würde ich jeden BusinessEnrollmentProgram ein Map<TransactionType, List<Rule>> als ein Feld geben, damit Sie organisieren können, was Rule Objekte mit jedem TransactionType gehen. Es wird es einfacher zu suchen, welche Rule s ausgeführt werden müssen.

So wäre es etwa so aussehen:

BusinessEnrollmentProgram.java

public class BusinessEnrollmentProgram { 

    private Map<TransactionType, List<Rule>> transactions = new HashMap<>(); 

    public void processTransaction(TransactionType t) { 
     List<Rule> rules = transactions.get(t); 
     boolean result = true; 
     for (Rule rule : rules) { 
      if (!rule.execute(t)) { 
       result = false; 
       break; 
      } 
     } 
     if (result) { 
      // do something 
     } else { 
      // do something else 
     } 
    } 
} 

TransactionType.java

public class TransactionType { 
    private COMMON_FIELD_1; 
    private COMMON_FIELD_2; 

    // override hashCode() & equals() here so it can be used as a HashMap key 
} 

Dann alle Ihre Transaktionstypen machen extend TransactionType und Lassen Sie Ihre Map zu st Erz alle Beziehungen, für die Rule laut ist mit denen TransactionType. Jeder BusinessEnrollmentProgram sollte einen separaten Satz von Regeln haben, aus denen man zeichnen kann.

Wenn Sie feststellen, dass zu viele Klassen vorhanden sind, die sich erweitern Rule, verwenden Sie stattdessen anonymous classes oder lambda expressions.