Design Pattern zur Implementierung von Business Rules mit Hunderten von if else in Java

Können Sie Befehl Muster oder Factory pattern.

Befehl Muster kann verwendet werden, zu ersetzen, die sperrig-Schalter/if-Blöcke, die dazu neigen, zu wachsen, auf unbestimmte Zeit, wie Sie neue Optionen hinzufügen.

public interface Command {
     void exec();
}

public class CommandA() implements Command {

     void exec() {
          //... 
     }
}
//etc etc

erstellen Sie dann eine Map<String,Command> Objekt, und füllen Sie es mit dem Befehl Instanzen:

commandMap.put("A", new CommandA());
commandMap.put("B", new CommandB());

dann können Sie ersetzen Ihre if/else if-Kette mit:

commandMap.get(value).exec();

In Fabrik-Muster Sie Ihre if/switch in einer Fabrik, die kümmert sich um die Hässlichkeit und blendet die fülle von ifs. Beispiel-code für die Fabrik-Muster.

InformationsquelleAutor der Antwort fortytwo

Einem design-Muster kann Ihnen helfen, um den code lesbarer zu gestalten oder zu verbessern die Verwaltbarkeit, aber wenn Sie wirklich brauchen, um zu bewerten eine solche Anzahl von Bedingungen, die IF-Anweisungen können nicht vermieden werden.

Ich würde sehen das problem aus einer anderen Sicht (z.B.: brauche ich wirklich hundert bedingte Anweisungen, um das problem zu lösen?) und ich würde versuchen zu verändern oder zu verbessern, die Algorithmus.

Einer Die Expression Language könnte einige helfen, weil Sie programmatisch einen string für jede IF-Anweisung und zu bewerten und das Ergebnis mit diesem Werkzeug, aber Sie haben immer noch das problem zu lösen mit der Ausführung der besonderen Logik, die mit jedem Zustand.

InformationsquelleAutor der Antwort Gabriel Aramburu

Sollten Sie sich die Regeln-Entwurfsmuster http://www.michael-whelan.net/rules-design-pattern/. Es sieht sehr ähnlich zu der von Beispiel-code, den Sie gab, und besteht aus einer Basis-Schnittstelle definiert eine Methode für die Bestimmung, wenn eine Regel erfüllt ist und dann verschiedene konkrete Implementierungen gemäß unterschiedlichen Regeln. Als ich verstehen es, Ihre switch-Anweisung würde in eine Art einfache Schleife, die nur bewertet Dinge, bis Ihre Zusammensetzung Regeln ist entweder zufrieden ist oder fehlschlägt.

interface IRule {
    bool isSatisfied(SomeThing thing);
}

class RuleA: IRule {
    public bool isSatisfied(SomeThing thing) {
        ...
    }
}

class RuleA: IRule {
    ...
}

class RuleC: IRule {
    ...
}

Zusammensetzung Regeln:

class OrRule: IRule {
    private readonly IRule[] rules;

    public OrRule(params IRule[] rules) {
        this.rules = rules;
    }

    public isSatisfied(thing: Thing) {
        return this.rules.Any(r => r.isSatisfied(thing));
    }
}

class AndRule: IRule {
    private readonly IRule[] rules;

    public AndRule(params IRule[] rules) {
        this.rules = rules;
    }

    public isSatisfied(thing: Thing) {
        return this.rules.All(r => r.isSatisfied(thing));
    }
}

//Helpers for AndRule /OrRule

static IRule and(params IRule[] rules) {
    return new AndRule(rules);
}

static IRule or(params IRule[] rules) {
    return new OrRule(rules);
}

Einige service-Methode läuft in der Regel auf eine Sache.
class SomeService {
public auswerten(IRule Regel, Sache, Ding) {
zurück Regel.isSatisfied(Sache);
}
}

Verwendung:

//Compose a tree of rules
var rule = 
    and (
        new Rule1(),
        or (
            new Rule2(),
            new Rule3()
        )
    );

var thing = new Thing();

new SomeService().evaluate(rule, thing);

Diese wurde auch hier beantwortet: https://softwareengineering.stackexchange.com/questions/323018/business-rules-design-pattern

InformationsquelleAutor der Antwort bingles