Befehlsmuster

Das Befehlsmuster ist ein datengetriebenes Entwurfsmuster, das zu den Verhaltensmustern gehört.

Das Befehlsmuster kapselt eine Anfrage als Objekt und ermöglicht es Ihnen, Clients mit unterschiedlichen Anfragen zu parametrisieren, Anfragen in Warteschlangen einzureihen oder zu protokollieren und rückgängig machbare Operationen zu unterstützen.

Strukturdiagramm des Befehlsmusters:

Einführung

Absicht

Kapselt eine Anfrage als Objekt und ermöglicht Benutzern, Clients mit unterschiedlichen Anfragen zu parametrisieren.

Behandelte Hauptprobleme

  • Löst das Problem der engen Kopplung zwischen Anforderern und Ausführenden in Softwaresystemen, insbesondere in Szenarien, in denen Verhalten aufgezeichnet, rückgängig gemacht/wiederhergestellt oder transaktional verarbeitet werden müssen.

Anwendungsfall

  • Wenn Verhalten aufgezeichnet, rückgängig gemacht/wiederhergestellt oder transaktional verarbeitet werden muss, verwende das Command-Muster, um Anforderer und Ausführende zu entkoppeln.

Implementierungsansatz

  • Definiere die Befehlsschnittstelle: Die Schnittstelle, die alle Befehle implementieren müssen.
  • Erstelle konkrete BefehleKonkrete Klassen, die die Befehlsschnittstelle implementieren und Methoden zum Ausführen von Anfragen enthalten.
  • Aufrufer: Hält Befehlsobjekte und löst die Ausführung von Befehlen aus.
  • Empfänger: Das Objekt, das den Befehl ausführt.

Schlüsselcode

  • Empfänger: Das tatsächliche Objekt, das den Befehl ausführt.
  • Befehl: Die Schnittstelle, die die Befehlsausführung definiert.
  • Invoker: Der Einstiegspunkt für die Verwendung von Befehlsobjekten.

Anwendungsbeispiel

  • Struts 1ActionServlet dient als Invoker, und die Klassen der Modellschicht dienen als konkrete Befehle.

Vorteile

  1. Kopplung reduzieren: Die Kopplung zwischen Anforderern und Ausführenden wird reduziert.
  2. Einfach zu erweitern: Neue Befehle können einfach zum System hinzugefügt werden.

Nachteile

  • Zu viele Befehlsklassen⟧: Das System kann zu viele konkrete Befehlsklassen haben, was die Systemkomplexität erhöht.: The system may have too many concrete command classes, increasing system complexity.

Verwendungshinweise

  • In einer GUI kann jeder Button oder Menüeintrag als ein Befehl betrachtet werden.
  • Verwenden Sie das Befehlsmuster in Szenarien, in denen Kommandozeilenoperationen simuliert werden müssen.

Hinweise

  • Wenn das System Undo- und Redo-Operationen für Befehle unterstützen muss, ist das Befehlsmuster eine geeignete Wahl.

Struktur

Es umfasst hauptsächlich die folgenden Kernrollen:

  • Befehl:

    • Definiert die Schnittstelle zum Ausführen von Operationen, die typischerweise eineexecuteMethode enthält, die verwendet wird, um bestimmte Operationen aufzurufen.

  • ConcreteCommand:

    • Implementiert die Befehlsschnittstelle und ist für die Ausführung bestimmter Operationen verantwortlich. Sie enthält normalerweise eine Referenz auf den Empfänger und erledigt die Anforderungsbehandlung, indem sie die Methoden des Empfängers aufruft.

  • Empfänger:

    • Weiß, wie Operationen im Zusammenhang mit der Anforderung ausgeführt werden; das Objekt, das den Befehl tatsächlich ausführt.

  • Invoker:

    • Das Objekt, das Befehle sendet; es enthält ein Befehlsobjekt und kann die Ausführung des Befehls auslösen. Der Invoker bearbeitet Anforderungen nicht direkt, sondern implementiert dies, indem er die Anforderung an das Befehlsobjekt weitergibt.

  • Client:

    • Erstellen Sie konkrete Befehlsobjekte und legen Sie deren Empfänger fest; übergeben Sie die Befehlsobjekte zur Ausführung an den Invoker.

Implementierung

Zuerst erstellen wir eine Schnittstelle als BefehlOrder, dann erstellen wir die AnfrageStockKlasse. Konkrete BefehlsklasseBuyStockundSellStock, implementiertOrderdie Schnittstelle, die die eigentliche Befehlsverarbeitung durchführt. Erstellen Sie eine Klasse als aufrufendes Objekt.Broker, die einen Auftrag annimmt und einen Auftrag erteilen kann.

BrokerObjekte verwenden das Befehlsmuster und bestimmen anhand des Befehlstyps, welches Objekt welchen Befehl ausführt.CommandPatternDemoKlassenverwendungBrokerKlasse, um das Befehlsmuster zu demonstrieren.

Schritt 1

Erstellen Sie eine Befehlsschnittstelle.

Order.java

public interface Order { void execute(); }

Schritt 2

Erstellen Sie eine Anfrageklasse.

Stock.java

public class Stock { private String name = "ABC"; private int quantity = 10; public void buy(){ System.out.println("Aktie [ Name: "+name+", Menge: " + quantity +" ] gekauft"); } public void sell(){ System.out.println("Aktie [ Name: "+name+", Menge: " + quantity +" ] verkauft"); } }

Schritt 3

Implementierung erstellenOrderKonkrete Implementierungsklasse des Interfaces.

BuyStock.java

public class BuyStock implements Order { private Stock abcStock; public BuyStock(Stock abcStock){ this.abcStock = abcStock; } public void execute() { abcStock.buy(); } }

SellStock.java

public class SellStock implements Order { private Stock abcStock; public SellStock(Stock abcStock){ this.abcStock = abcStock; } public void execute() { abcStock.sell(); } }

Schritt 4

Erstellen Sie eine Command-Invoker-Klasse.

Broker.java

import java.util.ArrayList; import java.util.List; public class Broker { private List<Order> orderList = new ArrayList<Order>(); public void takeOrder(Order order){ orderList.add(order); } public void placeOrders(){ for (Order order : orderList) { order.execute(); } orderList.clear(); } }

Schritt 5

Verwenden Sie eine Broker-Klasse, um Befehle anzunehmen und auszuführen.

CommandPatternDemo.java

public class CommandPatternDemo { public static void main(String[] args) { Stock abcStock = new Stock(); BuyStock buyStockOrder = new BuyStock(abcStock); SellStock sellStockOrder = new SellStock(abcStock); Broker broker = new Broker(); broker.takeOrder(buyStockOrder); broker.takeOrder(sellStockOrder); broker.placeOrders(); } }

Schritt 6

Führen Sie das Programm aus, Ausgabeergebnis:

Stock [ Name: ABC, Quantity: 10 ] bought
Stock [ Name: ABC, Quantity: 10 ] sold
Weitere Erweiterungen