Zusammengesetzte Strategie Muster - Java - Wie schlimm ist dieser Code?

Question

Diese Frage ist eine Art Fortsetzung zu meinem früheren Beitrag: Visitor pattern implementation in java- How does this look?

Ich habe ein wenig verwirrt, während ich meinen Code refactoring. Ich versuche, mein Besuchermuster (das im vorherigen Post erklärt wurde) in ein zusammengesetztes Strategie-Muster umzuwandeln. Ich versuche, so etwas zu tun:

public interface Rule { 
    public List<ValidatonError> check(Validatable validatable); 
} 

Jetzt habe ich eine Regel wie folgt definieren würde:

public class ValidCountryRule { 
    public List<ValidationError> check(Validatable validatable) { 
    // invokeDAO and do something, if violation met 
    // add to a list of ValidationErrors. 
    // return the list. 
    } 
} 

Nun, ich zwei verschiedene Arten haben könnten Objekte validiert werden. Diese zwei könnten völlig unterschiedlich sein: Angenommen, ich habe einen Store, der Validatable ist, und dann einen Schedule, der Validatable ist. Nun, wenn ich einen Verbund schreiben würde, die wie folgt aussehen:

class Validator implements Rule { 
    private List<Rule> tests = new ArrayList<Rule>(); 

    public void addRule(Rule rule) { 
    tests.add(rule); 
    } 

    public List<ValidationError> check(Visitable visitable) { 
    List<ValidationError> list = new ArrayList<ValidationError>(); 
    for(Rule rule : tests) { 
     list.addAll(rule.check(visitable); 
    } 
    } 

    public Validator(ValidatorType type) { 
    this.tests = type.getRules(); 
    } 
} 

Ich würde definieren eine enum das, was Reihe von Kontrollen definiert gehen, wo ...

public Enum ValidatorType { 
    public abstract List<Rule> getRules(); 
    STORE_VALIDATOR { 
    public List<Rule> getRules() { 
     List<Rule> rules = new ArrayList<Rule>(); 
     rules.add(new ValidCountryRule()); 
     rules.add(new ValidXYZRule()); 
    } 

    // more validators 
} 

und schließlich würde ich es ist wie folgt:

Validator validator = new Validator(ValidatorType.STORE_VALIDATOR); 
for (Store store : stores) { 
    validator.check(store); 
} 

Ich habe ein seltsames Gefühl, dass mein Design fehlerhaft ist. Mir gefällt die Idee nicht, dass meine Regelschnittstelle eine Validatable erwartet. Könnten Sie mir bitte vorschlagen, wie ich das verbessern würde?

Schätzen Sie Ihre Hilfe.

Answer 1

ersetzen Validierbares durch einen generischen Typparameter T die Validation Framework Art sicher zu machen.

public interface Rule<T> { 
    public List<ValidationError> check(T value); 
} 

wir unseren Rahmen mit einer Schnittstelle ValidationStrategy erweitern:

public interface ValidationStrategy<T> { 
    public List<Rule<? super T>> getRules(); 
} 

Wir beschäftigen uns mit Regeln begrenzt durch, damit wir eine Regel für Tier an einen Hund Validator hinzufügen (unter der Annahme Dog „Super T?“ verlängert Tier). Der Validator sieht nun wie folgt aus:

public class Validator<T> implements Rule<T> { 
    private List<Rule<? super T>> tests = new ArrayList<Rule<? super T>>(); 

    public Validator(ValidationStrategy<T> type) { 
     this.tests = type.getRules(); 
    } 

    public void addRule(Rule<? super T> rule) { 
     tests.add(rule); 
    } 

    public List<ValidationError> check(T value) { 
     List<ValidationError> list = new ArrayList<ValidationError>(); 
     for (Rule<? super T> rule : tests) { 
      list.addAll(rule.check(value)); 
     } 
     return list; 
    } 
} 

Jetzt können wir eine Probe DogValidationStrategy wie folgt implementieren:

public class DogValidationStrategy implements ValidationStrategy<Dog> { 
    public List<Rule<? super Dog>> getRules() { 
     List<Rule<? super Dog>> rules = new ArrayList<Rule<? super Dog>>(); 
     rules.add(new Rule<Dog>() { 
      public List<ValidationError> check(Dog dog) { 
       // dog check... 
       return Collections.emptyList(); 
      } 
     }); 
     rules.add(new Rule<Animal>() { 
      public List<ValidationError> check(Animal animal) { 
       // animal check... 
       return Collections.emptyList(); 
      } 
     }); 
     return rules; 
    } 
} 

Oder wie in der Probe, können wir eine Enum bietet mehrere Hund Validierungsstrategien haben:

public enum DogValidationType implements ValidationStrategy<Dog> { 
    STRATEGY_1 { 
     public List<Rule<? super Dog>> getRules() { 
      // answer rules... 
     } 
    }, 
    // more dog validation strategies 
} 

Answer 2

Als ich erfuhr, über Design Patterns ersten, hielt ich versuche, Orte zu finden, sie zu nutzen. Ich habe inzwischen gelernt, dass vorzeitige "Musterbildung" ist wie eine vorzeitige Optimierung. Versuchen Sie zuerst, es auf eine geradlinige Weise zu tun, und dann sehen Sie, welche Probleme Sie gibt.

Versuchen mit minimalen Schnittstellen und Subklassen zu entwerfen. Wenden Sie dann das Muster an, das für die offensichtlichen Redundanzen, die Sie finden, geeignet sein könnte. Ich habe den Eindruck von diesem und dem vorherigen Beitrag, dass Sie Ihren Code möglicherweise überarbeiten.