Patron Commande

Le patron de commande est un patron de conception piloté par les données qui appartient aux patrons comportementaux.

Le patron de commande encapsule une requête sous forme d'objet, ce qui permet de paramétrer des clients avec différentes requêtes, de mettre en file d'attente ou de journaliser des requêtes, et de prendre en charge des opérations annulables.

Diagramme de structure du patron de commande:

Introduction

intention

Encapsuler une requête sous forme d'objet, permettant aux utilisateurs de paramétrer des clients avec différentes requêtes.

Principaux problèmes traités

  • Résout le problème de couplage fort entre les demandeurs et les exécuteurs dans les systèmes logiciels, en particulier dans les scénarios où les comportements doivent être enregistrés, annulés/rétablis ou traités de manière transactionnelle.

Cas d'utilisation

  • Lorsque des comportements doivent être enregistrés, annulés/rétablis ou traités de manière transactionnelle, utilisez le patron Commande pour découpler les demandeurs et les exécutants.

Approche d'implémentation

  • Définir l'interface de commande: l'interface que toutes les commandes doivent implémenter.
  • Créer des commandes concrètes: des classes concrètes qui implémentent l'interface de commande, contenant des méthodes pour exécuter des requêtes.
  • Appelant: détient des objets de commande et déclenche l'exécution des commandes.
  • récepteur: l'objet qui exécute réellement la commande.

Code clé

  • Récepteur: l'objet réel qui exécute la commande.
  • Commande: l'interface qui définit l'exécution des commandes.
  • Invocateur: le point d'entrée pour utiliser des objets de commande.

Exemple d'application

  • Struts 1ActionServlet sert d'Invocateur, et les classes de la couche modèle servent de Commandes concrètes.

Avantages

  1. Réduire le couplage: le couplage entre les demandeurs et les exécutants est réduit.
  2. Facile à étendre: de nouvelles commandes peuvent être facilement ajoutées au système.

Inconvénients

  • Trop de classes de commande: le système peut avoir trop de classes de commande concrètes, ce qui augmente la complexité du système.

Suggestions d'utilisation

  • Dans une interface graphique, chaque bouton ou élément de menu peut être considéré comme une commande.
  • Utilisez le patron de conception Commande dans les scénarios où des opérations en ligne de commande doivent être simulées.

Notes

  • Si le système doit prendre en charge les opérations Annuler et Rétablir, le patron de conception Commande est un choix approprié.

Structure

Il implique principalement les rôles principaux suivants :

  • Commande :

    • Définit l'interface pour l'exécution d'opérations, contenant généralement uneexecuteméthode utilisée pour invoquer des opérations spécifiques.

  • Commande concrète :

    • Implémente l'interface de commande, responsable de l'exécution d'opérations spécifiques. Elle contient généralement une référence au récepteur et gère la requête en appelant les méthodes du récepteur.

  • Récepteur :

    • Sait comment exécuter les opérations liées à la requête ; l'objet qui exécute réellement la commande.

  • Invocateur :

    • L'objet qui envoie les commandes ; il contient un objet de commande et peut déclencher l'exécution de la commande. L'invocateur ne traite pas directement les requêtes, mais le fait en transmettant la requête à l'objet de commande.

  • Client :

    • Créez des objets de commande concrets et définissez leurs récepteurs, puis confiez les objets de commande à l'invocateur pour exécution.

Implémentation

Nous créons d'abord une interface comme la commandeOrder, puis créons la requêteStockClasse. Classe de commande concrèteBuyStocketSellStock, implémenteOrderL'interface, qui effectuera le traitement réel de la commande. Créez une classe comme objet invocateur.Broker, qui accepte une commande et peut passer une commande.

BrokerLes objets utilisent le modèle de commande, déterminant quel objet exécute quelle commande en fonction du type de commande.CommandPatternDemoUtilisation de la classeBrokerclasse pour démontrer le modèle de commande.

Étape 1

Créer une interface de commande.

Order.java

public interface Order { void execute(); }

Étape 2

Créer une classe de requête.

Stock.java

public class Stock { private String name = "ABC"; private int quantity = 10; public void buy(){ System.out.println("Stock [ Nom: "+name+", Quantité: " + quantity +" ] acheté"); } public void sell(){ System.out.println("Stock [ Nom: "+name+", Quantité: " + quantity +" ] vendu"); } }

Étape 3

Créer une implémentationOrderClasse d'implémentation concrète de l'interface.

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

Étape 4

Créer une classe d'invocateur de commande.

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

Étape 5

Utilisez une classe Broker pour accepter et exécuter des commandes.

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

Étape 6

Exécutez le programme, résultat de sortie :

Stock [ Name: ABC, Quantity: 10 ] bought
Stock [ Name: ABC, Quantity: 10 ] sold
autres extensions