Strategie-Muster, Pass-Funktion in übergeordnete Methode

Question

Ich möchte etwas wie Strategie-Muster implementieren. Ich habe eine verallgemeinerte Logik in der Parent-Methode, ich muss bestimmte Logik (mit Casting usw.) in Parent übergeben.

Ich habe folgende Klassen:

class A{ 
    public Object generateData(Function fetchData, AbstractForm form) 
    { 
     List<DataBean> dataBeans = (List<DataBean>) fetchData.apply(form); 
     //... 
    } 
} 

class B extends A{ 
    void someMethod(AbstractForm form){ 
     Function<AbstractForm, List<DataBean>> fetchFunction = new Function<AbstractForm, List<DataBean>>() { 
      //here goes form specific casting and other data fetch specific logic 
      return dataBeans; 
     } 
     super.generateData(fetchFunction, form); 
    } 
} 

Habe ich die Idee der Funktion hier richtig?

Answer 1

Korrekte Verwendung des Strategy-Pattern bedeutet Aggregation zwischen einem Kontext (in Ihrem Fall Klasse A) und einer Strategie (in Ihrem Fall eine Implementierung von Function).

Sie können die Beziehung in der Abbildung unten sehen (aus dem Buch der Vierergruppe, Design patterns: elements of reusable object-oriented software).

Im Folgenden werde ich ein traditionelles Strategiemuster Ansatz für Ihr Problem angewendet haben. In diesem Fall habe ich es so gemacht, dass Function.apply(AbstractForm)List<DataBean> zurückgibt, um die Notwendigkeit zum Gießen zu entfernen. Sie könnten natürlich Generika verwenden, um Function flexibler zu machen.

Strategie

public interface Function { 
    List<DataBean> apply(AbstractForm form);  
} 

Kontext

public class A { 

    private Function fetchData; // strategy 

    public void setStrategy(Function fetchData) { // method for setting the strategy 
     this.fetchData = fetchData; 
    } 

    // precondition: fetchData != null 
    public Object generateData(AbstractForm form) { 
     List<DataBean> dataBeans = fetchData.apply(form); // using the strategy 
     return null; // whatever you want to return 
    }  
} 

In diesem Fall Klasse erweitern A ist nicht notwendig, da wir unsere Strategie injizieren (Function) mit setStrategy(Function). Wir könnten jedoch immer A zu einem großartigen Objekt mit einer vordefinierten Strategie erweitern.

Zum Beispiel:

public class B extends A { 

    public B() { 
     setStrategy((form) -> null); // implement your concrete strategy here 
    } 
} 

eine Factory-Methode

Da eine Strategie unter Verwendung der Daten für das Abrufen wird wahrscheinlich erforderlich, und es kann keine ‚Standard‘ sein zu verwenden und nicht immer kann sich ändern, Das Factory-Methodenmuster könnte stattdessen verwendet werden, um die Erstellung eines Produkts zu erzwingen (Function). Die Notizklasse A ist jetzt abstrakt und enthält eine Factory-Methode createFunction(), die dann in den Unterklassen implementiert wird (z. B. B), um die Function zu erstellen.

Das Design für das Factory-Method-Muster ist in der UML-Datei zu sehen. In diesem Fall ist unser Produkt nun das, was vorher unsere Strategie war (Function) und der Ersteller ist die Klasse A, wobei der ConcreteCreator die Klasse B hat.

Creator

public abstract class A { 

    private Function fetchData; // product to be used 

    public class A() { 
     fetchData = createFunction(); // call factory method 
    } 

    protected abstract Function createFunction(); // factory method 

    // precondition: fetchData != null 
    public Object generateData(AbstractForm form) { 
     List<DataBean> dataBeans = fetchData.apply(form); // using the product 
     return null; // whatever you want to return 
    } 

} 

ConcreteCreator

public class B extends A { 

    @Override 
    protected Function createFunction() { 
     return (form) -> null; // return product 
    } 
} 

In diesem Fall wird das Produkt festgelegt ist und nicht veränderbar, aber das durch Vermischen der beiden Muster überwunden werden könnte zusammen und einschließlich setStrategy(Function) wieder aus der Klasse A im ersten Beispiel.