Pattern di strategia composita - java - Quanto è pericoloso questo codice?

Question

questa domanda è sorta di continuazione al mio post precedente: Visitor pattern implementation in java- How does this look?

mi sono un po 'confuso, mentre il refactoring il mio codice. Sto cercando di convertire il mio modello di visitatore (spiegato nel post precedente) in un modello di strategia composita. Sto cercando di fare qualcosa di simile:

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

Ora, vorrei definire una regola come questa:

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. 
    } 
} 

Ora, potrei avere due tipi diversi oggetti da convalidare. Questi due potrebbero essere completamente diversi: dire che ho un negozio che è Validatable, e quindi un Schedule che è Validatable. Ora, se io avrei scritto un composito che sarebbe simile a questa:

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

vorrei definire un enum che definisce un insieme di controlli andare dove ...

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 
} 

e, infine, vorrei utilizzare così:

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

Ho la strana sensazione che il mio disegno sia difettoso. Non mi piace l'idea che la mia interfaccia Rule si aspetta un Validatable. Potresti per favore suggerire come migliorerei questo?

Apprezzo il tuo aiuto.

Answer 1

Sostituisci Validabile con un parametro di tipo generico T per rendere sicuro il tipo di framework di convalida.

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

Diamo estendere il nostro quadro con un'interfaccia ValidationStrategy:

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

Abbiamo a che fare con le regole delimitate da in modo che possiamo aggiungere una regola per Animal ad un validatore Dog (assumendo Dog "super-T?" estende l'animale). Il Validator ora assomiglia a questo:

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

Ora possiamo implementare una DogValidationStrategy campione come questo:

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

Oppure, come nel tuo esempio, possiamo avere un Enum che fornisce diverse strategie di validazione cane:

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

Answer 2

Quando ho appreso per la prima volta degli schemi di progettazione, ho continuato a cercare luoghi per utilizzarli. Da allora ho imparato che la "modellizzazione" prematura è un po 'come l'ottimizzazione prematura. Per prima cosa, prova a farlo in modo diretto e poi vedi quali problemi ti danno.

Provare a progettare con interfacce e sottoclassi minime. Quindi applica qualsiasi modello appropriato per le ridondanze evidenti che trovi. Ho l'impressione da questo e dal post precedente che potresti essere sopra-architettando il tuo codice.